# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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
if 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('_mforms', [dirname(__file__)])
        except ImportError:
            import _mforms
            return _mforms
        if fp is not None:
            try:
                _mod = imp.load_module('_mforms', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _mforms = swig_import_helper()
    del swig_import_helper
else:
    import _mforms
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


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

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

    def value(self):
        return _mforms.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _mforms.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _mforms.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _mforms.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _mforms.SwigPyIterator_equal(self, x)

    def copy(self):
        return _mforms.SwigPyIterator_copy(self)

    def next(self):
        return _mforms.SwigPyIterator_next(self)

    def __next__(self):
        return _mforms.SwigPyIterator___next__(self)

    def previous(self):
        return _mforms.SwigPyIterator_previous(self)

    def advance(self, n):
        return _mforms.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _mforms.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _mforms.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _mforms.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _mforms.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _mforms.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _mforms.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _mforms.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

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

    def iterator(self):
        return _mforms.doubleList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mforms.doubleList___nonzero__(self)

    def __bool__(self):
        return _mforms.doubleList___bool__(self)

    def __len__(self):
        return _mforms.doubleList___len__(self)

    def __getslice__(self, i, j):
        return _mforms.doubleList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mforms.doubleList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mforms.doubleList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mforms.doubleList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mforms.doubleList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mforms.doubleList___setitem__(self, *args)

    def pop(self):
        return _mforms.doubleList_pop(self)

    def append(self, x):
        return _mforms.doubleList_append(self, x)

    def empty(self):
        return _mforms.doubleList_empty(self)

    def size(self):
        return _mforms.doubleList_size(self)

    def swap(self, v):
        return _mforms.doubleList_swap(self, v)

    def begin(self):
        return _mforms.doubleList_begin(self)

    def end(self):
        return _mforms.doubleList_end(self)

    def rbegin(self):
        return _mforms.doubleList_rbegin(self)

    def rend(self):
        return _mforms.doubleList_rend(self)

    def clear(self):
        return _mforms.doubleList_clear(self)

    def get_allocator(self):
        return _mforms.doubleList_get_allocator(self)

    def pop_back(self):
        return _mforms.doubleList_pop_back(self)

    def erase(self, *args):
        return _mforms.doubleList_erase(self, *args)

    def __init__(self, *args):
        this = _mforms.new_doubleList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _mforms.doubleList_push_back(self, x)

    def front(self):
        return _mforms.doubleList_front(self)

    def back(self):
        return _mforms.doubleList_back(self)

    def assign(self, n, x):
        return _mforms.doubleList_assign(self, n, x)

    def resize(self, *args):
        return _mforms.doubleList_resize(self, *args)

    def insert(self, *args):
        return _mforms.doubleList_insert(self, *args)

    def pop_front(self):
        return _mforms.doubleList_pop_front(self)

    def push_front(self, x):
        return _mforms.doubleList_push_front(self, x)

    def reverse(self):
        return _mforms.doubleList_reverse(self)
    __swig_destroy__ = _mforms.delete_doubleList
    __del__ = lambda self: None
doubleList_swigregister = _mforms.doubleList_swigregister
doubleList_swigregister(doubleList)


# flake8: noqa

def newLabel(*args):
    c = Label(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newButton(*args):
    c = Button(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newCheckBox(*args):
    c = CheckBox(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newCodeEditor(*args):
    c = CodeEditor(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTextEntry(*args):
    c = TextEntry(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTextBox(*args):
    c = TextBox(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newSelector(*args):
    c = Selector(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newListBox(*args):
    c = ListBox(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTabView(*args):
    c = TabView(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newBox(*args):
    c = Box(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newPanel(*args):
    c = Panel(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newFileChooser(*args):
    c = FileChooser(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newRadioButton(*args):
    c = RadioButton(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newImageBox(*args):
    c = ImageBox(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newProgressBar(*args):
    c = ProgressBar(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTable(*args):
    c = Table(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newScrollPanel(*args):
    c = ScrollPanel(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTreeView(*args):
    c = TreeView(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newAppView(*args):
    c = AppView(*args)
    return c

def newDrawBox(*args):
    c = DrawBox(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTabSwitcher(*args):
    c = TabSwitcher(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newSectionBox(*args):
    c = SectionBox(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newWidgetSeparator(*args):
    c = WidgetSeparator(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newHeartbeatWidget(*args):
    c = HeartbeatWidget(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newServerStatusWidget(*args):
    c = ServerStatusWidget(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newBarGraphWidget(*args):
    c = BarGraphWidget(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newLineDiagramWidget(*args):
    c = LineDiagramWidget(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newWebBrowser(*args):
    c = WebBrowser(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newPopup(*args):
    c = Popup(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newPopover(*args):
    c = Popover(*args)
    c.set_managed()
    c.release()
    return c

def newSplitter(*args):
    c = Splitter(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newTaskSidebar(*args):
    c = TaskSidebar.create(*args)
    c.set_managed()
    c.set_release_on_add()
    return c


def newHyperText(*args):
    c = HyperText(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newContextMenu(*args):
    c = ContextMenu(*args)
    c.set_managed()
    return c

def newMenuItem(*args):
    c = MenuItem(*args)
    c.set_managed()
    c.set_release_on_add()
    return c

def newToolBar(*args):
    c = ToolBar(*args)
    c.set_managed()
    return c

def newToolBarItem(*args):
    c = ToolBarItem(*args)
    c.set_managed()
    c.set_release_on_add()
    return c


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

    def retain(self):
        return _mforms.Object_retain(self)

    def release(self):
        return _mforms.Object_release(self)

    def set_managed(self):
        return _mforms.Object_set_managed(self)

    def set_release_on_add(self, flag=True):
        return _mforms.Object_set_release_on_add(self, flag)

    def is_managed(self):
        return _mforms.Object_is_managed(self)

    def release_on_add(self):
        return _mforms.Object_release_on_add(self)

    def retain_count(self):
        return _mforms.Object_retain_count(self)

    def set_destroying(self):
        return _mforms.Object_set_destroying(self)

    def is_destroying(self):
        return _mforms.Object_is_destroying(self)

    def __init__(self):
        this = _mforms.new_Object()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_Object
    __del__ = lambda self: None
Object_swigregister = _mforms.Object_swigregister
Object_swigregister(Object)


_mforms.NoAlign_swigconstant(_mforms)
NoAlign = _mforms.NoAlign

_mforms.BottomLeft_swigconstant(_mforms)
BottomLeft = _mforms.BottomLeft

_mforms.BottomCenter_swigconstant(_mforms)
BottomCenter = _mforms.BottomCenter

_mforms.BottomRight_swigconstant(_mforms)
BottomRight = _mforms.BottomRight

_mforms.MiddleLeft_swigconstant(_mforms)
MiddleLeft = _mforms.MiddleLeft

_mforms.MiddleCenter_swigconstant(_mforms)
MiddleCenter = _mforms.MiddleCenter

_mforms.MiddleRight_swigconstant(_mforms)
MiddleRight = _mforms.MiddleRight

_mforms.TopLeft_swigconstant(_mforms)
TopLeft = _mforms.TopLeft

_mforms.TopCenter_swigconstant(_mforms)
TopCenter = _mforms.TopCenter

_mforms.TopRight_swigconstant(_mforms)
TopRight = _mforms.TopRight

_mforms.WizardLabelAlignment_swigconstant(_mforms)
WizardLabelAlignment = _mforms.WizardLabelAlignment
class TextAttributes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextAttributes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TextAttributes, name)
    __repr__ = _swig_repr

    def __init__(self, c, b, i):
        this = _mforms.new_TextAttributes(c, b, i)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_TextAttributes
    __del__ = lambda self: None
TextAttributes_swigregister = _mforms.TextAttributes_swigregister
TextAttributes_swigregister(TextAttributes)
cvar = _mforms.cvar
DragFormatText = cvar.DragFormatText
DragFormatFileName = cvar.DragFormatFileName


_mforms.MouseButtonLeft_swigconstant(_mforms)
MouseButtonLeft = _mforms.MouseButtonLeft

_mforms.MouseButtonRight_swigconstant(_mforms)
MouseButtonRight = _mforms.MouseButtonRight

_mforms.MouseButtonOther_swigconstant(_mforms)
MouseButtonOther = _mforms.MouseButtonOther

_mforms.MouseButtonNone_swigconstant(_mforms)
MouseButtonNone = _mforms.MouseButtonNone

_mforms.DragOperationNone_swigconstant(_mforms)
DragOperationNone = _mforms.DragOperationNone

_mforms.DragOperationCopy_swigconstant(_mforms)
DragOperationCopy = _mforms.DragOperationCopy

_mforms.DragOperationMove_swigconstant(_mforms)
DragOperationMove = _mforms.DragOperationMove

_mforms.DragOperationAll_swigconstant(_mforms)
DragOperationAll = _mforms.DragOperationAll

_mforms.DropPositionUnknown_swigconstant(_mforms)
DropPositionUnknown = _mforms.DropPositionUnknown

_mforms.DropPositionLeft_swigconstant(_mforms)
DropPositionLeft = _mforms.DropPositionLeft

_mforms.DropPositionRight_swigconstant(_mforms)
DropPositionRight = _mforms.DropPositionRight

_mforms.DropPositionOn_swigconstant(_mforms)
DropPositionOn = _mforms.DropPositionOn

_mforms.DropPositionTop_swigconstant(_mforms)
DropPositionTop = _mforms.DropPositionTop

_mforms.DropPositionBottom_swigconstant(_mforms)
DropPositionBottom = _mforms.DropPositionBottom
class DragDetails(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DragDetails, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DragDetails, name)
    __repr__ = _swig_repr
    __swig_setmethods__["location"] = _mforms.DragDetails_location_set
    __swig_getmethods__["location"] = _mforms.DragDetails_location_get
    if _newclass:
        location = _swig_property(_mforms.DragDetails_location_get, _mforms.DragDetails_location_set)
    __swig_setmethods__["allowedOperations"] = _mforms.DragDetails_allowedOperations_set
    __swig_getmethods__["allowedOperations"] = _mforms.DragDetails_allowedOperations_get
    if _newclass:
        allowedOperations = _swig_property(_mforms.DragDetails_allowedOperations_get, _mforms.DragDetails_allowedOperations_set)
    __swig_setmethods__["image"] = _mforms.DragDetails_image_set
    __swig_getmethods__["image"] = _mforms.DragDetails_image_get
    if _newclass:
        image = _swig_property(_mforms.DragDetails_image_get, _mforms.DragDetails_image_set)
    __swig_setmethods__["hotspot"] = _mforms.DragDetails_hotspot_set
    __swig_getmethods__["hotspot"] = _mforms.DragDetails_hotspot_get
    if _newclass:
        hotspot = _swig_property(_mforms.DragDetails_hotspot_get, _mforms.DragDetails_hotspot_set)

    def __init__(self):
        this = _mforms.new_DragDetails()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_DragDetails
    __del__ = lambda self: None
DragDetails_swigregister = _mforms.DragDetails_swigregister
DragDetails_swigregister(DragDetails)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mforms.delete_View
    __del__ = lambda self: None

    def find_subview(self, name):
        return _mforms.View_find_subview(self, name)

    def contains_subview(self, subview):
        return _mforms.View_contains_subview(self, subview)

    def clear_subviews(self):
        return _mforms.View_clear_subviews(self)

    def set_name(self, name):
        return _mforms.View_set_name(self, name)

    def set_tooltip(self, text):
        return _mforms.View_set_tooltip(self, text)

    def set_font(self, fontDescription):
        return _mforms.View_set_font(self, fontDescription)

    def get_name(self):
        return _mforms.View_get_name(self)

    def set_parent(self, parent):
        return _mforms.View_set_parent(self, parent)

    def get_parent(self):
        return _mforms.View_get_parent(self)

    def get_parent_form(self):
        return _mforms.View_get_parent_form(self)

    def get_width(self):
        return _mforms.View_get_width(self)

    def get_height(self):
        return _mforms.View_get_height(self)

    def get_preferred_width(self):
        return _mforms.View_get_preferred_width(self)

    def get_preferred_height(self):
        return _mforms.View_get_preferred_height(self)

    def get_x(self):
        return _mforms.View_get_x(self)

    def get_y(self):
        return _mforms.View_get_y(self)

    def set_position(self, x, y):
        return _mforms.View_set_position(self, x, y)

    def set_size(self, width, height):
        return _mforms.View_set_size(self, width, height)

    def set_min_size(self, width, height):
        return _mforms.View_set_min_size(self, width, height)

    def client_to_screen(self, x, y):
        return _mforms.View_client_to_screen(self, x, y)

    def screen_to_client(self, x, y):
        return _mforms.View_screen_to_client(self, x, y)

    def show(self, flag=True):
        return _mforms.View_show(self, flag)

    def is_shown(self):
        return _mforms.View_is_shown(self)

    def is_fully_visible(self):
        return _mforms.View_is_fully_visible(self)

    def set_enabled(self, flag):
        return _mforms.View_set_enabled(self, flag)

    def is_enabled(self):
        return _mforms.View_is_enabled(self)

    def set_needs_repaint(self):
        return _mforms.View_set_needs_repaint(self)

    def relayout(self):
        return _mforms.View_relayout(self)

    def set_layout_dirty(self, value):
        return _mforms.View_set_layout_dirty(self, value)

    def is_layout_dirty(self):
        return _mforms.View_is_layout_dirty(self)

    def suspend_layout(self):
        return _mforms.View_suspend_layout(self)

    def resume_layout(self):
        return _mforms.View_resume_layout(self)

    def set_front_color(self, color):
        return _mforms.View_set_front_color(self, color)

    def get_front_color(self):
        return _mforms.View_get_front_color(self)

    def set_back_color(self, color):
        return _mforms.View_set_back_color(self, color)

    def get_back_color(self):
        return _mforms.View_get_back_color(self)

    def get_string_value(self):
        return _mforms.View_get_string_value(self)

    def get_int_value(self):
        return _mforms.View_get_int_value(self)

    def get_bool_value(self):
        return _mforms.View_get_bool_value(self)

    def flush_events(self):
        return _mforms.View_flush_events(self)

    def focus(self):
        return _mforms.View_focus(self)

    def has_focus(self):
        return _mforms.View_has_focus(self)

    def focus_changed(self):
        return _mforms.View_focus_changed(self)

    def resize(self):
        return _mforms.View_resize(self)

    def signal_resized(self):
        return _mforms.View_signal_resized(self)

    def signal_mouse_leave(self):
        return _mforms.View_signal_mouse_leave(self)

    def signal_got_focus(self):
        return _mforms.View_signal_got_focus(self)
View_swigregister = _mforms.View_swigregister
View_swigregister(View)

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

    def __init__(self):
        this = _mforms.new_Container()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_padding(self, *args):
        return _mforms.Container_set_padding(self, *args)

    def set_back_image(self, path, alignment):
        return _mforms.Container_set_back_image(self, path, alignment)
    __swig_destroy__ = _mforms.delete_Container
    __del__ = lambda self: None
Container_swigregister = _mforms.Container_swigregister
Container_swigregister(Container)


_mforms.TOP_FORM_PADDING_swigconstant(_mforms)
TOP_FORM_PADDING = _mforms.TOP_FORM_PADDING

_mforms.FormNone_swigconstant(_mforms)
FormNone = _mforms.FormNone

_mforms.FormSingleFrame_swigconstant(_mforms)
FormSingleFrame = _mforms.FormSingleFrame

_mforms.FormDialogFrame_swigconstant(_mforms)
FormDialogFrame = _mforms.FormDialogFrame

_mforms.FormResizable_swigconstant(_mforms)
FormResizable = _mforms.FormResizable

_mforms.FormMinimizable_swigconstant(_mforms)
FormMinimizable = _mforms.FormMinimizable

_mforms.FormHideOnClose_swigconstant(_mforms)
FormHideOnClose = _mforms.FormHideOnClose

_mforms.FormStayOnTop_swigconstant(_mforms)
FormStayOnTop = _mforms.FormStayOnTop

_mforms.FormToolWindow_swigconstant(_mforms)
FormToolWindow = _mforms.FormToolWindow

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

    def __init__(self, *args):
        this = _mforms.new_Form(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_Form
    __del__ = lambda self: None
    __swig_getmethods__["main_form"] = lambda x: _mforms.Form_main_form
    if _newclass:
        main_form = staticmethod(_mforms.Form_main_form)
    __swig_getmethods__["active_form"] = lambda x: _mforms.Form_active_form
    if _newclass:
        active_form = staticmethod(_mforms.Form_active_form)

    def set_content(self, view):
        return _mforms.Form_set_content(self, view)

    def get_content(self):
        return _mforms.Form_get_content(self)

    def set_title(self, title):
        return _mforms.Form_set_title(self, title)

    def set_menubar(self, menu):
        return _mforms.Form_set_menubar(self, menu)

    def get_menubar(self):
        return _mforms.Form_get_menubar(self)

    def show_modal(self, accept, cancel):
        return _mforms.Form_show_modal(self, accept, cancel)

    def run_modal(self, accept, cancel):
        return _mforms.Form_run_modal(self, accept, cancel)

    def end_modal(self, result):
        return _mforms.Form_end_modal(self, result)

    def close(self):
        return _mforms.Form_close(self)

    def center(self):
        return _mforms.Form_center(self)

    def set_release_on_close(self, flag):
        return _mforms.Form_set_release_on_close(self, flag)

    def is_active(self):
        return _mforms.Form_is_active(self)

    def can_close(self):
        return _mforms.Form_can_close(self)

    def was_closed(self):
        return _mforms.Form_was_closed(self)

    def set_on_close(self, callback):
        return _mforms.Form_set_on_close(self, callback)

    def add_closed_callback(self, callback):
        return _mforms.Form_add_closed_callback(self, callback)

    def call_closed_callback(self):
        return _mforms.Form_call_closed_callback(self)

    def add_activated_callback(self, callback):
        return _mforms.Form_add_activated_callback(self, callback)

    def call_activated_callback(self):
        return _mforms.Form_call_activated_callback(self)

    def add_deactivated_callback(self, callback):
        return _mforms.Form_add_deactivated_callback(self, callback)

    def call_deactivated_callback(self):
        return _mforms.Form_call_deactivated_callback(self)
Form_swigregister = _mforms.Form_swigregister
Form_swigregister(Form)

def Form_main_form():
    return _mforms.Form_main_form()
Form_main_form = _mforms.Form_main_form

def Form_active_form():
    return _mforms.Form_active_form()
Form_active_form = _mforms.Form_active_form


_mforms.PushButton_swigconstant(_mforms)
PushButton = _mforms.PushButton

_mforms.ToolButton_swigconstant(_mforms)
ToolButton = _mforms.ToolButton

_mforms.AdminActionButton_swigconstant(_mforms)
AdminActionButton = _mforms.AdminActionButton

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

    def __init__(self, *args):
        this = _mforms.new_Button(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def enable_internal_padding(self, flag):
        return _mforms.Button_enable_internal_padding(self, flag)

    def set_text(self, text):
        return _mforms.Button_set_text(self, text)

    def set_icon(self, icon):
        return _mforms.Button_set_icon(self, icon)

    def add_clicked_callback(self, callback):
        return _mforms.Button_add_clicked_callback(self, callback)

    def call_clicked_callback(self):
        return _mforms.Button_call_clicked_callback(self)
    __swig_destroy__ = _mforms.delete_Button
    __del__ = lambda self: None
Button_swigregister = _mforms.Button_swigregister
Button_swigregister(Button)

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

    def __init__(self, square=False):
        this = _mforms.new_CheckBox(square)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_active(self, flag):
        return _mforms.CheckBox_set_active(self, flag)

    def get_active(self):
        return _mforms.CheckBox_get_active(self)
    __swig_destroy__ = _mforms.delete_CheckBox
    __del__ = lambda self: None
CheckBox_swigregister = _mforms.CheckBox_swigregister
CheckBox_swigregister(CheckBox)


_mforms.NormalEntry_swigconstant(_mforms)
NormalEntry = _mforms.NormalEntry

_mforms.PasswordEntry_swigconstant(_mforms)
PasswordEntry = _mforms.PasswordEntry

_mforms.SearchEntry_swigconstant(_mforms)
SearchEntry = _mforms.SearchEntry

_mforms.SmallSearchEntry_swigconstant(_mforms)
SmallSearchEntry = _mforms.SmallSearchEntry

_mforms.EntryActivate_swigconstant(_mforms)
EntryActivate = _mforms.EntryActivate

_mforms.EntryEscape_swigconstant(_mforms)
EntryEscape = _mforms.EntryEscape

_mforms.EntryKeyUp_swigconstant(_mforms)
EntryKeyUp = _mforms.EntryKeyUp

_mforms.EntryKeyDown_swigconstant(_mforms)
EntryKeyDown = _mforms.EntryKeyDown

_mforms.EntryCKeyUp_swigconstant(_mforms)
EntryCKeyUp = _mforms.EntryCKeyUp

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

    def __init__(self, *args):
        this = _mforms.new_TextEntry(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_max_length(self, len):
        return _mforms.TextEntry_set_max_length(self, len)

    def set_value(self, text):
        return _mforms.TextEntry_set_value(self, text)

    def set_read_only(self, flag):
        return _mforms.TextEntry_set_read_only(self, flag)

    def set_placeholder_text(self, text):
        return _mforms.TextEntry_set_placeholder_text(self, text)

    def set_placeholder_color(self, color):
        return _mforms.TextEntry_set_placeholder_color(self, color)

    def set_bordered(self, flag):
        return _mforms.TextEntry_set_bordered(self, flag)

    def cut(self):
        return _mforms.TextEntry_cut(self)

    def copy(self):
        return _mforms.TextEntry_copy(self)

    def paste(self):
        return _mforms.TextEntry_paste(self)

    def select(self, arg2):
        return _mforms.TextEntry_select(self, arg2)

    def get_selection(self):
        return _mforms.TextEntry_get_selection(self)

    def add_changed_callback(self, callback):
        return _mforms.TextEntry_add_changed_callback(self, callback)

    def call_changed_callback(self):
        return _mforms.TextEntry_call_changed_callback(self)

    def add_action_callback(self, callback):
        return _mforms.TextEntry_add_action_callback(self, callback)
    __swig_destroy__ = _mforms.delete_TextEntry
    __del__ = lambda self: None
TextEntry_swigregister = _mforms.TextEntry_swigregister
TextEntry_swigregister(TextEntry)


_mforms.NoScrollBar_swigconstant(_mforms)
NoScrollBar = _mforms.NoScrollBar

_mforms.HorizontalScrollBar_swigconstant(_mforms)
HorizontalScrollBar = _mforms.HorizontalScrollBar

_mforms.VerticalScrollBar_swigconstant(_mforms)
VerticalScrollBar = _mforms.VerticalScrollBar

_mforms.BothScrollBars_swigconstant(_mforms)
BothScrollBars = _mforms.BothScrollBars

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

    def __init__(self, scroll_bars):
        this = _mforms.new_TextBox(scroll_bars)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_bordered(self, flag):
        return _mforms.TextBox_set_bordered(self, flag)

    def set_monospaced(self, flag):
        return _mforms.TextBox_set_monospaced(self, flag)

    def set_read_only(self, flag):
        return _mforms.TextBox_set_read_only(self, flag)

    def set_value(self, text):
        return _mforms.TextBox_set_value(self, text)

    def get_selected_range(self, start, end):
        return _mforms.TextBox_get_selected_range(self, start, end)

    def append_text(self, text, scroll_to_end=False):
        return _mforms.TextBox_append_text(self, text, scroll_to_end)

    def append_text_with_encoding(self, text, encoding, scroll_to_end=False):
        return _mforms.TextBox_append_text_with_encoding(self, text, encoding, scroll_to_end)

    def set_padding(self, pad):
        return _mforms.TextBox_set_padding(self, pad)

    def clear(self):
        return _mforms.TextBox_clear(self)

    def add_changed_callback(self, callback):
        return _mforms.TextBox_add_changed_callback(self, callback)

    def call_changed_callback(self):
        return _mforms.TextBox_call_changed_callback(self)

    def append_text_and_scroll(self, text, scroll_to_end):
        return _mforms.TextBox_append_text_and_scroll(self, text, scroll_to_end)

    def append_text_with_encoding_and_scroll(self, text, encoding, scroll_to_end):
        return _mforms.TextBox_append_text_with_encoding_and_scroll(self, text, encoding, scroll_to_end)
    __swig_destroy__ = _mforms.delete_TextBox
    __del__ = lambda self: None
TextBox_swigregister = _mforms.TextBox_swigregister
TextBox_swigregister(TextBox)


_mforms.NormalStyle_swigconstant(_mforms)
NormalStyle = _mforms.NormalStyle

_mforms.BoldStyle_swigconstant(_mforms)
BoldStyle = _mforms.BoldStyle

_mforms.SmallBoldStyle_swigconstant(_mforms)
SmallBoldStyle = _mforms.SmallBoldStyle

_mforms.BigStyle_swigconstant(_mforms)
BigStyle = _mforms.BigStyle

_mforms.BigBoldStyle_swigconstant(_mforms)
BigBoldStyle = _mforms.BigBoldStyle

_mforms.SmallStyle_swigconstant(_mforms)
SmallStyle = _mforms.SmallStyle

_mforms.VerySmallStyle_swigconstant(_mforms)
VerySmallStyle = _mforms.VerySmallStyle

_mforms.InfoCaptionStyle_swigconstant(_mforms)
InfoCaptionStyle = _mforms.InfoCaptionStyle

_mforms.BoldInfoCaptionStyle_swigconstant(_mforms)
BoldInfoCaptionStyle = _mforms.BoldInfoCaptionStyle

_mforms.WizardHeadingStyle_swigconstant(_mforms)
WizardHeadingStyle = _mforms.WizardHeadingStyle

_mforms.SmallHelpTextStyle_swigconstant(_mforms)
SmallHelpTextStyle = _mforms.SmallHelpTextStyle

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

    def __init__(self, text, right_align=False):
        this = _mforms.new_Label(text, right_align)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_wrap_text(self, flag):
        return _mforms.Label_set_wrap_text(self, flag)

    def set_text_align(self, align):
        return _mforms.Label_set_text_align(self, align)

    def set_text(self, text):
        return _mforms.Label_set_text(self, text)

    def set_style(self, style):
        return _mforms.Label_set_style(self, style)

    def set_color(self, color):
        return _mforms.Label_set_color(self, color)
    __swig_destroy__ = _mforms.delete_Label
    __del__ = lambda self: None
Label_swigregister = _mforms.Label_swigregister
Label_swigregister(Label)


_mforms.SelectorCombobox_swigconstant(_mforms)
SelectorCombobox = _mforms.SelectorCombobox

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

    def __init__(self, *args):
        this = _mforms.new_Selector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def clear(self):
        return _mforms.Selector_clear(self)

    def add_item(self, item):
        return _mforms.Selector_add_item(self, item)

    def add_items(self, items):
        return _mforms.Selector_add_items(self, items)

    def get_item_title(self, i):
        return _mforms.Selector_get_item_title(self, i)

    def set_selected(self, index):
        return _mforms.Selector_set_selected(self, index)

    def index_of_item_with_title(self, title):
        return _mforms.Selector_index_of_item_with_title(self, title)

    def get_selected_index(self):
        return _mforms.Selector_get_selected_index(self)

    def set_value(self, value):
        return _mforms.Selector_set_value(self, value)

    def get_item_count(self):
        return _mforms.Selector_get_item_count(self)

    def add_changed_callback(self, callback):
        return _mforms.Selector_add_changed_callback(self, callback)

    def call_changed_callback(self):
        return _mforms.Selector_call_changed_callback(self)
    __swig_destroy__ = _mforms.delete_Selector
    __del__ = lambda self: None
Selector_swigregister = _mforms.Selector_swigregister
Selector_swigregister(Selector)

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

    def __init__(self, multi):
        this = _mforms.new_ListBox(multi)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def clear(self):
        return _mforms.ListBox_clear(self)

    def set_heading(self, text):
        return _mforms.ListBox_set_heading(self, text)

    def add_item(self, item):
        return _mforms.ListBox_add_item(self, item)

    def add_items(self, items):
        return _mforms.ListBox_add_items(self, items)

    def remove_index(self, index):
        return _mforms.ListBox_remove_index(self, index)

    def remove_indexes(self, indexes):
        return _mforms.ListBox_remove_indexes(self, indexes)

    def set_selected(self, index):
        return _mforms.ListBox_set_selected(self, index)

    def get_selected_index(self):
        return _mforms.ListBox_get_selected_index(self)

    def get_selected_indices(self):
        return _mforms.ListBox_get_selected_indices(self)

    def get_count(self):
        return _mforms.ListBox_get_count(self)

    def get_string_value_from_index(self, index):
        return _mforms.ListBox_get_string_value_from_index(self, index)

    def add_changed_callback(self, callback):
        return _mforms.ListBox_add_changed_callback(self, callback)

    def call_changed_callback(self):
        return _mforms.ListBox_call_changed_callback(self)
    __swig_destroy__ = _mforms.delete_ListBox
    __del__ = lambda self: None
ListBox_swigregister = _mforms.ListBox_swigregister
ListBox_swigregister(ListBox)


_mforms.TabViewSystemStandard_swigconstant(_mforms)
TabViewSystemStandard = _mforms.TabViewSystemStandard

_mforms.TabViewTabless_swigconstant(_mforms)
TabViewTabless = _mforms.TabViewTabless

_mforms.TabViewMainClosable_swigconstant(_mforms)
TabViewMainClosable = _mforms.TabViewMainClosable

_mforms.TabViewDocument_swigconstant(_mforms)
TabViewDocument = _mforms.TabViewDocument

_mforms.TabViewDocumentClosable_swigconstant(_mforms)
TabViewDocumentClosable = _mforms.TabViewDocumentClosable

_mforms.TabViewDocumentClosableX_swigconstant(_mforms)
TabViewDocumentClosableX = _mforms.TabViewDocumentClosableX

_mforms.TabViewPalette_swigconstant(_mforms)
TabViewPalette = _mforms.TabViewPalette

_mforms.TabViewSelectorSecondary_swigconstant(_mforms)
TabViewSelectorSecondary = _mforms.TabViewSelectorSecondary

_mforms.TabViewEditorBottom_swigconstant(_mforms)
TabViewEditorBottom = _mforms.TabViewEditorBottom

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

    def __init__(self, *args):
        this = _mforms.new_TabView(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_TabView
    __del__ = lambda self: None

    def get_type(self):
        return _mforms.TabView_get_type(self)

    def set_active_tab(self, index):
        return _mforms.TabView_set_active_tab(self, index)

    def get_active_tab(self):
        return _mforms.TabView_get_active_tab(self)

    def add_page(self, page, caption, hasCloseButton=True):
        return _mforms.TabView_add_page(self, page, caption, hasCloseButton)

    def remove_page(self, page):
        return _mforms.TabView_remove_page(self, page)

    def set_tab_title(self, page, caption):
        return _mforms.TabView_set_tab_title(self, page, caption)

    def get_page_index(self, page):
        return _mforms.TabView_get_page_index(self, page)

    def get_page(self, index):
        return _mforms.TabView_get_page(self, index)

    def page_count(self):
        return _mforms.TabView_page_count(self)

    def can_close_tab(self, index):
        return _mforms.TabView_can_close_tab(self, index)

    def set_allows_reordering(self, flag):
        return _mforms.TabView_set_allows_reordering(self, flag)

    def set_tab_menu(self, menu):
        return _mforms.TabView_set_tab_menu(self, menu)

    def get_tab_menu(self):
        return _mforms.TabView_get_tab_menu(self)

    def get_menu_tab(self):
        return _mforms.TabView_get_menu_tab(self)

    def set_aux_view(self, view):
        return _mforms.TabView_set_aux_view(self, view)

    def get_aux_view(self):
        return _mforms.TabView_get_aux_view(self)

    def add_tab_changed_callback(self, callback):
        return _mforms.TabView_add_tab_changed_callback(self, callback)

    def call_tab_changed_callback(self):
        return _mforms.TabView_call_tab_changed_callback(self)

    def add_tab_closing_callback(self, callback):
        return _mforms.TabView_add_tab_closing_callback(self, callback)

    def call_tab_closing_callback(self, i):
        return _mforms.TabView_call_tab_closing_callback(self, i)
TabView_swigregister = _mforms.TabView_swigregister
TabView_swigregister(TabView)

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

    def __init__(self, horiz):
        this = _mforms.new_Box(horiz)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add(self, subview, expand, fill=True):
        return _mforms.Box_add(self, subview, expand, fill)

    def add_end(self, subview, expand, fill=True):
        return _mforms.Box_add_end(self, subview, expand, fill)

    def remove(self, subview):
        return _mforms.Box_remove(self, subview)

    def set_homogeneous(self, flag):
        return _mforms.Box_set_homogeneous(self, flag)

    def set_spacing(self, space):
        return _mforms.Box_set_spacing(self, space)

    def is_horizontal(self):
        return _mforms.Box_is_horizontal(self)
    __swig_destroy__ = _mforms.delete_Box
    __del__ = lambda self: None
Box_swigregister = _mforms.Box_swigregister
Box_swigregister(Box)


_mforms.TransparentPanel_swigconstant(_mforms)
TransparentPanel = _mforms.TransparentPanel

_mforms.FilledPanel_swigconstant(_mforms)
FilledPanel = _mforms.FilledPanel

_mforms.BorderedPanel_swigconstant(_mforms)
BorderedPanel = _mforms.BorderedPanel

_mforms.LineBorderPanel_swigconstant(_mforms)
LineBorderPanel = _mforms.LineBorderPanel

_mforms.TitledBoxPanel_swigconstant(_mforms)
TitledBoxPanel = _mforms.TitledBoxPanel

_mforms.TitledGroupPanel_swigconstant(_mforms)
TitledGroupPanel = _mforms.TitledGroupPanel

_mforms.FilledHeaderPanel_swigconstant(_mforms)
FilledHeaderPanel = _mforms.FilledHeaderPanel

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

    def __init__(self, type):
        this = _mforms.new_Panel(type)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_title(self, title):
        return _mforms.Panel_set_title(self, title)

    def set_back_color(self, color):
        return _mforms.Panel_set_back_color(self, color)

    def set_active(self, arg2):
        return _mforms.Panel_set_active(self, arg2)

    def get_active(self):
        return _mforms.Panel_get_active(self)

    def add(self, subview):
        return _mforms.Panel_add(self, subview)

    def remove(self, subview):
        return _mforms.Panel_remove(self, subview)
    __swig_destroy__ = _mforms.delete_Panel
    __del__ = lambda self: None
Panel_swigregister = _mforms.Panel_swigregister
Panel_swigregister(Panel)


_mforms.MainToolBar_swigconstant(_mforms)
MainToolBar = _mforms.MainToolBar

_mforms.SecondaryToolBar_swigconstant(_mforms)
SecondaryToolBar = _mforms.SecondaryToolBar

_mforms.ToolPickerToolBar_swigconstant(_mforms)
ToolPickerToolBar = _mforms.ToolPickerToolBar

_mforms.OptionsToolBar_swigconstant(_mforms)
OptionsToolBar = _mforms.OptionsToolBar

_mforms.PaletteToolBar_swigconstant(_mforms)
PaletteToolBar = _mforms.PaletteToolBar

_mforms.LabelItem_swigconstant(_mforms)
LabelItem = _mforms.LabelItem

_mforms.ActionItem_swigconstant(_mforms)
ActionItem = _mforms.ActionItem

_mforms.TextActionItem_swigconstant(_mforms)
TextActionItem = _mforms.TextActionItem

_mforms.TextEntryItem_swigconstant(_mforms)
TextEntryItem = _mforms.TextEntryItem

_mforms.ToggleItem_swigconstant(_mforms)
ToggleItem = _mforms.ToggleItem

_mforms.SegmentedToggleItem_swigconstant(_mforms)
SegmentedToggleItem = _mforms.SegmentedToggleItem

_mforms.SearchFieldItem_swigconstant(_mforms)
SearchFieldItem = _mforms.SearchFieldItem

_mforms.SelectorItem_swigconstant(_mforms)
SelectorItem = _mforms.SelectorItem

_mforms.FlatSelectorItem_swigconstant(_mforms)
FlatSelectorItem = _mforms.FlatSelectorItem

_mforms.ColorSelectorItem_swigconstant(_mforms)
ColorSelectorItem = _mforms.ColorSelectorItem

_mforms.SeparatorItem_swigconstant(_mforms)
SeparatorItem = _mforms.SeparatorItem

_mforms.ExpanderItem_swigconstant(_mforms)
ExpanderItem = _mforms.ExpanderItem

_mforms.ImageBoxItem_swigconstant(_mforms)
ImageBoxItem = _mforms.ImageBoxItem

_mforms.TitleItem_swigconstant(_mforms)
TitleItem = _mforms.TitleItem

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

    def __init__(self, *args):
        this = _mforms.new_ToolBar(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_ToolBar
    __del__ = lambda self: None

    def get_type(self):
        return _mforms.ToolBar_get_type(self)

    def get_items(self):
        return _mforms.ToolBar_get_items(self)

    def find_item(self, name):
        return _mforms.ToolBar_find_item(self, name)

    def set_item_enabled(self, name, flag):
        return _mforms.ToolBar_set_item_enabled(self, name, flag)

    def set_item_checked(self, name, flag):
        return _mforms.ToolBar_set_item_checked(self, name, flag)

    def get_item_checked(self, name):
        return _mforms.ToolBar_get_item_checked(self, name)

    def add_item(self, item):
        return _mforms.ToolBar_add_item(self, item)

    def insert_item(self, index, item):
        return _mforms.ToolBar_insert_item(self, index, item)

    def remove_all(self):
        return _mforms.ToolBar_remove_all(self)

    def remove_item(self, item):
        return _mforms.ToolBar_remove_item(self, item)

    def add_separator_item(self, *args):
        return _mforms.ToolBar_add_separator_item(self, *args)

    def validate(self):
        return _mforms.ToolBar_validate(self)
ToolBar_swigregister = _mforms.ToolBar_swigregister
ToolBar_swigregister(ToolBar)

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

    def __init__(self, *args):
        this = _mforms.new_ToolBarItem(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_type(self):
        return _mforms.ToolBarItem_get_type(self)

    def get_expandable(self):
        return _mforms.ToolBarItem_get_expandable(self)

    def set_text(self, text):
        return _mforms.ToolBarItem_set_text(self, text)

    def get_text(self):
        return _mforms.ToolBarItem_get_text(self)

    def set_tooltip(self, text):
        return _mforms.ToolBarItem_set_tooltip(self, text)

    def set_icon(self, path):
        return _mforms.ToolBarItem_set_icon(self, path)

    def get_icon(self):
        return _mforms.ToolBarItem_get_icon(self)

    def set_alt_icon(self, path):
        return _mforms.ToolBarItem_set_alt_icon(self, path)

    def get_alt_icon(self):
        return _mforms.ToolBarItem_get_alt_icon(self)

    def set_enabled(self, flag):
        return _mforms.ToolBarItem_set_enabled(self, flag)

    def get_enabled(self):
        return _mforms.ToolBarItem_get_enabled(self)

    def set_checked(self, flag):
        return _mforms.ToolBarItem_set_checked(self, flag)

    def get_checked(self):
        return _mforms.ToolBarItem_get_checked(self)

    def signal_activated(self):
        return _mforms.ToolBarItem_signal_activated(self)

    def set_name(self, name):
        return _mforms.ToolBarItem_set_name(self, name)

    def get_name(self):
        return _mforms.ToolBarItem_get_name(self)

    def set_selector_items(self, values):
        return _mforms.ToolBarItem_set_selector_items(self, values)

    def set_validator(self, slot):
        return _mforms.ToolBarItem_set_validator(self, slot)

    def set_search_handler(self, slot):
        return _mforms.ToolBarItem_set_search_handler(self, slot)

    def callback(self):
        return _mforms.ToolBarItem_callback(self)

    def validate(self):
        return _mforms.ToolBarItem_validate(self)

    def search(self, arg2):
        return _mforms.ToolBarItem_search(self, arg2)

    def add_activated_callback(self, callback):
        return _mforms.ToolBarItem_add_activated_callback(self, callback)
    __swig_destroy__ = _mforms.delete_ToolBarItem
    __del__ = lambda self: None
ToolBarItem_swigregister = _mforms.ToolBarItem_swigregister
ToolBarItem_swigregister(ToolBarItem)


_mforms.OpenFile_swigconstant(_mforms)
OpenFile = _mforms.OpenFile

_mforms.SaveFile_swigconstant(_mforms)
SaveFile = _mforms.SaveFile

_mforms.OpenDirectory_swigconstant(_mforms)
OpenDirectory = _mforms.OpenDirectory
class FileChooser(View):
    __swig_setmethods__ = {}
    for _s in [View]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileChooser, name, value)
    __swig_getmethods__ = {}
    for _s in [View]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileChooser, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_selector_options"] = _mforms.FileChooser__selector_options_set
    __swig_getmethods__["_selector_options"] = _mforms.FileChooser__selector_options_get
    if _newclass:
        _selector_options = _swig_property(_mforms.FileChooser__selector_options_get, _mforms.FileChooser__selector_options_set)

    def split_extensions(self, extensions, file_extensions=True):
        return _mforms.FileChooser_split_extensions(self, extensions, file_extensions)

    def __init__(self, *args):
        this = _mforms.new_FileChooser(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_title(self, title):
        return _mforms.FileChooser_set_title(self, title)

    def run_modal(self):
        return _mforms.FileChooser_run_modal(self)

    def set_directory(self, path):
        return _mforms.FileChooser_set_directory(self, path)

    def set_path(self, path):
        return _mforms.FileChooser_set_path(self, path)

    def get_path(self):
        return _mforms.FileChooser_get_path(self)

    def get_directory(self):
        return _mforms.FileChooser_get_directory(self)

    def set_extensions(self, extensions, default_extension, allow_all_file_types=True):
        return _mforms.FileChooser_set_extensions(self, extensions, default_extension, allow_all_file_types)

    def add_selector_option(self, *args):
        return _mforms.FileChooser_add_selector_option(self, *args)

    def get_selector_option_value(self, name):
        return _mforms.FileChooser_get_selector_option_value(self, name)
    __swig_setmethods__["last_directory"] = _mforms.FileChooser_last_directory_set
    __swig_getmethods__["last_directory"] = _mforms.FileChooser_last_directory_get
    if _newclass:
        last_directory = _swig_property(_mforms.FileChooser_last_directory_get, _mforms.FileChooser_last_directory_set)
    __swig_destroy__ = _mforms.delete_FileChooser
    __del__ = lambda self: None
FileChooser_swigregister = _mforms.FileChooser_swigregister
FileChooser_swigregister(FileChooser)

class RadioButton(Button):
    __swig_setmethods__ = {}
    for _s in [Button]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadioButton, name, value)
    __swig_getmethods__ = {}
    for _s in [Button]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RadioButton, name)
    __repr__ = _swig_repr
    __swig_getmethods__["new_id"] = lambda x: _mforms.RadioButton_new_id
    if _newclass:
        new_id = staticmethod(_mforms.RadioButton_new_id)

    def __init__(self, group_id):
        this = _mforms.new_RadioButton(group_id)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def group_id(self):
        return _mforms.RadioButton_group_id(self)

    def set_active(self, flag):
        return _mforms.RadioButton_set_active(self, flag)

    def get_active(self):
        return _mforms.RadioButton_get_active(self)

    def add_clicked_callback(self, callback):
        return _mforms.RadioButton_add_clicked_callback(self, callback)

    def call_clicked_callback(self):
        return _mforms.RadioButton_call_clicked_callback(self)
    __swig_destroy__ = _mforms.delete_RadioButton
    __del__ = lambda self: None
RadioButton_swigregister = _mforms.RadioButton_swigregister
RadioButton_swigregister(RadioButton)

def RadioButton_new_id():
    return _mforms.RadioButton_new_id()
RadioButton_new_id = _mforms.RadioButton_new_id

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

    def __init__(self):
        this = _mforms.new_ImageBox()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_image(self, file):
        return _mforms.ImageBox_set_image(self, file)

    def set_scale_contents(self, flag):
        return _mforms.ImageBox_set_scale_contents(self, flag)

    def set_image_align(self, alignment):
        return _mforms.ImageBox_set_image_align(self, alignment)
    __swig_destroy__ = _mforms.delete_ImageBox
    __del__ = lambda self: None
ImageBox_swigregister = _mforms.ImageBox_swigregister
ImageBox_swigregister(ImageBox)

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

    def __init__(self):
        this = _mforms.new_ProgressBar()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_indeterminate(self, flag):
        return _mforms.ProgressBar_set_indeterminate(self, flag)

    def start(self):
        return _mforms.ProgressBar_start(self)

    def stop(self):
        return _mforms.ProgressBar_stop(self)

    def set_value(self, pct):
        return _mforms.ProgressBar_set_value(self, pct)
    __swig_destroy__ = _mforms.delete_ProgressBar
    __del__ = lambda self: None
ProgressBar_swigregister = _mforms.ProgressBar_swigregister
ProgressBar_swigregister(ProgressBar)


_mforms.NoFillExpandFlag_swigconstant(_mforms)
NoFillExpandFlag = _mforms.NoFillExpandFlag

_mforms.VExpandFlag_swigconstant(_mforms)
VExpandFlag = _mforms.VExpandFlag

_mforms.HExpandFlag_swigconstant(_mforms)
HExpandFlag = _mforms.HExpandFlag

_mforms.VFillFlag_swigconstant(_mforms)
VFillFlag = _mforms.VFillFlag

_mforms.HFillFlag_swigconstant(_mforms)
HFillFlag = _mforms.HFillFlag

_mforms.FillAndExpand_swigconstant(_mforms)
FillAndExpand = _mforms.FillAndExpand

def __or__(a, b):
    return _mforms.__or__(a, b)
__or__ = _mforms.__or__
class Table(Container):
    __swig_setmethods__ = {}
    for _s in [Container]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Table, name, value)
    __swig_getmethods__ = {}
    for _s in [Container]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Table, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _mforms.new_Table()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_row_count(self, c):
        return _mforms.Table_set_row_count(self, c)

    def set_column_count(self, c):
        return _mforms.Table_set_column_count(self, c)

    def set_row_spacing(self, s):
        return _mforms.Table_set_row_spacing(self, s)

    def set_column_spacing(self, s):
        return _mforms.Table_set_column_spacing(self, s)

    def set_homogeneous(self, value):
        return _mforms.Table_set_homogeneous(self, value)

    def add(self, *args):
        return _mforms.Table_add(self, *args)

    def remove(self, sv):
        return _mforms.Table_remove(self, sv)
    __swig_destroy__ = _mforms.delete_Table
    __del__ = lambda self: None
Table_swigregister = _mforms.Table_swigregister
Table_swigregister(Table)


_mforms.ScrollPanelNoFlags_swigconstant(_mforms)
ScrollPanelNoFlags = _mforms.ScrollPanelNoFlags

_mforms.ScrollPanelBordered_swigconstant(_mforms)
ScrollPanelBordered = _mforms.ScrollPanelBordered

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

    def __init__(self, *args):
        this = _mforms.new_ScrollPanel(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_ScrollPanel
    __del__ = lambda self: None

    def set_visible_scrollers(self, vertical, horizontal):
        return _mforms.ScrollPanel_set_visible_scrollers(self, vertical, horizontal)

    def set_autohide_scrollers(self, flag):
        return _mforms.ScrollPanel_set_autohide_scrollers(self, flag)

    def add(self, child):
        return _mforms.ScrollPanel_add(self, child)

    def remove(self):
        return _mforms.ScrollPanel_remove(self)

    def scroll_to_view(self, child):
        return _mforms.ScrollPanel_scroll_to_view(self, child)

    def get_content_rect(self):
        return _mforms.ScrollPanel_get_content_rect(self)

    def scroll_to(self, x, y):
        return _mforms.ScrollPanel_scroll_to(self, x, y)
ScrollPanel_swigregister = _mforms.ScrollPanel_swigregister
ScrollPanel_swigregister(ScrollPanel)

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

    def __init__(self, owner):
        this = _mforms.new_Wizard(owner)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_Wizard
    __del__ = lambda self: None

    def run(self):
        return _mforms.Wizard_run(self)

    def set_heading(self, text):
        return _mforms.Wizard_set_heading(self, text)

    def set_step_list(self, steps):
        return _mforms.Wizard_set_step_list(self, steps)

    def set_allow_cancel(self, flag):
        return _mforms.Wizard_set_allow_cancel(self, flag)

    def set_allow_back(self, flag):
        return _mforms.Wizard_set_allow_back(self, flag)

    def set_allow_next(self, flag):
        return _mforms.Wizard_set_allow_next(self, flag)

    def set_show_extra(self, flag):
        return _mforms.Wizard_set_show_extra(self, flag)

    def set_extra_caption(self, caption):
        return _mforms.Wizard_set_extra_caption(self, caption)

    def set_next_caption(self, *args):
        return _mforms.Wizard_set_next_caption(self, *args)

    def add_next_callback(self, callback):
        return _mforms.Wizard_add_next_callback(self, callback)

    def call_next_callback(self):
        return _mforms.Wizard_call_next_callback(self)

    def add_back_callback(self, callback):
        return _mforms.Wizard_add_back_callback(self, callback)

    def call_back_callback(self):
        return _mforms.Wizard_call_back_callback(self)

    def add_extra_callback(self, callback):
        return _mforms.Wizard_add_extra_callback(self, callback)

    def call_extra_callback(self):
        return _mforms.Wizard_call_extra_callback(self)
Wizard_swigregister = _mforms.Wizard_swigregister
Wizard_swigregister(Wizard)


_mforms.Documents_swigconstant(_mforms)
Documents = _mforms.Documents

_mforms.Desktop_swigconstant(_mforms)
Desktop = _mforms.Desktop

_mforms.ApplicationData_swigconstant(_mforms)
ApplicationData = _mforms.ApplicationData

_mforms.WinProgramFiles_swigconstant(_mforms)
WinProgramFiles = _mforms.WinProgramFiles

_mforms.WinProgramFilesX86_swigconstant(_mforms)
WinProgramFilesX86 = _mforms.WinProgramFilesX86

_mforms.ApplicationSettings_swigconstant(_mforms)
ApplicationSettings = _mforms.ApplicationSettings

_mforms.SessionStorePasswordScheme_swigconstant(_mforms)
SessionStorePasswordScheme = _mforms.SessionStorePasswordScheme

_mforms.PersistentStorePasswordScheme_swigconstant(_mforms)
PersistentStorePasswordScheme = _mforms.PersistentStorePasswordScheme

_mforms.KeyNone_swigconstant(_mforms)
KeyNone = _mforms.KeyNone

_mforms.KeyChar_swigconstant(_mforms)
KeyChar = _mforms.KeyChar

_mforms.KeyModifierOnly_swigconstant(_mforms)
KeyModifierOnly = _mforms.KeyModifierOnly

_mforms.KeyEnter_swigconstant(_mforms)
KeyEnter = _mforms.KeyEnter

_mforms.KeyReturn_swigconstant(_mforms)
KeyReturn = _mforms.KeyReturn

_mforms.KeyHome_swigconstant(_mforms)
KeyHome = _mforms.KeyHome

_mforms.KeyEnd_swigconstant(_mforms)
KeyEnd = _mforms.KeyEnd

_mforms.KeyPrevious_swigconstant(_mforms)
KeyPrevious = _mforms.KeyPrevious

_mforms.KeyNext_swigconstant(_mforms)
KeyNext = _mforms.KeyNext

_mforms.KeyUp_swigconstant(_mforms)
KeyUp = _mforms.KeyUp

_mforms.KeyDown_swigconstant(_mforms)
KeyDown = _mforms.KeyDown

_mforms.KeyUnkown_swigconstant(_mforms)
KeyUnkown = _mforms.KeyUnkown

_mforms.ModifierNoModifier_swigconstant(_mforms)
ModifierNoModifier = _mforms.ModifierNoModifier

_mforms.ModifierControl_swigconstant(_mforms)
ModifierControl = _mforms.ModifierControl

_mforms.ModifierShift_swigconstant(_mforms)
ModifierShift = _mforms.ModifierShift

_mforms.ModifierCommand_swigconstant(_mforms)
ModifierCommand = _mforms.ModifierCommand

_mforms.ModifierAlt_swigconstant(_mforms)
ModifierAlt = _mforms.ModifierAlt

_mforms.ResultOk_swigconstant(_mforms)
ResultOk = _mforms.ResultOk

_mforms.ResultCancel_swigconstant(_mforms)
ResultCancel = _mforms.ResultCancel

_mforms.ResultOther_swigconstant(_mforms)
ResultOther = _mforms.ResultOther

_mforms.ResultUnknown_swigconstant(_mforms)
ResultUnknown = _mforms.ResultUnknown

_mforms.DialogMessage_swigconstant(_mforms)
DialogMessage = _mforms.DialogMessage

_mforms.DialogError_swigconstant(_mforms)
DialogError = _mforms.DialogError

_mforms.DialogWarning_swigconstant(_mforms)
DialogWarning = _mforms.DialogWarning

_mforms.DialogQuery_swigconstant(_mforms)
DialogQuery = _mforms.DialogQuery

_mforms.DialogSuccess_swigconstant(_mforms)
DialogSuccess = _mforms.DialogSuccess
class Utilities(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Utilities, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Utilities, name)
    __repr__ = _swig_repr
    __swig_getmethods__["beep"] = lambda x: _mforms.Utilities_beep
    if _newclass:
        beep = staticmethod(_mforms.Utilities_beep)
    __swig_getmethods__["show_message"] = lambda x: _mforms.Utilities_show_message
    if _newclass:
        show_message = staticmethod(_mforms.Utilities_show_message)
    __swig_getmethods__["show_error"] = lambda x: _mforms.Utilities_show_error
    if _newclass:
        show_error = staticmethod(_mforms.Utilities_show_error)
    __swig_getmethods__["show_warning"] = lambda x: _mforms.Utilities_show_warning
    if _newclass:
        show_warning = staticmethod(_mforms.Utilities_show_warning)
    __swig_getmethods__["show_message_and_remember"] = lambda x: _mforms.Utilities_show_message_and_remember
    if _newclass:
        show_message_and_remember = staticmethod(_mforms.Utilities_show_message_and_remember)
    __swig_getmethods__["forget_message_answers"] = lambda x: _mforms.Utilities_forget_message_answers
    if _newclass:
        forget_message_answers = staticmethod(_mforms.Utilities_forget_message_answers)
    __swig_getmethods__["set_message_answers_storage_path"] = lambda x: _mforms.Utilities_set_message_answers_storage_path
    if _newclass:
        set_message_answers_storage_path = staticmethod(_mforms.Utilities_set_message_answers_storage_path)
    __swig_getmethods__["show_wait_message"] = lambda x: _mforms.Utilities_show_wait_message
    if _newclass:
        show_wait_message = staticmethod(_mforms.Utilities_show_wait_message)
    __swig_getmethods__["hide_wait_message"] = lambda x: _mforms.Utilities_hide_wait_message
    if _newclass:
        hide_wait_message = staticmethod(_mforms.Utilities_hide_wait_message)
    __swig_getmethods__["run_cancelable_task"] = lambda x: _mforms.Utilities_run_cancelable_task
    if _newclass:
        run_cancelable_task = staticmethod(_mforms.Utilities_run_cancelable_task)
    __swig_getmethods__["request_input"] = lambda x: _mforms.Utilities_request_input
    if _newclass:
        request_input = staticmethod(_mforms.Utilities_request_input)
    __swig_getmethods__["ask_for_password_check_store"] = lambda x: _mforms.Utilities_ask_for_password_check_store
    if _newclass:
        ask_for_password_check_store = staticmethod(_mforms.Utilities_ask_for_password_check_store)
    __swig_getmethods__["ask_for_password"] = lambda x: _mforms.Utilities_ask_for_password
    if _newclass:
        ask_for_password = staticmethod(_mforms.Utilities_ask_for_password)
    __swig_getmethods__["find_or_ask_for_password"] = lambda x: _mforms.Utilities_find_or_ask_for_password
    if _newclass:
        find_or_ask_for_password = staticmethod(_mforms.Utilities_find_or_ask_for_password)
    __swig_getmethods__["store_password"] = lambda x: _mforms.Utilities_store_password
    if _newclass:
        store_password = staticmethod(_mforms.Utilities_store_password)
    __swig_getmethods__["find_password"] = lambda x: _mforms.Utilities_find_password
    if _newclass:
        find_password = staticmethod(_mforms.Utilities_find_password)
    __swig_getmethods__["find_cached_password"] = lambda x: _mforms.Utilities_find_cached_password
    if _newclass:
        find_cached_password = staticmethod(_mforms.Utilities_find_cached_password)
    __swig_getmethods__["forget_cached_password"] = lambda x: _mforms.Utilities_forget_cached_password
    if _newclass:
        forget_cached_password = staticmethod(_mforms.Utilities_forget_cached_password)
    __swig_getmethods__["forget_password"] = lambda x: _mforms.Utilities_forget_password
    if _newclass:
        forget_password = staticmethod(_mforms.Utilities_forget_password)
    __swig_getmethods__["set_clipboard_text"] = lambda x: _mforms.Utilities_set_clipboard_text
    if _newclass:
        set_clipboard_text = staticmethod(_mforms.Utilities_set_clipboard_text)
    __swig_getmethods__["get_clipboard_text"] = lambda x: _mforms.Utilities_get_clipboard_text
    if _newclass:
        get_clipboard_text = staticmethod(_mforms.Utilities_get_clipboard_text)
    __swig_getmethods__["get_special_folder"] = lambda x: _mforms.Utilities_get_special_folder
    if _newclass:
        get_special_folder = staticmethod(_mforms.Utilities_get_special_folder)
    __swig_getmethods__["open_url"] = lambda x: _mforms.Utilities_open_url
    if _newclass:
        open_url = staticmethod(_mforms.Utilities_open_url)
    __swig_getmethods__["move_to_trash"] = lambda x: _mforms.Utilities_move_to_trash
    if _newclass:
        move_to_trash = staticmethod(_mforms.Utilities_move_to_trash)
    __swig_getmethods__["reveal_file"] = lambda x: _mforms.Utilities_reveal_file
    if _newclass:
        reveal_file = staticmethod(_mforms.Utilities_reveal_file)
    __swig_getmethods__["cancel_timeout"] = lambda x: _mforms.Utilities_cancel_timeout
    if _newclass:
        cancel_timeout = staticmethod(_mforms.Utilities_cancel_timeout)
    __swig_getmethods__["add_end_ok_cancel_buttons"] = lambda x: _mforms.Utilities_add_end_ok_cancel_buttons
    if _newclass:
        add_end_ok_cancel_buttons = staticmethod(_mforms.Utilities_add_end_ok_cancel_buttons)
    __swig_getmethods__["in_main_thread"] = lambda x: _mforms.Utilities_in_main_thread
    if _newclass:
        in_main_thread = staticmethod(_mforms.Utilities_in_main_thread)
    __swig_getmethods__["set_thread_name"] = lambda x: _mforms.Utilities_set_thread_name
    if _newclass:
        set_thread_name = staticmethod(_mforms.Utilities_set_thread_name)
    __swig_getmethods__["driver_shutdown"] = lambda x: _mforms.Utilities_driver_shutdown
    if _newclass:
        driver_shutdown = staticmethod(_mforms.Utilities_driver_shutdown)
    __swig_getmethods__["add_timeout"] = lambda x: _mforms.Utilities_add_timeout
    if _newclass:
        add_timeout = staticmethod(_mforms.Utilities_add_timeout)
    __swig_getmethods__["perform_from_main_thread"] = lambda x: _mforms.Utilities_perform_from_main_thread
    if _newclass:
        perform_from_main_thread = staticmethod(_mforms.Utilities_perform_from_main_thread)

    def __init__(self):
        this = _mforms.new_Utilities()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_Utilities
    __del__ = lambda self: None
Utilities_swigregister = _mforms.Utilities_swigregister
Utilities_swigregister(Utilities)

def Utilities_beep():
    return _mforms.Utilities_beep()
Utilities_beep = _mforms.Utilities_beep

def Utilities_show_message(*args):
    return _mforms.Utilities_show_message(*args)
Utilities_show_message = _mforms.Utilities_show_message

def Utilities_show_error(*args):
    return _mforms.Utilities_show_error(*args)
Utilities_show_error = _mforms.Utilities_show_error

def Utilities_show_warning(*args):
    return _mforms.Utilities_show_warning(*args)
Utilities_show_warning = _mforms.Utilities_show_warning

def Utilities_show_message_and_remember(title, text, ok, cancel, other, answer_id, checkbox_text):
    return _mforms.Utilities_show_message_and_remember(title, text, ok, cancel, other, answer_id, checkbox_text)
Utilities_show_message_and_remember = _mforms.Utilities_show_message_and_remember

def Utilities_forget_message_answers():
    return _mforms.Utilities_forget_message_answers()
Utilities_forget_message_answers = _mforms.Utilities_forget_message_answers

def Utilities_set_message_answers_storage_path(path):
    return _mforms.Utilities_set_message_answers_storage_path(path)
Utilities_set_message_answers_storage_path = _mforms.Utilities_set_message_answers_storage_path

def Utilities_show_wait_message(title, text):
    return _mforms.Utilities_show_wait_message(title, text)
Utilities_show_wait_message = _mforms.Utilities_show_wait_message

def Utilities_hide_wait_message():
    return _mforms.Utilities_hide_wait_message()
Utilities_hide_wait_message = _mforms.Utilities_hide_wait_message

def Utilities_run_cancelable_task(title, text, task, cancel_task, task_result):
    return _mforms.Utilities_run_cancelable_task(title, text, task, cancel_task, task_result)
Utilities_run_cancelable_task = _mforms.Utilities_run_cancelable_task

def Utilities_request_input(title, description, default_value):
    return _mforms.Utilities_request_input(title, description, default_value)
Utilities_request_input = _mforms.Utilities_request_input

def Utilities_ask_for_password_check_store(title, service, username):
    return _mforms.Utilities_ask_for_password_check_store(title, service, username)
Utilities_ask_for_password_check_store = _mforms.Utilities_ask_for_password_check_store

def Utilities_ask_for_password(title, service, username):
    return _mforms.Utilities_ask_for_password(title, service, username)
Utilities_ask_for_password = _mforms.Utilities_ask_for_password

def Utilities_find_or_ask_for_password(title, service, username, reset_password):
    return _mforms.Utilities_find_or_ask_for_password(title, service, username, reset_password)
Utilities_find_or_ask_for_password = _mforms.Utilities_find_or_ask_for_password

def Utilities_store_password(service, account, password):
    return _mforms.Utilities_store_password(service, account, password)
Utilities_store_password = _mforms.Utilities_store_password

def Utilities_find_password(service, account):
    return _mforms.Utilities_find_password(service, account)
Utilities_find_password = _mforms.Utilities_find_password

def Utilities_find_cached_password(service, account):
    return _mforms.Utilities_find_cached_password(service, account)
Utilities_find_cached_password = _mforms.Utilities_find_cached_password

def Utilities_forget_cached_password(service, account):
    return _mforms.Utilities_forget_cached_password(service, account)
Utilities_forget_cached_password = _mforms.Utilities_forget_cached_password

def Utilities_forget_password(service, account):
    return _mforms.Utilities_forget_password(service, account)
Utilities_forget_password = _mforms.Utilities_forget_password

def Utilities_set_clipboard_text(text):
    return _mforms.Utilities_set_clipboard_text(text)
Utilities_set_clipboard_text = _mforms.Utilities_set_clipboard_text

def Utilities_get_clipboard_text():
    return _mforms.Utilities_get_clipboard_text()
Utilities_get_clipboard_text = _mforms.Utilities_get_clipboard_text

def Utilities_get_special_folder(type):
    return _mforms.Utilities_get_special_folder(type)
Utilities_get_special_folder = _mforms.Utilities_get_special_folder

def Utilities_open_url(url):
    return _mforms.Utilities_open_url(url)
Utilities_open_url = _mforms.Utilities_open_url

def Utilities_move_to_trash(path):
    return _mforms.Utilities_move_to_trash(path)
Utilities_move_to_trash = _mforms.Utilities_move_to_trash

def Utilities_reveal_file(path):
    return _mforms.Utilities_reveal_file(path)
Utilities_reveal_file = _mforms.Utilities_reveal_file

def Utilities_cancel_timeout(handle):
    return _mforms.Utilities_cancel_timeout(handle)
Utilities_cancel_timeout = _mforms.Utilities_cancel_timeout

def Utilities_add_end_ok_cancel_buttons(box, ok, cancel):
    return _mforms.Utilities_add_end_ok_cancel_buttons(box, ok, cancel)
Utilities_add_end_ok_cancel_buttons = _mforms.Utilities_add_end_ok_cancel_buttons

def Utilities_in_main_thread():
    return _mforms.Utilities_in_main_thread()
Utilities_in_main_thread = _mforms.Utilities_in_main_thread

def Utilities_set_thread_name(name):
    return _mforms.Utilities_set_thread_name(name)
Utilities_set_thread_name = _mforms.Utilities_set_thread_name

def Utilities_driver_shutdown():
    return _mforms.Utilities_driver_shutdown()
Utilities_driver_shutdown = _mforms.Utilities_driver_shutdown

def Utilities_add_timeout(interval, callback):
    return _mforms.Utilities_add_timeout(interval, callback)
Utilities_add_timeout = _mforms.Utilities_add_timeout

def Utilities_perform_from_main_thread(callable, wait):
    return _mforms.Utilities_perform_from_main_thread(callable, wait)
Utilities_perform_from_main_thread = _mforms.Utilities_perform_from_main_thread

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

    def __init__(self, horiz, context_name, is_main):
        this = _mforms.new_AppView(horiz, context_name, is_main)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_AppView
    __del__ = lambda self: None

    def set_title(self, title):
        return _mforms.AppView_set_title(self, title)

    def get_title(self):
        return _mforms.AppView_get_title(self)

    def set_identifier(self, identifier):
        return _mforms.AppView_set_identifier(self, identifier)

    def identifier(self):
        return _mforms.AppView_identifier(self)

    def close(self):
        return _mforms.AppView_close(self)

    def get_menubar(self):
        return _mforms.AppView_get_menubar(self)

    def set_menubar(self, menu):
        return _mforms.AppView_set_menubar(self, menu)

    def get_toolbar(self):
        return _mforms.AppView_get_toolbar(self)

    def set_toolbar(self, toolbar):
        return _mforms.AppView_set_toolbar(self, toolbar)

    def is_main_form(self):
        return _mforms.AppView_is_main_form(self)

    def get_form_context_name(self):
        return _mforms.AppView_get_form_context_name(self)

    def on_close(self, *args):
        return _mforms.AppView_on_close(self, *args)
AppView_swigregister = _mforms.AppView_swigregister
AppView_swigregister(AppView)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mforms.delete_DockingPoint
    __del__ = lambda self: None

    def get_type(self):
        return _mforms.DockingPoint_get_type(self)

    def dock_view(self, *args):
        return _mforms.DockingPoint_dock_view(self, *args)

    def select_view(self, view):
        return _mforms.DockingPoint_select_view(self, view)

    def selected_view(self):
        return _mforms.DockingPoint_selected_view(self)

    def undock_view(self, view):
        return _mforms.DockingPoint_undock_view(self, view)

    def close_view_at_index(self, index):
        return _mforms.DockingPoint_close_view_at_index(self, index)

    def close_all_views(self):
        return _mforms.DockingPoint_close_all_views(self)

    def get_size(self):
        return _mforms.DockingPoint_get_size(self)

    def view_count(self):
        return _mforms.DockingPoint_view_count(self)

    def view_at_index(self, index):
        return _mforms.DockingPoint_view_at_index(self, index)
DockingPoint_swigregister = _mforms.DockingPoint_swigregister
DockingPoint_swigregister(DockingPoint)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["get"] = lambda x: _mforms.App_get
    if _newclass:
        get = staticmethod(_mforms.App_get)

    def set_status_text(self, text):
        return _mforms.App_set_status_text(self, text)

    def get_resource_path(self, file):
        return _mforms.App_get_resource_path(self, file)

    def get_executable_path(self, file):
        return _mforms.App_get_executable_path(self, file)

    def get_user_data_folder(self):
        return _mforms.App_get_user_data_folder(self)

    def get_application_bounds(self):
        return _mforms.App_get_application_bounds(self)

    def enter_event_loop(self, timeout=0.0):
        return _mforms.App_enter_event_loop(self, timeout)

    def exit_event_loop(self, retcode):
        return _mforms.App_exit_event_loop(self, retcode)

    def backing_scale_factor(self):
        return _mforms.App_backing_scale_factor(self)
    __swig_destroy__ = _mforms.delete_App
    __del__ = lambda self: None
App_swigregister = _mforms.App_swigregister
App_swigregister(App)

def App_get():
    return _mforms.App_get()
App_get = _mforms.App_get

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

    def __init__(self):
        this = _mforms.new_DrawBox()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add(self, view, alignment):
        return _mforms.DrawBox_add(self, view, alignment)

    def remove(self, view):
        return _mforms.DrawBox_remove(self, view)

    def move(self, child, x, y):
        return _mforms.DrawBox_move(self, child, x, y)

    def set_padding(self, left, top, right, bottom):
        return _mforms.DrawBox_set_padding(self, left, top, right, bottom)

    def set_needs_repaint(self):
        return _mforms.DrawBox_set_needs_repaint(self)

    def set_needs_repaint_area(self, x, y, w, h):
        return _mforms.DrawBox_set_needs_repaint_area(self, x, y, w, h)

    def getLayoutSize(self, proposedSize):
        return _mforms.DrawBox_getLayoutSize(self, proposedSize)
    __swig_destroy__ = _mforms.delete_DrawBox
    __del__ = lambda self: None
DrawBox_swigregister = _mforms.DrawBox_swigregister
DrawBox_swigregister(DrawBox)


_mforms.VerticalIconSwitcher_swigconstant(_mforms)
VerticalIconSwitcher = _mforms.VerticalIconSwitcher

_mforms.TabActiveBackground_swigconstant(_mforms)
TabActiveBackground = _mforms.TabActiveBackground

_mforms.TabInactiveBackground_swigconstant(_mforms)
TabInactiveBackground = _mforms.TabInactiveBackground

_mforms.TabActiveForeground_swigconstant(_mforms)
TabActiveForeground = _mforms.TabActiveForeground

_mforms.TabInactiveForeground_swigconstant(_mforms)
TabInactiveForeground = _mforms.TabInactiveForeground

_mforms.TabMainCaption_swigconstant(_mforms)
TabMainCaption = _mforms.TabMainCaption

_mforms.TabSubCaption_swigconstant(_mforms)
TabSubCaption = _mforms.TabSubCaption

_mforms.TabLineColor_swigconstant(_mforms)
TabLineColor = _mforms.TabLineColor

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

    def __init__(self, type):
        this = _mforms.new_TabSwitcher(type)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_TabSwitcher
    __del__ = lambda self: None

    def attach_to_tabview(self, tabView):
        return _mforms.TabSwitcher_attach_to_tabview(self, tabView)

    def add_item(self, title, sub_title, icon_path, alt_icon_path):
        return _mforms.TabSwitcher_add_item(self, title, sub_title, icon_path, alt_icon_path)

    def remove_item(self, index):
        return _mforms.TabSwitcher_remove_item(self, index)

    def set_icon(self, index, icon_path, alt_icon_path):
        return _mforms.TabSwitcher_set_icon(self, index, icon_path, alt_icon_path)

    def set_selected(self, index):
        return _mforms.TabSwitcher_set_selected(self, index)

    def get_selected(self):
        return _mforms.TabSwitcher_get_selected(self)

    def set_needs_relayout(self):
        return _mforms.TabSwitcher_set_needs_relayout(self)

    def set_collapsed(self, flag):
        return _mforms.TabSwitcher_set_collapsed(self, flag)

    def get_collapsed(self):
        return _mforms.TabSwitcher_get_collapsed(self)

    def add_changed_callback(self, callback):
        return _mforms.TabSwitcher_add_changed_callback(self, callback)

    def call_changed_callback(self):
        return _mforms.TabSwitcher_call_changed_callback(self)
TabSwitcher_swigregister = _mforms.TabSwitcher_swigregister
TabSwitcher_swigregister(TabSwitcher)

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

    def __init__(self, expandable, title, header_mode=False):
        this = _mforms.new_SectionBox(expandable, title, header_mode)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_SectionBox
    __del__ = lambda self: None

    def set_content(self, page):
        return _mforms.SectionBox_set_content(self, page)

    def toggle(self):
        return _mforms.SectionBox_toggle(self)

    def set_expanded(self, expanded):
        return _mforms.SectionBox_set_expanded(self, expanded)

    def get_expanded(self):
        return _mforms.SectionBox_get_expanded(self)
SectionBox_swigregister = _mforms.SectionBox_swigregister
SectionBox_swigregister(SectionBox)

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

    def __init__(self):
        this = _mforms.new_BaseWidget()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_BaseWidget
    __del__ = lambda self: None

    def set_right_align(self, flag):
        return _mforms.BaseWidget_set_right_align(self, flag)

    def enable_auto_scale(self, enable):
        return _mforms.BaseWidget_enable_auto_scale(self, enable)

    def get_upper_range(self):
        return _mforms.BaseWidget_get_upper_range(self)

    def set_value_range(self, low, high):
        return _mforms.BaseWidget_set_value_range(self, low, high)

    def set_thresholds(self, lower_thresholds, upper_thresholds):
        return _mforms.BaseWidget_set_thresholds(self, lower_thresholds, upper_thresholds)

    def set_description(self, description):
        return _mforms.BaseWidget_set_description(self, description)
BaseWidget_swigregister = _mforms.BaseWidget_swigregister
BaseWidget_swigregister(BaseWidget)

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

    def __init__(self):
        this = _mforms.new_WidgetSeparator()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_WidgetSeparator
    __del__ = lambda self: None
WidgetSeparator_swigregister = _mforms.WidgetSeparator_swigregister
WidgetSeparator_swigregister(WidgetSeparator)


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

    def __init__(self):
        this = _mforms.new_HeartbeatWidget()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_HeartbeatWidget
    __del__ = lambda self: None

    def set_value(self, value):
        return _mforms.HeartbeatWidget_set_value(self, value)
HeartbeatWidget_swigregister = _mforms.HeartbeatWidget_swigregister
HeartbeatWidget_swigregister(HeartbeatWidget)

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

    def __init__(self):
        this = _mforms.new_ServerStatusWidget()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_ServerStatusWidget
    __del__ = lambda self: None

    def set_server_status(self, status):
        return _mforms.ServerStatusWidget_set_server_status(self, status)
ServerStatusWidget_swigregister = _mforms.ServerStatusWidget_swigregister
ServerStatusWidget_swigregister(ServerStatusWidget)

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

    def __init__(self):
        this = _mforms.new_BarGraphWidget()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_BarGraphWidget
    __del__ = lambda self: None

    def set_value(self, value):
        return _mforms.BarGraphWidget_set_value(self, value)
BarGraphWidget_swigregister = _mforms.BarGraphWidget_swigregister
BarGraphWidget_swigregister(BarGraphWidget)


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

    def __init__(self):
        this = _mforms.new_LineDiagramWidget()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_LineDiagramWidget
    __del__ = lambda self: None

    def set_value(self, value):
        return _mforms.LineDiagramWidget_set_value(self, value)
LineDiagramWidget_swigregister = _mforms.LineDiagramWidget_swigregister
LineDiagramWidget_swigregister(LineDiagramWidget)

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

    def __init__(self):
        this = _mforms.new_WebBrowser()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_html(self, path):
        return _mforms.WebBrowser_set_html(self, path)

    def navigate(self, url):
        return _mforms.WebBrowser_navigate(self, url)

    def get_document_title(self):
        return _mforms.WebBrowser_get_document_title(self)

    def set_link_click_handler(self, slot):
        return _mforms.WebBrowser_set_link_click_handler(self, slot)

    def add_loaded_callback(self, callback):
        return _mforms.WebBrowser_add_loaded_callback(self, callback)

    def call_loaded_callback(self, s):
        return _mforms.WebBrowser_call_loaded_callback(self, s)
    __swig_destroy__ = _mforms.delete_WebBrowser
    __del__ = lambda self: None
WebBrowser_swigregister = _mforms.WebBrowser_swigregister
WebBrowser_swigregister(WebBrowser)


_mforms.PopupPlain_swigconstant(_mforms)
PopupPlain = _mforms.PopupPlain

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

    def __init__(self, style):
        this = _mforms.new_Popup(style)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_Popup
    __del__ = lambda self: None

    def set_needs_repaint(self):
        return _mforms.Popup_set_needs_repaint(self)

    def set_size(self, width, height):
        return _mforms.Popup_set_size(self, width, height)

    def show(self, spot_x, spot_y):
        return _mforms.Popup_show(self, spot_x, spot_y)

    def get_content_rect(self):
        return _mforms.Popup_get_content_rect(self)

    def set_modal_result(self, result):
        return _mforms.Popup_set_modal_result(self, result)

    def closed(self):
        return _mforms.Popup_closed(self)
Popup_swigregister = _mforms.Popup_swigregister
Popup_swigregister(Popup)


_mforms.StartLeft_swigconstant(_mforms)
StartLeft = _mforms.StartLeft

_mforms.StartRight_swigconstant(_mforms)
StartRight = _mforms.StartRight

_mforms.StartAbove_swigconstant(_mforms)
StartAbove = _mforms.StartAbove

_mforms.StartBelow_swigconstant(_mforms)
StartBelow = _mforms.StartBelow

_mforms.PopoverStyleNormal_swigconstant(_mforms)
PopoverStyleNormal = _mforms.PopoverStyleNormal

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

    def __init__(self, *args):
        this = _mforms.new_Popover(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_Popover
    __del__ = lambda self: None

    def set_content(self, content):
        return _mforms.Popover_set_content(self, content)

    def set_size(self, width, height):
        return _mforms.Popover_set_size(self, width, height)

    def show(self, x, y, position):
        return _mforms.Popover_show(self, x, y, position)

    def close(self):
        return _mforms.Popover_close(self)

    def show_and_track(self, tracked_view, x, y, position):
        return _mforms.Popover_show_and_track(self, tracked_view, x, y, position)

    def signal_close(self):
        return _mforms.Popover_signal_close(self)

    def add_close_callback(self, callback):
        return _mforms.Popover_add_close_callback(self, callback)

    def call_close_callback(self):
        return _mforms.Popover_call_close_callback(self)
Popover_swigregister = _mforms.Popover_swigregister
Popover_swigregister(Popover)


_mforms.NormalMenuItem_swigconstant(_mforms)
NormalMenuItem = _mforms.NormalMenuItem

_mforms.CheckedMenuItem_swigconstant(_mforms)
CheckedMenuItem = _mforms.CheckedMenuItem

_mforms.SeparatorMenuItem_swigconstant(_mforms)
SeparatorMenuItem = _mforms.SeparatorMenuItem
class MenuBase(Object):
    __swig_setmethods__ = {}
    for _s in [Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuBase, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MenuBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mforms.delete_MenuBase
    __del__ = lambda self: None

    def find_item(self, name):
        return _mforms.MenuBase_find_item(self, name)

    def get_item(self, i):
        return _mforms.MenuBase_get_item(self, i)

    def get_item_index(self, item):
        return _mforms.MenuBase_get_item_index(self, item)

    def item_count(self):
        return _mforms.MenuBase_item_count(self)

    def add_separator(self):
        return _mforms.MenuBase_add_separator(self)

    def add_item(self, item):
        return _mforms.MenuBase_add_item(self, item)

    def add_submenu(self, item):
        return _mforms.MenuBase_add_submenu(self, item)

    def insert_item(self, index, item):
        return _mforms.MenuBase_insert_item(self, index, item)

    def remove_all(self):
        return _mforms.MenuBase_remove_all(self)

    def remove_item(self, item):
        return _mforms.MenuBase_remove_item(self, item)

    def set_enabled(self, flag):
        return _mforms.MenuBase_set_enabled(self, flag)

    def get_enabled(self):
        return _mforms.MenuBase_get_enabled(self)

    def validate(self):
        return _mforms.MenuBase_validate(self)

    def get_parent(self):
        return _mforms.MenuBase_get_parent(self)

    def get_top_menu(self):
        return _mforms.MenuBase_get_top_menu(self)

    def add_item_with_title(self, *args):
        return _mforms.MenuBase_add_item_with_title(self, *args)

    def add_check_item_with_title(self, *args):
        return _mforms.MenuBase_add_check_item_with_title(self, *args)
MenuBase_swigregister = _mforms.MenuBase_swigregister
MenuBase_swigregister(MenuBase)

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

    def __init__(self, *args):
        this = _mforms.new_MenuItem(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_title(self, title):
        return _mforms.MenuItem_set_title(self, title)

    def get_title(self):
        return _mforms.MenuItem_get_title(self)

    def set_shortcut(self, shortcut):
        return _mforms.MenuItem_set_shortcut(self, shortcut)

    def get_shortcut(self):
        return _mforms.MenuItem_get_shortcut(self)

    def set_checked(self, flag):
        return _mforms.MenuItem_set_checked(self, flag)

    def get_checked(self):
        return _mforms.MenuItem_get_checked(self)

    def set_name(self, name):
        return _mforms.MenuItem_set_name(self, name)

    def get_name(self):
        return _mforms.MenuItem_get_name(self)

    def get_type(self):
        return _mforms.MenuItem_get_type(self)

    def add_validator(self, slot):
        return _mforms.MenuItem_add_validator(self, slot)

    def clear_validators(self):
        return _mforms.MenuItem_clear_validators(self)

    def callback(self):
        return _mforms.MenuItem_callback(self)

    def add_clicked_callback(self, callback):
        return _mforms.MenuItem_add_clicked_callback(self, callback)

    def call_clicked_callback(self):
        return _mforms.MenuItem_call_clicked_callback(self)
    __swig_destroy__ = _mforms.delete_MenuItem
    __del__ = lambda self: None
MenuItem_swigregister = _mforms.MenuItem_swigregister
MenuItem_swigregister(MenuItem)

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

    def __init__(self):
        this = _mforms.new_MenuBar()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_item_enabled(self, item_name, flag):
        return _mforms.MenuBar_set_item_enabled(self, item_name, flag)

    def set_item_checked(self, item_name, flag):
        return _mforms.MenuBar_set_item_checked(self, item_name, flag)

    def will_show_submenu_from(self, item):
        return _mforms.MenuBar_will_show_submenu_from(self, item)
    __swig_destroy__ = _mforms.delete_MenuBar
    __del__ = lambda self: None
MenuBar_swigregister = _mforms.MenuBar_swigregister
MenuBar_swigregister(MenuBar)

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

    def __init__(self):
        this = _mforms.new_ContextMenu()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_item_enabled(self, item_name, flag):
        return _mforms.ContextMenu_set_item_enabled(self, item_name, flag)

    def set_item_checked(self, item_name, flag):
        return _mforms.ContextMenu_set_item_checked(self, item_name, flag)

    def will_show(self):
        return _mforms.ContextMenu_will_show(self)

    def will_show_submenu_from(self, item):
        return _mforms.ContextMenu_will_show_submenu_from(self, item)

    def popup_at(self, owner, location):
        return _mforms.ContextMenu_popup_at(self, owner, location)

    def add_will_show_callback(self, callback):
        return _mforms.ContextMenu_add_will_show_callback(self, callback)

    def call_will_show_callback(self, item):
        return _mforms.ContextMenu_call_will_show_callback(self, item)
    __swig_destroy__ = _mforms.delete_ContextMenu
    __del__ = lambda self: None
ContextMenu_swigregister = _mforms.ContextMenu_swigregister
ContextMenu_swigregister(ContextMenu)

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

    def __init__(self, horiz, thin=False):
        this = _mforms.new_Splitter(horiz, thin)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add(self, subview, minsize=0, fixed=False):
        return _mforms.Splitter_add(self, subview, minsize, fixed)

    def remove(self, subview):
        return _mforms.Splitter_remove(self, subview)

    def set_divider_position(self, position):
        return _mforms.Splitter_set_divider_position(self, position)

    def get_divider_position(self):
        return _mforms.Splitter_get_divider_position(self)

    def set_expanded(self, first, expand):
        return _mforms.Splitter_set_expanded(self, first, expand)

    def position_changed(self):
        return _mforms.Splitter_position_changed(self)
    __swig_destroy__ = _mforms.delete_Splitter
    __del__ = lambda self: None
Splitter_swigregister = _mforms.Splitter_swigregister
Splitter_swigregister(Splitter)


_mforms.LanguageNone_swigconstant(_mforms)
LanguageNone = _mforms.LanguageNone

_mforms.LanguageMySQL50_swigconstant(_mforms)
LanguageMySQL50 = _mforms.LanguageMySQL50

_mforms.LanguageMySQL51_swigconstant(_mforms)
LanguageMySQL51 = _mforms.LanguageMySQL51

_mforms.LanguageMySQL55_swigconstant(_mforms)
LanguageMySQL55 = _mforms.LanguageMySQL55

_mforms.LanguageMySQL56_swigconstant(_mforms)
LanguageMySQL56 = _mforms.LanguageMySQL56

_mforms.LanguageMySQL57_swigconstant(_mforms)
LanguageMySQL57 = _mforms.LanguageMySQL57

_mforms.LanguageHtml_swigconstant(_mforms)
LanguageHtml = _mforms.LanguageHtml

_mforms.LanguagePython_swigconstant(_mforms)
LanguagePython = _mforms.LanguagePython

_mforms.LanguageCpp_swigconstant(_mforms)
LanguageCpp = _mforms.LanguageCpp

_mforms.LanguageJS_swigconstant(_mforms)
LanguageJS = _mforms.LanguageJS

_mforms.LanguageJson_swigconstant(_mforms)
LanguageJson = _mforms.LanguageJson

_mforms.LanguageMySQL_swigconstant(_mforms)
LanguageMySQL = _mforms.LanguageMySQL

_mforms.LineMarkupNone_swigconstant(_mforms)
LineMarkupNone = _mforms.LineMarkupNone

_mforms.LineMarkupStatement_swigconstant(_mforms)
LineMarkupStatement = _mforms.LineMarkupStatement

_mforms.LineMarkupError_swigconstant(_mforms)
LineMarkupError = _mforms.LineMarkupError

_mforms.LineMarkupBreakpoint_swigconstant(_mforms)
LineMarkupBreakpoint = _mforms.LineMarkupBreakpoint

_mforms.LineMarkupBreakpointHit_swigconstant(_mforms)
LineMarkupBreakpointHit = _mforms.LineMarkupBreakpointHit

_mforms.LineMarkupCurrent_swigconstant(_mforms)
LineMarkupCurrent = _mforms.LineMarkupCurrent

_mforms.LineMarkupErrorContinue_swigconstant(_mforms)
LineMarkupErrorContinue = _mforms.LineMarkupErrorContinue

_mforms.LineMarkupAll_swigconstant(_mforms)
LineMarkupAll = _mforms.LineMarkupAll
class LineMarkupChangeEntry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LineMarkupChangeEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LineMarkupChangeEntry, name)
    __repr__ = _swig_repr
    __swig_setmethods__["original_line"] = _mforms.LineMarkupChangeEntry_original_line_set
    __swig_getmethods__["original_line"] = _mforms.LineMarkupChangeEntry_original_line_get
    if _newclass:
        original_line = _swig_property(_mforms.LineMarkupChangeEntry_original_line_get, _mforms.LineMarkupChangeEntry_original_line_set)
    __swig_setmethods__["new_line"] = _mforms.LineMarkupChangeEntry_new_line_set
    __swig_getmethods__["new_line"] = _mforms.LineMarkupChangeEntry_new_line_get
    if _newclass:
        new_line = _swig_property(_mforms.LineMarkupChangeEntry_new_line_get, _mforms.LineMarkupChangeEntry_new_line_set)
    __swig_setmethods__["markup"] = _mforms.LineMarkupChangeEntry_markup_set
    __swig_getmethods__["markup"] = _mforms.LineMarkupChangeEntry_markup_get
    if _newclass:
        markup = _swig_property(_mforms.LineMarkupChangeEntry_markup_get, _mforms.LineMarkupChangeEntry_markup_set)

    def __init__(self):
        this = _mforms.new_LineMarkupChangeEntry()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_LineMarkupChangeEntry
    __del__ = lambda self: None
LineMarkupChangeEntry_swigregister = _mforms.LineMarkupChangeEntry_swigregister
LineMarkupChangeEntry_swigregister(LineMarkupChangeEntry)


_mforms.RangeIndicatorNone_swigconstant(_mforms)
RangeIndicatorNone = _mforms.RangeIndicatorNone

_mforms.RangeIndicatorError_swigconstant(_mforms)
RangeIndicatorError = _mforms.RangeIndicatorError

_mforms.FeatureNone_swigconstant(_mforms)
FeatureNone = _mforms.FeatureNone

_mforms.FeatureWrapText_swigconstant(_mforms)
FeatureWrapText = _mforms.FeatureWrapText

_mforms.FeatureGutter_swigconstant(_mforms)
FeatureGutter = _mforms.FeatureGutter

_mforms.FeatureReadOnly_swigconstant(_mforms)
FeatureReadOnly = _mforms.FeatureReadOnly

_mforms.FeatureShowSpecial_swigconstant(_mforms)
FeatureShowSpecial = _mforms.FeatureShowSpecial

_mforms.FeatureUsePopup_swigconstant(_mforms)
FeatureUsePopup = _mforms.FeatureUsePopup

_mforms.FeatureConvertEolOnPaste_swigconstant(_mforms)
FeatureConvertEolOnPaste = _mforms.FeatureConvertEolOnPaste

_mforms.FeatureScrollOnResize_swigconstant(_mforms)
FeatureScrollOnResize = _mforms.FeatureScrollOnResize

_mforms.FeatureFolding_swigconstant(_mforms)
FeatureFolding = _mforms.FeatureFolding

_mforms.FeatureAutoIndent_swigconstant(_mforms)
FeatureAutoIndent = _mforms.FeatureAutoIndent

_mforms.FeatureAll_swigconstant(_mforms)
FeatureAll = _mforms.FeatureAll

_mforms.AutoCompletionSelection_swigconstant(_mforms)
AutoCompletionSelection = _mforms.AutoCompletionSelection

_mforms.AutoCompletionCancelled_swigconstant(_mforms)
AutoCompletionCancelled = _mforms.AutoCompletionCancelled

_mforms.AutoCompletionCharDeleted_swigconstant(_mforms)
AutoCompletionCharDeleted = _mforms.AutoCompletionCharDeleted

_mforms.EolCRLF_swigconstant(_mforms)
EolCRLF = _mforms.EolCRLF

_mforms.EolCR_swigconstant(_mforms)
EolCR = _mforms.EolCR

_mforms.EolLF_swigconstant(_mforms)
EolLF = _mforms.EolLF

_mforms.FindDefault_swigconstant(_mforms)
FindDefault = _mforms.FindDefault

_mforms.FindMatchCase_swigconstant(_mforms)
FindMatchCase = _mforms.FindMatchCase

_mforms.FindWrapAround_swigconstant(_mforms)
FindWrapAround = _mforms.FindWrapAround

_mforms.FindWholeWords_swigconstant(_mforms)
FindWholeWords = _mforms.FindWholeWords

_mforms.FindRegex_swigconstant(_mforms)
FindRegex = _mforms.FindRegex
class CodeEditor(View):
    __swig_setmethods__ = {}
    for _s in [View]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CodeEditor, name, value)
    __swig_getmethods__ = {}
    for _s in [View]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CodeEditor, name)
    __repr__ = _swig_repr
    LineNumberMargin = _mforms.CodeEditor_LineNumberMargin
    MarkersMargin = _mforms.CodeEditor_MarkersMargin
    FolderMargin = _mforms.CodeEditor_FolderMargin
    TextMargin = _mforms.CodeEditor_TextMargin

    def __init__(self, host=None, showInfo=True):
        this = _mforms.new_CodeEditor(host, showInfo)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_CodeEditor
    __del__ = lambda self: None

    def setup(self):
        return _mforms.CodeEditor_setup(self)

    def setWidth(self, *args):
        return _mforms.CodeEditor_setWidth(self, *args)

    def setColor(self, margin, color, foreground=False):
        return _mforms.CodeEditor_setColor(self, margin, color, foreground)

    def showMargin(self, arg2, show=True):
        return _mforms.CodeEditor_showMargin(self, arg2, show)

    def setMarginText(self, *args):
        return _mforms.CodeEditor_setMarginText(self, *args)

    def setScrollWidth(self, width):
        return _mforms.CodeEditor_setScrollWidth(self, width)

    def getLineHeight(self, line):
        return _mforms.CodeEditor_getLineHeight(self, line)

    def set_text(self, text):
        return _mforms.CodeEditor_set_text(self, text)

    def set_value(self, text):
        return _mforms.CodeEditor_set_value(self, text)

    def set_text_keeping_state(self, text):
        return _mforms.CodeEditor_set_text_keeping_state(self, text)

    def append_text(self, text, length):
        return _mforms.CodeEditor_append_text(self, text, length)

    def replace_selected_text(self, text):
        return _mforms.CodeEditor_replace_selected_text(self, text)

    def get_text(self, selection_only):
        return _mforms.CodeEditor_get_text(self, selection_only)

    def get_text_in_range(self, start, end):
        return _mforms.CodeEditor_get_text_in_range(self, start, end)

    def get_text_ptr(self):
        return _mforms.CodeEditor_get_text_ptr(self)

    def set_selection(self, start, length):
        return _mforms.CodeEditor_set_selection(self, start, length)

    def get_selection(self, start, length):
        return _mforms.CodeEditor_get_selection(self, start, length)

    def clear_selection(self):
        return _mforms.CodeEditor_clear_selection(self)

    def get_range_of_line(self, line, start, end):
        return _mforms.CodeEditor_get_range_of_line(self, line, start, end)

    def set_language(self, language):
        return _mforms.CodeEditor_set_language(self, language)

    def show_markup(self, markup, line):
        return _mforms.CodeEditor_show_markup(self, markup, line)

    def remove_markup(self, markup, line):
        return _mforms.CodeEditor_remove_markup(self, markup, line)

    def has_markup(self, markup, line):
        return _mforms.CodeEditor_has_markup(self, markup, line)

    def show_indicator(self, indicator, start, length):
        return _mforms.CodeEditor_show_indicator(self, indicator, start, length)

    def indicator_at(self, position):
        return _mforms.CodeEditor_indicator_at(self, position)

    def remove_indicator(self, indicator, start, length):
        return _mforms.CodeEditor_remove_indicator(self, indicator, start, length)

    def line_count(self):
        return _mforms.CodeEditor_line_count(self)

    def text_length(self):
        return _mforms.CodeEditor_text_length(self)

    def position_from_line(self, line_number):
        return _mforms.CodeEditor_position_from_line(self, line_number)

    def line_from_position(self, position):
        return _mforms.CodeEditor_line_from_position(self, position)

    def set_features(self, features, flag):
        return _mforms.CodeEditor_set_features(self, features, flag)

    def toggle_features(self, features):
        return _mforms.CodeEditor_toggle_features(self, features)

    def set_read_only(self, flag):
        return _mforms.CodeEditor_set_read_only(self, flag)

    def reset_undo_stack(self):
        return _mforms.CodeEditor_reset_undo_stack(self)

    def reset_dirty(self):
        return _mforms.CodeEditor_reset_dirty(self)

    def is_dirty(self):
        return _mforms.CodeEditor_is_dirty(self)

    def get_caret_pos(self):
        return _mforms.CodeEditor_get_caret_pos(self)

    def set_caret_pos(self, position):
        return _mforms.CodeEditor_set_caret_pos(self, position)

    def get_line_column_pos(self, position, line, column):
        return _mforms.CodeEditor_get_line_column_pos(self, position, line, column)

    def can_undo(self):
        return _mforms.CodeEditor_can_undo(self)

    def undo(self):
        return _mforms.CodeEditor_undo(self)

    def can_redo(self):
        return _mforms.CodeEditor_can_redo(self)

    def redo(self):
        return _mforms.CodeEditor_redo(self)

    def can_cut(self):
        return _mforms.CodeEditor_can_cut(self)

    def cut(self):
        return _mforms.CodeEditor_cut(self)

    def can_copy(self):
        return _mforms.CodeEditor_can_copy(self)

    def copy(self):
        return _mforms.CodeEditor_copy(self)

    def can_paste(self):
        return _mforms.CodeEditor_can_paste(self)

    def paste(self):
        return _mforms.CodeEditor_paste(self)

    def can_delete(self):
        return _mforms.CodeEditor_can_delete(self)

    def do_delete(self):
        return _mforms.CodeEditor_do_delete(self)

    def select_all(self):
        return _mforms.CodeEditor_select_all(self)

    def set_status_text(self, text):
        return _mforms.CodeEditor_set_status_text(self, text)

    def show_find_panel(self, replace):
        return _mforms.CodeEditor_show_find_panel(self, replace)

    def hide_find_panel(self):
        return _mforms.CodeEditor_hide_find_panel(self)

    def get_find_panel(self):
        return _mforms.CodeEditor_get_find_panel(self)

    def set_show_find_panel_callback(self, callback):
        return _mforms.CodeEditor_set_show_find_panel_callback(self, callback)

    def find_and_highlight_text(self, search_text, flags, scroll_to, backwards):
        return _mforms.CodeEditor_find_and_highlight_text(self, search_text, flags, scroll_to, backwards)

    def find_and_replace_text(self, search_text, new_text, flags, do_all):
        return _mforms.CodeEditor_find_and_replace_text(self, search_text, new_text, flags, do_all)

    def jump_to_next_placeholder(self):
        return _mforms.CodeEditor_jump_to_next_placeholder(self)

    def auto_completion_show(self, *args):
        return _mforms.CodeEditor_auto_completion_show(self, *args)

    def auto_completion_cancel(self):
        return _mforms.CodeEditor_auto_completion_cancel(self)

    def auto_completion_options(self, ignore_case, choose_single, auto_hide, drop_rest_of_word, cancel_at_start):
        return _mforms.CodeEditor_auto_completion_options(self, ignore_case, choose_single, auto_hide, drop_rest_of_word, cancel_at_start)

    def auto_completion_max_size(self, width, height):
        return _mforms.CodeEditor_auto_completion_max_size(self, width, height)

    def auto_completion_register_images(self, images):
        return _mforms.CodeEditor_auto_completion_register_images(self, images)

    def auto_completion_active(self):
        return _mforms.CodeEditor_auto_completion_active(self)

    def auto_completion_stops(self, stops):
        return _mforms.CodeEditor_auto_completion_stops(self, stops)

    def auto_completion_fillups(self, fillups):
        return _mforms.CodeEditor_auto_completion_fillups(self, fillups)

    def show_calltip(self, show, position, value):
        return _mforms.CodeEditor_show_calltip(self, show, position, value)

    def set_eol_mode(self, mode, convert=False):
        return _mforms.CodeEditor_set_eol_mode(self, mode, convert)

    def set_context_menu(self, menu):
        return _mforms.CodeEditor_set_context_menu(self, menu)

    def get_context_menu(self):
        return _mforms.CodeEditor_get_context_menu(self)

    def get_host(self):
        return _mforms.CodeEditor_get_host(self)

    def send_editor(self, message, wParam, lParam):
        return _mforms.CodeEditor_send_editor(self, message, wParam, lParam)

    def add_changed_callback(self, callback):
        return _mforms.CodeEditor_add_changed_callback(self, callback)

    def call_changed_callback(self, i, j, k, l):
        return _mforms.CodeEditor_call_changed_callback(self, i, j, k, l)
CodeEditor_swigregister = _mforms.CodeEditor_swigregister
CodeEditor_swigregister(CodeEditor)


_mforms.TaskSectionPlain_swigconstant(_mforms)
TaskSectionPlain = _mforms.TaskSectionPlain

_mforms.TaskSectionRefreshable_swigconstant(_mforms)
TaskSectionRefreshable = _mforms.TaskSectionRefreshable

_mforms.TaskSectionCollapsible_swigconstant(_mforms)
TaskSectionCollapsible = _mforms.TaskSectionCollapsible

_mforms.TaskSectionToggleModeButton_swigconstant(_mforms)
TaskSectionToggleModeButton = _mforms.TaskSectionToggleModeButton

_mforms.TaskSectionToggleModeButtonPreSelected_swigconstant(_mforms)
TaskSectionToggleModeButtonPreSelected = _mforms.TaskSectionToggleModeButtonPreSelected

_mforms.TaskSectionShowConfigButton_swigconstant(_mforms)
TaskSectionShowConfigButton = _mforms.TaskSectionShowConfigButton

_mforms.TaskEntrySelectableItem_swigconstant(_mforms)
TaskEntrySelectableItem = _mforms.TaskEntrySelectableItem

_mforms.TaskEntryLink_swigconstant(_mforms)
TaskEntryLink = _mforms.TaskEntryLink

_mforms.TaskEntryAlwaysActiveLink_swigconstant(_mforms)
TaskEntryAlwaysActiveLink = _mforms.TaskEntryAlwaysActiveLink

_mforms.TaskEntryPlainItem_swigconstant(_mforms)
TaskEntryPlainItem = _mforms.TaskEntryPlainItem
class TaskSidebar(Box):
    __swig_setmethods__ = {}
    for _s in [Box]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TaskSidebar, name, value)
    __swig_getmethods__ = {}
    for _s in [Box]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TaskSidebar, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_getmethods__["create"] = lambda x: _mforms.TaskSidebar_create
    if _newclass:
        create = staticmethod(_mforms.TaskSidebar_create)

    def add_section(self, *args):
        return _mforms.TaskSidebar_add_section(self, *args)

    def remove_section(self, name):
        return _mforms.TaskSidebar_remove_section(self, name)

    def add_section_entry(self, section_name, entry_name, title, icon, type):
        return _mforms.TaskSidebar_add_section_entry(self, section_name, entry_name, title, icon, type)

    def set_section_entry_text(self, entry_name, title):
        return _mforms.TaskSidebar_set_section_entry_text(self, entry_name, title)

    def set_section_entry_icon(self, entry_name, icon):
        return _mforms.TaskSidebar_set_section_entry_icon(self, entry_name, icon)

    def set_section_entry_enabled(self, entry_name, flag):
        return _mforms.TaskSidebar_set_section_entry_enabled(self, entry_name, flag)

    def mark_section_busy(self, section_name, busy):
        return _mforms.TaskSidebar_mark_section_busy(self, section_name, busy)

    def remove_section_entry(self, entry_name):
        return _mforms.TaskSidebar_remove_section_entry(self, entry_name)

    def set_collapse_states(self, data):
        return _mforms.TaskSidebar_set_collapse_states(self, data)

    def get_collapse_states(self):
        return _mforms.TaskSidebar_get_collapse_states(self)

    def clear_sections(self):
        return _mforms.TaskSidebar_clear_sections(self)

    def clear_section(self, section_name):
        return _mforms.TaskSidebar_clear_section(self, section_name)

    def set_selection_color(self, *args):
        return _mforms.TaskSidebar_set_selection_color(self, *args)

    def select_entry(self, entry_name):
        return _mforms.TaskSidebar_select_entry(self, entry_name)

    def selected_entry(self):
        return _mforms.TaskSidebar_selected_entry(self)

    def clear_selection(self):
        return _mforms.TaskSidebar_clear_selection(self)

    def on_section_command(self):
        return _mforms.TaskSidebar_on_section_command(self)

    def set_schema_model(self, model):
        return _mforms.TaskSidebar_set_schema_model(self, model)

    def set_filtered_schema_model(self, model):
        return _mforms.TaskSidebar_set_filtered_schema_model(self, model)

    def enable_server_search(self, enabled):
        return _mforms.TaskSidebar_enable_server_search(self, enabled)

    def get_schema_tree(self):
        return _mforms.TaskSidebar_get_schema_tree(self)

    def get_filter_entry(self):
        return _mforms.TaskSidebar_get_filter_entry(self)

    def expand_schema(self, schema_index):
        return _mforms.TaskSidebar_expand_schema(self, schema_index)

    def signal_filter_changed(self):
        return _mforms.TaskSidebar_signal_filter_changed(self)

    def tree_node_selected(self):
        return _mforms.TaskSidebar_tree_node_selected(self)

    def get_context_menu(self):
        return _mforms.TaskSidebar_get_context_menu(self)

    def add_on_section_command_callback(self, callback):
        return _mforms.TaskSidebar_add_on_section_command_callback(self, callback)

    def call_on_section_command_callback(self, s):
        return _mforms.TaskSidebar_call_on_section_command_callback(self, s)
    __swig_destroy__ = _mforms.delete_TaskSidebar
    __del__ = lambda self: None
TaskSidebar_swigregister = _mforms.TaskSidebar_swigregister
TaskSidebar_swigregister(TaskSidebar)

def TaskSidebar_create(type):
    return _mforms.TaskSidebar_create(type)
TaskSidebar_create = _mforms.TaskSidebar_create

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

    def __init__(self):
        this = _mforms.new_HyperText()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_markup_text(self, text):
        return _mforms.HyperText_set_markup_text(self, text)

    def set_padding(self, left, top, right, bottom):
        return _mforms.HyperText_set_padding(self, left, top, right, bottom)

    def handle_url_click(self, url):
        return _mforms.HyperText_handle_url_click(self, url)

    def add_link_click_callback(self, callback):
        return _mforms.HyperText_add_link_click_callback(self, callback)

    def call_link_click_callback(self, s):
        return _mforms.HyperText_call_link_click_callback(self, s)
    __swig_destroy__ = _mforms.delete_HyperText
    __del__ = lambda self: None
HyperText_swigregister = _mforms.HyperText_swigregister
HyperText_swigregister(HyperText)


_mforms.StringColumnType_swigconstant(_mforms)
StringColumnType = _mforms.StringColumnType

_mforms.StringLTColumnType_swigconstant(_mforms)
StringLTColumnType = _mforms.StringLTColumnType

_mforms.IntegerColumnType_swigconstant(_mforms)
IntegerColumnType = _mforms.IntegerColumnType

_mforms.LongIntegerColumnType_swigconstant(_mforms)
LongIntegerColumnType = _mforms.LongIntegerColumnType

_mforms.CheckColumnType_swigconstant(_mforms)
CheckColumnType = _mforms.CheckColumnType

_mforms.TriCheckColumnType_swigconstant(_mforms)
TriCheckColumnType = _mforms.TriCheckColumnType

_mforms.IconColumnType_swigconstant(_mforms)
IconColumnType = _mforms.IconColumnType

_mforms.IconStringColumnType_swigconstant(_mforms)
IconStringColumnType = _mforms.IconStringColumnType

_mforms.NumberWithUnitColumnType_swigconstant(_mforms)
NumberWithUnitColumnType = _mforms.NumberWithUnitColumnType

_mforms.FloatColumnType_swigconstant(_mforms)
FloatColumnType = _mforms.FloatColumnType

_mforms.TreeDefault_swigconstant(_mforms)
TreeDefault = _mforms.TreeDefault

_mforms.TreeNoColumns_swigconstant(_mforms)
TreeNoColumns = _mforms.TreeNoColumns

_mforms.TreeAllowReorderRows_swigconstant(_mforms)
TreeAllowReorderRows = _mforms.TreeAllowReorderRows

_mforms.TreeShowColumnLines_swigconstant(_mforms)
TreeShowColumnLines = _mforms.TreeShowColumnLines

_mforms.TreeShowRowLines_swigconstant(_mforms)
TreeShowRowLines = _mforms.TreeShowRowLines

_mforms.TreeNoBorder_swigconstant(_mforms)
TreeNoBorder = _mforms.TreeNoBorder

_mforms.TreeSidebar_swigconstant(_mforms)
TreeSidebar = _mforms.TreeSidebar

_mforms.TreeNoHeader_swigconstant(_mforms)
TreeNoHeader = _mforms.TreeNoHeader

_mforms.TreeShowHeader_swigconstant(_mforms)
TreeShowHeader = _mforms.TreeShowHeader

_mforms.TreeFlatList_swigconstant(_mforms)
TreeFlatList = _mforms.TreeFlatList

_mforms.TreeAltRowColors_swigconstant(_mforms)
TreeAltRowColors = _mforms.TreeAltRowColors

_mforms.TreeSizeSmall_swigconstant(_mforms)
TreeSizeSmall = _mforms.TreeSizeSmall

_mforms.TreeIndexOnTag_swigconstant(_mforms)
TreeIndexOnTag = _mforms.TreeIndexOnTag

_mforms.TreeCanBeDragSource_swigconstant(_mforms)
TreeCanBeDragSource = _mforms.TreeCanBeDragSource

_mforms.TreeSelectSingle_swigconstant(_mforms)
TreeSelectSingle = _mforms.TreeSelectSingle

_mforms.TreeSelectMultiple_swigconstant(_mforms)
TreeSelectMultiple = _mforms.TreeSelectMultiple
class TreeNodeSkeleton(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TreeNodeSkeleton, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TreeNodeSkeleton, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mforms.new_TreeNodeSkeleton(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_setmethods__["caption"] = _mforms.TreeNodeSkeleton_caption_set
    __swig_getmethods__["caption"] = _mforms.TreeNodeSkeleton_caption_get
    if _newclass:
        caption = _swig_property(_mforms.TreeNodeSkeleton_caption_get, _mforms.TreeNodeSkeleton_caption_set)
    __swig_setmethods__["icon"] = _mforms.TreeNodeSkeleton_icon_set
    __swig_getmethods__["icon"] = _mforms.TreeNodeSkeleton_icon_get
    if _newclass:
        icon = _swig_property(_mforms.TreeNodeSkeleton_icon_get, _mforms.TreeNodeSkeleton_icon_set)
    __swig_setmethods__["tag"] = _mforms.TreeNodeSkeleton_tag_set
    __swig_getmethods__["tag"] = _mforms.TreeNodeSkeleton_tag_get
    if _newclass:
        tag = _swig_property(_mforms.TreeNodeSkeleton_tag_get, _mforms.TreeNodeSkeleton_tag_set)
    __swig_setmethods__["children"] = _mforms.TreeNodeSkeleton_children_set
    __swig_getmethods__["children"] = _mforms.TreeNodeSkeleton_children_get
    if _newclass:
        children = _swig_property(_mforms.TreeNodeSkeleton_children_get, _mforms.TreeNodeSkeleton_children_set)
    __swig_destroy__ = _mforms.delete_TreeNodeSkeleton
    __del__ = lambda self: None
TreeNodeSkeleton_swigregister = _mforms.TreeNodeSkeleton_swigregister
TreeNodeSkeleton_swigregister(TreeNodeSkeleton)

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

    def __init__(self, *args):
        this = _mforms.new_TreeNodeCollectionSkeleton(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_setmethods__["icon"] = _mforms.TreeNodeCollectionSkeleton_icon_set
    __swig_getmethods__["icon"] = _mforms.TreeNodeCollectionSkeleton_icon_get
    if _newclass:
        icon = _swig_property(_mforms.TreeNodeCollectionSkeleton_icon_get, _mforms.TreeNodeCollectionSkeleton_icon_set)
    __swig_setmethods__["children"] = _mforms.TreeNodeCollectionSkeleton_children_set
    __swig_getmethods__["children"] = _mforms.TreeNodeCollectionSkeleton_children_get
    if _newclass:
        children = _swig_property(_mforms.TreeNodeCollectionSkeleton_children_get, _mforms.TreeNodeCollectionSkeleton_children_set)
    __swig_setmethods__["captions"] = _mforms.TreeNodeCollectionSkeleton_captions_set
    __swig_getmethods__["captions"] = _mforms.TreeNodeCollectionSkeleton_captions_get
    if _newclass:
        captions = _swig_property(_mforms.TreeNodeCollectionSkeleton_captions_get, _mforms.TreeNodeCollectionSkeleton_captions_set)
    __swig_destroy__ = _mforms.delete_TreeNodeCollectionSkeleton
    __del__ = lambda self: None
TreeNodeCollectionSkeleton_swigregister = _mforms.TreeNodeCollectionSkeleton_swigregister
TreeNodeCollectionSkeleton_swigregister(TreeNodeCollectionSkeleton)

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

    def __init__(self):
        this = _mforms.new_TreeNodeData()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_TreeNodeData
    __del__ = lambda self: None

    def retain(self):
        return _mforms.TreeNodeData_retain(self)

    def release(self):
        return _mforms.TreeNodeData_release(self)
TreeNodeData_swigregister = _mforms.TreeNodeData_swigregister
TreeNodeData_swigregister(TreeNodeData)

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

    def __init__(self, *args):
        this = _mforms.new_TreeNodeRef(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_TreeNodeRef
    __del__ = lambda self: None

    def __deref__(self, *args):
        return _mforms.TreeNodeRef___deref__(self, *args)

    def __nonzero__(self):
        return _mforms.TreeNodeRef___nonzero__(self)
    __bool__ = __nonzero__



    def __lt__(self, other):
        return _mforms.TreeNodeRef___lt__(self, other)

    def __eq__(self, other):
        return _mforms.TreeNodeRef___eq__(self, other)

    def __ne__(self, other):
        return _mforms.TreeNodeRef___ne__(self, other)

    def is_valid(self):
        return _mforms.TreeNodeRef_is_valid(self)

    def equals(self, other):
        return _mforms.TreeNodeRef_equals(self, other)

    def level(self):
        return _mforms.TreeNodeRef_level(self)

    def set_icon_path(self, column, icon):
        return _mforms.TreeNodeRef_set_icon_path(self, column, icon)

    def set_string(self, column, value):
        return _mforms.TreeNodeRef_set_string(self, column, value)

    def set_int(self, column, value):
        return _mforms.TreeNodeRef_set_int(self, column, value)

    def set_long(self, column, value):
        return _mforms.TreeNodeRef_set_long(self, column, value)

    def set_bool(self, column, value):
        return _mforms.TreeNodeRef_set_bool(self, column, value)

    def set_float(self, column, value):
        return _mforms.TreeNodeRef_set_float(self, column, value)

    def set_attributes(self, column, attrs):
        return _mforms.TreeNodeRef_set_attributes(self, column, attrs)

    def get_string(self, column):
        return _mforms.TreeNodeRef_get_string(self, column)

    def get_int(self, column):
        return _mforms.TreeNodeRef_get_int(self, column)

    def get_long(self, column):
        return _mforms.TreeNodeRef_get_long(self, column)

    def get_bool(self, column):
        return _mforms.TreeNodeRef_get_bool(self, column)

    def get_float(self, column):
        return _mforms.TreeNodeRef_get_float(self, column)

    def count(self):
        return _mforms.TreeNodeRef_count(self)

    def add_child(self):
        return _mforms.TreeNodeRef_add_child(self)

    def insert_child(self, index):
        return _mforms.TreeNodeRef_insert_child(self, index)

    def remove_from_parent(self):
        return _mforms.TreeNodeRef_remove_from_parent(self)

    def remove_children(self):
        return _mforms.TreeNodeRef_remove_children(self)

    def get_child(self, index):
        return _mforms.TreeNodeRef_get_child(self, index)

    def get_child_index(self, child):
        return _mforms.TreeNodeRef_get_child_index(self, child)

    def get_parent(self):
        return _mforms.TreeNodeRef_get_parent(self)

    def find_child_with_tag(self, tag):
        return _mforms.TreeNodeRef_find_child_with_tag(self, tag)

    def previous_sibling(self):
        return _mforms.TreeNodeRef_previous_sibling(self)

    def next_sibling(self):
        return _mforms.TreeNodeRef_next_sibling(self)

    def move_node(self, node, before):
        return _mforms.TreeNodeRef_move_node(self, node, before)

    def add_node_collection(self, nodes, position=-1):
        return _mforms.TreeNodeRef_add_node_collection(self, nodes, position)

    def expand(self):
        return _mforms.TreeNodeRef_expand(self)

    def collapse(self):
        return _mforms.TreeNodeRef_collapse(self)

    def is_expanded(self):
        return _mforms.TreeNodeRef_is_expanded(self)

    def can_expand(self):
        return _mforms.TreeNodeRef_can_expand(self)

    def toggle(self):
        return _mforms.TreeNodeRef_toggle(self)

    def set_tag(self, tag):
        return _mforms.TreeNodeRef_set_tag(self, tag)

    def get_tag(self):
        return _mforms.TreeNodeRef_get_tag(self)

    def set_data(self, data):
        return _mforms.TreeNodeRef_set_data(self, data)

    def get_data(self):
        return _mforms.TreeNodeRef_get_data(self)
TreeNodeRef_swigregister = _mforms.TreeNodeRef_swigregister
TreeNodeRef_swigregister(TreeNodeRef)

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

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

    def equals(self, other):
        return _mforms.TreeNode_equals(self, other)

    def level(self):
        return _mforms.TreeNode_level(self)

    def set_icon_path(self, column, icon):
        return _mforms.TreeNode_set_icon_path(self, column, icon)

    def set_string(self, column, value):
        return _mforms.TreeNode_set_string(self, column, value)

    def set_int(self, column, value):
        return _mforms.TreeNode_set_int(self, column, value)

    def set_long(self, column, value):
        return _mforms.TreeNode_set_long(self, column, value)

    def set_bool(self, column, value):
        return _mforms.TreeNode_set_bool(self, column, value)

    def set_float(self, column, value):
        return _mforms.TreeNode_set_float(self, column, value)

    def set_attributes(self, column, attrs):
        return _mforms.TreeNode_set_attributes(self, column, attrs)

    def get_string(self, column):
        return _mforms.TreeNode_get_string(self, column)

    def get_int(self, column):
        return _mforms.TreeNode_get_int(self, column)

    def get_long(self, column):
        return _mforms.TreeNode_get_long(self, column)

    def get_bool(self, column):
        return _mforms.TreeNode_get_bool(self, column)

    def get_float(self, column):
        return _mforms.TreeNode_get_float(self, column)

    def count(self):
        return _mforms.TreeNode_count(self)

    def add_child(self):
        return _mforms.TreeNode_add_child(self)

    def insert_child(self, index):
        return _mforms.TreeNode_insert_child(self, index)

    def remove_from_parent(self):
        return _mforms.TreeNode_remove_from_parent(self)

    def remove_children(self):
        return _mforms.TreeNode_remove_children(self)

    def get_child(self, index):
        return _mforms.TreeNode_get_child(self, index)

    def get_child_index(self, child):
        return _mforms.TreeNode_get_child_index(self, child)

    def get_parent(self):
        return _mforms.TreeNode_get_parent(self)

    def find_child_with_tag(self, tag):
        return _mforms.TreeNode_find_child_with_tag(self, tag)

    def previous_sibling(self):
        return _mforms.TreeNode_previous_sibling(self)

    def next_sibling(self):
        return _mforms.TreeNode_next_sibling(self)

    def move_node(self, node, before):
        return _mforms.TreeNode_move_node(self, node, before)

    def add_node_collection(self, nodes, position=-1):
        return _mforms.TreeNode_add_node_collection(self, nodes, position)

    def expand(self):
        return _mforms.TreeNode_expand(self)

    def collapse(self):
        return _mforms.TreeNode_collapse(self)

    def is_expanded(self):
        return _mforms.TreeNode_is_expanded(self)

    def can_expand(self):
        return _mforms.TreeNode_can_expand(self)

    def toggle(self):
        return _mforms.TreeNode_toggle(self)

    def set_tag(self, tag):
        return _mforms.TreeNode_set_tag(self, tag)

    def get_tag(self):
        return _mforms.TreeNode_get_tag(self)

    def set_data(self, data):
        return _mforms.TreeNode_set_data(self, data)

    def get_data(self):
        return _mforms.TreeNode_get_data(self)
TreeNode_swigregister = _mforms.TreeNode_swigregister
TreeNode_swigregister(TreeNode)

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

    def __init__(self, options):
        this = _mforms.new_TreeView(options)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_TreeView
    __del__ = lambda self: None

    def add_column(self, type, name, initial_width, editable=False, attributed=False):
        return _mforms.TreeView_add_column(self, type, name, initial_width, editable, attributed)

    def end_columns(self):
        return _mforms.TreeView_end_columns(self)

    def set_column_title(self, column, title):
        return _mforms.TreeView_set_column_title(self, column, title)

    def set_row_overlay_handler(self, overlay_icon_for_node):
        return _mforms.TreeView_set_row_overlay_handler(self, overlay_icon_for_node)

    def get_column_count(self):
        return _mforms.TreeView_get_column_count(self)

    def get_column_type(self, column):
        return _mforms.TreeView_get_column_type(self, column)

    def clear(self):
        return _mforms.TreeView_clear(self)

    def root_node(self):
        return _mforms.TreeView_root_node(self)

    def add_node(self):
        return _mforms.TreeView_add_node(self)

    def set_selection_mode(self, mode):
        return _mforms.TreeView_set_selection_mode(self, mode)

    def get_selection_mode(self):
        return _mforms.TreeView_get_selection_mode(self)

    def get_selection(self):
        return _mforms.TreeView_get_selection(self)

    def get_selected_node(self):
        return _mforms.TreeView_get_selected_node(self)

    def get_selected_row(self):
        return _mforms.TreeView_get_selected_row(self)

    def clear_selection(self):
        return _mforms.TreeView_clear_selection(self)

    def select_node(self, node):
        return _mforms.TreeView_select_node(self, node)

    def set_node_selected(self, node, flag):
        return _mforms.TreeView_set_node_selected(self, node, flag)

    def scrollToNode(self, node):
        return _mforms.TreeView_scrollToNode(self, node)

    def row_for_node(self, node):
        return _mforms.TreeView_row_for_node(self, node)

    def node_at_row(self, row):
        return _mforms.TreeView_node_at_row(self, row)

    def node_at_position(self, position):
        return _mforms.TreeView_node_at_position(self, position)

    def node_with_tag(self, tag):
        return _mforms.TreeView_node_with_tag(self, tag)

    def set_row_height(self, height):
        return _mforms.TreeView_set_row_height(self, height)

    def set_allow_sorting(self, flag):
        return _mforms.TreeView_set_allow_sorting(self, flag)

    def freeze_refresh(self):
        return _mforms.TreeView_freeze_refresh(self)

    def thaw_refresh(self):
        return _mforms.TreeView_thaw_refresh(self)

    def set_column_visible(self, column, flag):
        return _mforms.TreeView_set_column_visible(self, column, flag)

    def get_column_visible(self, column):
        return _mforms.TreeView_get_column_visible(self, column)

    def set_context_menu(self, menu):
        return _mforms.TreeView_set_context_menu(self, menu)

    def set_header_menu(self, menu):
        return _mforms.TreeView_set_header_menu(self, menu)

    def get_context_menu(self):
        return _mforms.TreeView_get_context_menu(self)

    def get_header_menu(self):
        return _mforms.TreeView_get_header_menu(self)

    def get_clicked_header_column(self):
        return _mforms.TreeView_get_clicked_header_column(self)

    def get_column_width(self, column):
        return _mforms.TreeView_get_column_width(self, column)

    def set_column_width(self, column, width):
        return _mforms.TreeView_set_column_width(self, column, width)

    def count(self):
        return _mforms.TreeView_count(self)

    def add_activated_callback(self, callback):
        return _mforms.TreeView_add_activated_callback(self, callback)

    def call_activated_callback(self, i, j):
        return _mforms.TreeView_call_activated_callback(self, i, j)

    def add_changed_callback(self, callback):
        return _mforms.TreeView_add_changed_callback(self, callback)

    def call_changed_callback(self):
        return _mforms.TreeView_call_changed_callback(self)

    def add_column_resized_callback(self, callback):
        return _mforms.TreeView_add_column_resized_callback(self, callback)

    def call_column_resized_callback(self, i):
        return _mforms.TreeView_call_column_resized_callback(self, i)

    def set_cell_edited_callback(self, callable):
        return _mforms.TreeView_set_cell_edited_callback(self, callable)
TreeView_swigregister = _mforms.TreeView_swigregister
TreeView_swigregister(TreeView)


_mforms.MIN_SERVER_VERSION_swigconstant(_mforms)
MIN_SERVER_VERSION = _mforms.MIN_SERVER_VERSION

_mforms.MAX_SERVER_VERSION_swigconstant(_mforms)
MAX_SERVER_VERSION = _mforms.MAX_SERVER_VERSION

_mforms.DEFAULT_FONT_FAMILY_swigconstant(_mforms)
DEFAULT_FONT_FAMILY = _mforms.DEFAULT_FONT_FAMILY

_mforms.DEFAULT_FONT_SIZE_swigconstant(_mforms)
DEFAULT_FONT_SIZE = _mforms.DEFAULT_FONT_SIZE

_mforms.DEFAULT_SMALL_FONT_swigconstant(_mforms)
DEFAULT_SMALL_FONT = _mforms.DEFAULT_SMALL_FONT

_mforms.DEFAULT_MONOSPACE_FONT_FAMILY_swigconstant(_mforms)
DEFAULT_MONOSPACE_FONT_FAMILY = _mforms.DEFAULT_MONOSPACE_FONT_FAMILY

_mforms.ColorSchemeStandard_swigconstant(_mforms)
ColorSchemeStandard = _mforms.ColorSchemeStandard

_mforms.ColorSchemeStandardWin7_swigconstant(_mforms)
ColorSchemeStandardWin7 = _mforms.ColorSchemeStandardWin7

_mforms.ColorSchemeStandardWin8_swigconstant(_mforms)
ColorSchemeStandardWin8 = _mforms.ColorSchemeStandardWin8

_mforms.ColorSchemeStandardWin8Alternate_swigconstant(_mforms)
ColorSchemeStandardWin8Alternate = _mforms.ColorSchemeStandardWin8Alternate

_mforms.ColorSchemeHighContrast_swigconstant(_mforms)
ColorSchemeHighContrast = _mforms.ColorSchemeHighContrast

_mforms.ColorSchemeCustom_swigconstant(_mforms)
ColorSchemeCustom = _mforms.ColorSchemeCustom

_mforms.AppColorMainTab_swigconstant(_mforms)
AppColorMainTab = _mforms.AppColorMainTab

_mforms.AppColorMainBackground_swigconstant(_mforms)
AppColorMainBackground = _mforms.AppColorMainBackground

_mforms.AppColorPanelHeader_swigconstant(_mforms)
AppColorPanelHeader = _mforms.AppColorPanelHeader

_mforms.AppColorPanelHeaderFocused_swigconstant(_mforms)
AppColorPanelHeaderFocused = _mforms.AppColorPanelHeaderFocused

_mforms.AppColorPanelToolbar_swigconstant(_mforms)
AppColorPanelToolbar = _mforms.AppColorPanelToolbar

_mforms.AppColorPanelContentArea_swigconstant(_mforms)
AppColorPanelContentArea = _mforms.AppColorPanelContentArea

_mforms.AppColorTabUnselected_swigconstant(_mforms)
AppColorTabUnselected = _mforms.AppColorTabUnselected

_mforms.AppColorBottomTabSelected_swigconstant(_mforms)
AppColorBottomTabSelected = _mforms.AppColorBottomTabSelected

_mforms.AppColorTopTabSelectedFocused_swigconstant(_mforms)
AppColorTopTabSelectedFocused = _mforms.AppColorTopTabSelectedFocused

_mforms.AppColorTopTabSelectedUnfocused_swigconstant(_mforms)
AppColorTopTabSelectedUnfocused = _mforms.AppColorTopTabSelectedUnfocused

_mforms.AppColorStatusbar_swigconstant(_mforms)
AppColorStatusbar = _mforms.AppColorStatusbar

_mforms.ControlShadowColor_swigconstant(_mforms)
ControlShadowColor = _mforms.ControlShadowColor

_mforms.ControlDarkShadowColor_swigconstant(_mforms)
ControlDarkShadowColor = _mforms.ControlDarkShadowColor

_mforms.ControlColor_swigconstant(_mforms)
ControlColor = _mforms.ControlColor

_mforms.ControlHighlightColor_swigconstant(_mforms)
ControlHighlightColor = _mforms.ControlHighlightColor

_mforms.ControlLightHighlightColor_swigconstant(_mforms)
ControlLightHighlightColor = _mforms.ControlLightHighlightColor

_mforms.ControlTextColor_swigconstant(_mforms)
ControlTextColor = _mforms.ControlTextColor

_mforms.ControlBackgroundColor_swigconstant(_mforms)
ControlBackgroundColor = _mforms.ControlBackgroundColor

_mforms.SelectedControlColor_swigconstant(_mforms)
SelectedControlColor = _mforms.SelectedControlColor

_mforms.SecondarySelectedControlColor_swigconstant(_mforms)
SecondarySelectedControlColor = _mforms.SecondarySelectedControlColor

_mforms.SelectedControlTextColor_swigconstant(_mforms)
SelectedControlTextColor = _mforms.SelectedControlTextColor

_mforms.DisabledControlTextColor_swigconstant(_mforms)
DisabledControlTextColor = _mforms.DisabledControlTextColor

_mforms.TextColor_swigconstant(_mforms)
TextColor = _mforms.TextColor

_mforms.TextBackgroundColor_swigconstant(_mforms)
TextBackgroundColor = _mforms.TextBackgroundColor

_mforms.SelectedTextColor_swigconstant(_mforms)
SelectedTextColor = _mforms.SelectedTextColor

_mforms.SelectedTextBackgroundColor_swigconstant(_mforms)
SelectedTextBackgroundColor = _mforms.SelectedTextBackgroundColor

_mforms.GridColor_swigconstant(_mforms)
GridColor = _mforms.GridColor

_mforms.WindowBackgroundColor_swigconstant(_mforms)
WindowBackgroundColor = _mforms.WindowBackgroundColor

_mforms.WindowFrameColor_swigconstant(_mforms)
WindowFrameColor = _mforms.WindowFrameColor

_mforms.WindowFrameTextColor_swigconstant(_mforms)
WindowFrameTextColor = _mforms.WindowFrameTextColor

_mforms.SelectedMenuItemColor_swigconstant(_mforms)
SelectedMenuItemColor = _mforms.SelectedMenuItemColor

_mforms.SelectedMenuItemTextColor_swigconstant(_mforms)
SelectedMenuItemTextColor = _mforms.SelectedMenuItemTextColor

_mforms.HighlightColor_swigconstant(_mforms)
HighlightColor = _mforms.HighlightColor

_mforms.HeaderColor_swigconstant(_mforms)
HeaderColor = _mforms.HeaderColor

_mforms.HeaderTextColor_swigconstant(_mforms)
HeaderTextColor = _mforms.HeaderTextColor

_mforms.AlternateSelectedControlColor_swigconstant(_mforms)
AlternateSelectedControlColor = _mforms.AlternateSelectedControlColor

_mforms.AlternateSelectedControlTextColor_swigconstant(_mforms)
AlternateSelectedControlTextColor = _mforms.AlternateSelectedControlTextColor
class Color(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Color, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Color, name)
    __repr__ = _swig_repr
    __swig_setmethods__["red"] = _mforms.Color_red_set
    __swig_getmethods__["red"] = _mforms.Color_red_get
    if _newclass:
        red = _swig_property(_mforms.Color_red_get, _mforms.Color_red_set)
    __swig_setmethods__["green"] = _mforms.Color_green_set
    __swig_getmethods__["green"] = _mforms.Color_green_get
    if _newclass:
        green = _swig_property(_mforms.Color_green_get, _mforms.Color_green_set)
    __swig_setmethods__["blue"] = _mforms.Color_blue_set
    __swig_getmethods__["blue"] = _mforms.Color_blue_get
    if _newclass:
        blue = _swig_property(_mforms.Color_blue_get, _mforms.Color_blue_set)
    __swig_setmethods__["alpha"] = _mforms.Color_alpha_set
    __swig_getmethods__["alpha"] = _mforms.Color_alpha_get
    if _newclass:
        alpha = _swig_property(_mforms.Color_alpha_get, _mforms.Color_alpha_set)

    def __init__(self, *args):
        this = _mforms.new_Color(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __ne__(self, other):
        return _mforms.Color___ne__(self, other)

    def to_html(self):
        return _mforms.Color_to_html(self)

    def toRGB(self):
        return _mforms.Color_toRGB(self)

    def toBGR(self):
        return _mforms.Color_toBGR(self)

    def is_valid(self):
        return _mforms.Color_is_valid(self)
    __swig_getmethods__["parse"] = lambda x: _mforms.Color_parse
    if _newclass:
        parse = staticmethod(_mforms.Color_parse)
    __swig_getmethods__["Black"] = lambda x: _mforms.Color_Black
    if _newclass:
        Black = staticmethod(_mforms.Color_Black)
    __swig_getmethods__["White"] = lambda x: _mforms.Color_White
    if _newclass:
        White = staticmethod(_mforms.Color_White)
    __swig_getmethods__["Invalid"] = lambda x: _mforms.Color_Invalid
    if _newclass:
        Invalid = staticmethod(_mforms.Color_Invalid)
    __swig_getmethods__["get_application_color"] = lambda x: _mforms.Color_get_application_color
    if _newclass:
        get_application_color = staticmethod(_mforms.Color_get_application_color)
    __swig_getmethods__["get_application_color_as_string"] = lambda x: _mforms.Color_get_application_color_as_string
    if _newclass:
        get_application_color_as_string = staticmethod(_mforms.Color_get_application_color_as_string)
    __swig_getmethods__["getSystemColor"] = lambda x: _mforms.Color_getSystemColor
    if _newclass:
        getSystemColor = staticmethod(_mforms.Color_getSystemColor)
    __swig_getmethods__["set_active_scheme"] = lambda x: _mforms.Color_set_active_scheme
    if _newclass:
        set_active_scheme = staticmethod(_mforms.Color_set_active_scheme)
    __swig_getmethods__["get_active_scheme"] = lambda x: _mforms.Color_get_active_scheme
    if _newclass:
        get_active_scheme = staticmethod(_mforms.Color_get_active_scheme)
    __swig_getmethods__["is_high_contrast_scheme"] = lambda x: _mforms.Color_is_high_contrast_scheme
    if _newclass:
        is_high_contrast_scheme = staticmethod(_mforms.Color_is_high_contrast_scheme)
    __swig_getmethods__["prepareForTesting"] = lambda x: _mforms.Color_prepareForTesting
    if _newclass:
        prepareForTesting = staticmethod(_mforms.Color_prepareForTesting)
    __swig_getmethods__["load_custom_colors"] = lambda x: _mforms.Color_load_custom_colors
    if _newclass:
        load_custom_colors = staticmethod(_mforms.Color_load_custom_colors)
    __swig_getmethods__["save_custom_colors"] = lambda x: _mforms.Color_save_custom_colors
    if _newclass:
        save_custom_colors = staticmethod(_mforms.Color_save_custom_colors)
    __swig_destroy__ = _mforms.delete_Color
    __del__ = lambda self: None
Color_swigregister = _mforms.Color_swigregister
Color_swigregister(Color)

def Color_parse(color):
    return _mforms.Color_parse(color)
Color_parse = _mforms.Color_parse

def Color_Black():
    return _mforms.Color_Black()
Color_Black = _mforms.Color_Black

def Color_White():
    return _mforms.Color_White()
Color_White = _mforms.Color_White

def Color_Invalid():
    return _mforms.Color_Invalid()
Color_Invalid = _mforms.Color_Invalid

def Color_get_application_color(color, foreground):
    return _mforms.Color_get_application_color(color, foreground)
Color_get_application_color = _mforms.Color_get_application_color

def Color_get_application_color_as_string(color, foreground):
    return _mforms.Color_get_application_color_as_string(color, foreground)
Color_get_application_color_as_string = _mforms.Color_get_application_color_as_string

def Color_getSystemColor(colorType):
    return _mforms.Color_getSystemColor(colorType)
Color_getSystemColor = _mforms.Color_getSystemColor

def Color_set_active_scheme(scheme):
    return _mforms.Color_set_active_scheme(scheme)
Color_set_active_scheme = _mforms.Color_set_active_scheme

def Color_get_active_scheme():
    return _mforms.Color_get_active_scheme()
Color_get_active_scheme = _mforms.Color_get_active_scheme

def Color_is_high_contrast_scheme():
    return _mforms.Color_is_high_contrast_scheme()
Color_is_high_contrast_scheme = _mforms.Color_is_high_contrast_scheme

def Color_prepareForTesting():
    return _mforms.Color_prepareForTesting()
Color_prepareForTesting = _mforms.Color_prepareForTesting

def Color_load_custom_colors(colors):
    return _mforms.Color_load_custom_colors(colors)
Color_load_custom_colors = _mforms.Color_load_custom_colors

def Color_save_custom_colors(colors):
    return _mforms.Color_save_custom_colors(colors)
Color_save_custom_colors = _mforms.Color_save_custom_colors

class HSVColor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HSVColor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HSVColor, name)
    __repr__ = _swig_repr
    __swig_setmethods__["h"] = _mforms.HSVColor_h_set
    __swig_getmethods__["h"] = _mforms.HSVColor_h_get
    if _newclass:
        h = _swig_property(_mforms.HSVColor_h_get, _mforms.HSVColor_h_set)
    __swig_setmethods__["s"] = _mforms.HSVColor_s_set
    __swig_getmethods__["s"] = _mforms.HSVColor_s_get
    if _newclass:
        s = _swig_property(_mforms.HSVColor_s_get, _mforms.HSVColor_s_set)
    __swig_setmethods__["v"] = _mforms.HSVColor_v_set
    __swig_getmethods__["v"] = _mforms.HSVColor_v_get
    if _newclass:
        v = _swig_property(_mforms.HSVColor_v_get, _mforms.HSVColor_v_set)
    __swig_setmethods__["a"] = _mforms.HSVColor_a_set
    __swig_getmethods__["a"] = _mforms.HSVColor_a_get
    if _newclass:
        a = _swig_property(_mforms.HSVColor_a_get, _mforms.HSVColor_a_set)

    def __init__(self, *args):
        this = _mforms.new_HSVColor(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_HSVColor
    __del__ = lambda self: None
HSVColor_swigregister = _mforms.HSVColor_swigregister
HSVColor_swigregister(HSVColor)

class OSConstants(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OSConstants, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OSConstants, name)
    __repr__ = _swig_repr
    __swig_getmethods__["defaultFontName"] = lambda x: _mforms.OSConstants_defaultFontName
    if _newclass:
        defaultFontName = staticmethod(_mforms.OSConstants_defaultFontName)
    __swig_getmethods__["systemFontSize"] = lambda x: _mforms.OSConstants_systemFontSize
    if _newclass:
        systemFontSize = staticmethod(_mforms.OSConstants_systemFontSize)
    __swig_getmethods__["smallSystemFontSize"] = lambda x: _mforms.OSConstants_smallSystemFontSize
    if _newclass:
        smallSystemFontSize = staticmethod(_mforms.OSConstants_smallSystemFontSize)
    __swig_getmethods__["labelFontSize"] = lambda x: _mforms.OSConstants_labelFontSize
    if _newclass:
        labelFontSize = staticmethod(_mforms.OSConstants_labelFontSize)

    def __init__(self):
        this = _mforms.new_OSConstants()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_OSConstants
    __del__ = lambda self: None
OSConstants_swigregister = _mforms.OSConstants_swigregister
OSConstants_swigregister(OSConstants)

def OSConstants_defaultFontName():
    return _mforms.OSConstants_defaultFontName()
OSConstants_defaultFontName = _mforms.OSConstants_defaultFontName

def OSConstants_systemFontSize():
    return _mforms.OSConstants_systemFontSize()
OSConstants_systemFontSize = _mforms.OSConstants_systemFontSize

def OSConstants_smallSystemFontSize():
    return _mforms.OSConstants_smallSystemFontSize()
OSConstants_smallSystemFontSize = _mforms.OSConstants_smallSystemFontSize

def OSConstants_labelFontSize():
    return _mforms.OSConstants_labelFontSize()
OSConstants_labelFontSize = _mforms.OSConstants_labelFontSize


def fromgrt(object):
    return _mforms.fromgrt(object)
fromgrt = _mforms.fromgrt

def togrt(object, mforms_type_name):
    return _mforms.togrt(object, mforms_type_name)
togrt = _mforms.togrt
class signal_connection_wrapper(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, signal_connection_wrapper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, signal_connection_wrapper, name)
    __repr__ = _swig_repr

    def disconnect(self):
        return _mforms.signal_connection_wrapper_disconnect(self)

    def __init__(self):
        this = _mforms.new_signal_connection_wrapper()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _mforms.delete_signal_connection_wrapper
    __del__ = lambda self: None
signal_connection_wrapper_swigregister = _mforms.signal_connection_wrapper_swigregister
signal_connection_wrapper_swigregister(signal_connection_wrapper)

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

    def __init__(self):
        this = _mforms.new_PyDrawBox()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_instance(self, instance):
        return _mforms.PyDrawBox_set_instance(self, instance)
    __swig_destroy__ = _mforms.delete_PyDrawBox
    __del__ = lambda self: None
PyDrawBox_swigregister = _mforms.PyDrawBox_swigregister
PyDrawBox_swigregister(PyDrawBox)

# This file is compatible with both classic and new-style classes.