# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# 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('_Data', [dirname(__file__)])
        except ImportError:
            import _Data
            return _Data
        if fp is not None:
            try:
                _mod = imp.load_module('_Data', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _Data = swig_import_helper()
    del swig_import_helper
else:
    import _Data
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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: 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__ = _Data.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self) -> "PyObject *" : return _Data.SwigPyIterator_value(self)
    def incr(self, n : 'size_t' = 1) -> "swig::SwigPyIterator *" : return _Data.SwigPyIterator_incr(self, n)
    def decr(self, n : 'size_t' = 1) -> "swig::SwigPyIterator *" : return _Data.SwigPyIterator_decr(self, n)
    def distance(self, *args) -> "ptrdiff_t" : return _Data.SwigPyIterator_distance(self, *args)
    def equal(self, *args) -> "bool" : return _Data.SwigPyIterator_equal(self, *args)
    def copy(self) -> "swig::SwigPyIterator *" : return _Data.SwigPyIterator_copy(self)
    def next(self) -> "PyObject *" : return _Data.SwigPyIterator_next(self)
    def __next__(self) -> "PyObject *" : return _Data.SwigPyIterator___next__(self)
    def previous(self) -> "PyObject *" : return _Data.SwigPyIterator_previous(self)
    def advance(self, *args) -> "swig::SwigPyIterator *" : return _Data.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args) -> "bool" : return _Data.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _Data.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args) -> "swig::SwigPyIterator &" : return _Data.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args) -> "swig::SwigPyIterator &" : return _Data.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args) -> "swig::SwigPyIterator *" : return _Data.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args) -> "ptrdiff_t" : return _Data.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _Data.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _Data.SHARED_PTR_DISOWN
class PointVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, PointVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PointVector, name)
    __repr__ = _swig_repr
    def __nonzero__(self) -> "bool" : return _Data.PointVector___nonzero__(self)
    def __bool__(self) -> "bool" : return _Data.PointVector___bool__(self)
    def __len__(self) -> "std::vector< TPoint >::size_type" : return _Data.PointVector___len__(self)
    def pop(self) -> "std::vector< TPoint >::value_type" : return _Data.PointVector_pop(self)
    def __getslice__(self, *args) -> "std::vector< TPoint,std::allocator< TPoint > > *" : return _Data.PointVector___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _Data.PointVector___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _Data.PointVector___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _Data.PointVector___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::vector< TPoint >::value_type const &" : return _Data.PointVector___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _Data.PointVector___setitem__(self, *args)
    def append(self, *args) -> "void" : return _Data.PointVector_append(self, *args)
    def empty(self) -> "bool" : return _Data.PointVector_empty(self)
    def size(self) -> "std::vector< TPoint >::size_type" : return _Data.PointVector_size(self)
    def clear(self) -> "void" : return _Data.PointVector_clear(self)
    def swap(self, *args) -> "void" : return _Data.PointVector_swap(self, *args)
    def get_allocator(self) -> "std::vector< TPoint >::allocator_type" : return _Data.PointVector_get_allocator(self)
    def pop_back(self) -> "void" : return _Data.PointVector_pop_back(self)
    def __init__(self, *args): 
        this = _Data.new_PointVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args) -> "void" : return _Data.PointVector_push_back(self, *args)
    def front(self) -> "std::vector< TPoint >::value_type const &" : return _Data.PointVector_front(self)
    def back(self) -> "std::vector< TPoint >::value_type const &" : return _Data.PointVector_back(self)
    def assign(self, *args) -> "void" : return _Data.PointVector_assign(self, *args)
    def resize(self, *args) -> "void" : return _Data.PointVector_resize(self, *args)
    def reserve(self, *args) -> "void" : return _Data.PointVector_reserve(self, *args)
    def capacity(self) -> "std::vector< TPoint >::size_type" : return _Data.PointVector_capacity(self)
    __swig_destroy__ = _Data.delete_PointVector
    __del__ = lambda self : None;
PointVector_swigregister = _Data.PointVector_swigregister
PointVector_swigregister(PointVector)

class CoordSetVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, CoordSetVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CoordSetVector, name)
    __repr__ = _swig_repr
    def __nonzero__(self) -> "bool" : return _Data.CoordSetVector___nonzero__(self)
    def __bool__(self) -> "bool" : return _Data.CoordSetVector___bool__(self)
    def __len__(self) -> "std::vector< Func32::TCoordSet< > >::size_type" : return _Data.CoordSetVector___len__(self)
    def pop(self) -> "std::vector< Func32::TCoordSet< > >::value_type" : return _Data.CoordSetVector_pop(self)
    def __getslice__(self, *args) -> "std::vector< Func32::TCoordSet< >,std::allocator< Func32::TCoordSet< > > > *" : return _Data.CoordSetVector___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _Data.CoordSetVector___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _Data.CoordSetVector___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _Data.CoordSetVector___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::vector< Func32::TCoordSet< > >::value_type const &" : return _Data.CoordSetVector___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _Data.CoordSetVector___setitem__(self, *args)
    def append(self, *args) -> "void" : return _Data.CoordSetVector_append(self, *args)
    def empty(self) -> "bool" : return _Data.CoordSetVector_empty(self)
    def size(self) -> "std::vector< Func32::TCoordSet< > >::size_type" : return _Data.CoordSetVector_size(self)
    def clear(self) -> "void" : return _Data.CoordSetVector_clear(self)
    def swap(self, *args) -> "void" : return _Data.CoordSetVector_swap(self, *args)
    def get_allocator(self) -> "std::vector< Func32::TCoordSet< > >::allocator_type" : return _Data.CoordSetVector_get_allocator(self)
    def pop_back(self) -> "void" : return _Data.CoordSetVector_pop_back(self)
    def __init__(self, *args): 
        this = _Data.new_CoordSetVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args) -> "void" : return _Data.CoordSetVector_push_back(self, *args)
    def front(self) -> "std::vector< Func32::TCoordSet< > >::value_type const &" : return _Data.CoordSetVector_front(self)
    def back(self) -> "std::vector< Func32::TCoordSet< > >::value_type const &" : return _Data.CoordSetVector_back(self)
    def assign(self, *args) -> "void" : return _Data.CoordSetVector_assign(self, *args)
    def resize(self, *args) -> "void" : return _Data.CoordSetVector_resize(self, *args)
    def reserve(self, *args) -> "void" : return _Data.CoordSetVector_reserve(self, *args)
    def capacity(self) -> "std::vector< Func32::TCoordSet< > >::size_type" : return _Data.CoordSetVector_capacity(self)
    __swig_destroy__ = _Data.delete_CoordSetVector
    __del__ = lambda self : None;
CoordSetVector_swigregister = _Data.CoordSetVector_swigregister
CoordSetVector_swigregister(CoordSetVector)

class UnsignedVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, UnsignedVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UnsignedVector, name)
    __repr__ = _swig_repr
    def __nonzero__(self) -> "bool" : return _Data.UnsignedVector___nonzero__(self)
    def __bool__(self) -> "bool" : return _Data.UnsignedVector___bool__(self)
    def __len__(self) -> "std::vector< unsigned int >::size_type" : return _Data.UnsignedVector___len__(self)
    def pop(self) -> "std::vector< unsigned int >::value_type" : return _Data.UnsignedVector_pop(self)
    def __getslice__(self, *args) -> "std::vector< unsigned int,std::allocator< unsigned int > > *" : return _Data.UnsignedVector___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _Data.UnsignedVector___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _Data.UnsignedVector___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _Data.UnsignedVector___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::vector< unsigned int >::value_type const &" : return _Data.UnsignedVector___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _Data.UnsignedVector___setitem__(self, *args)
    def append(self, *args) -> "void" : return _Data.UnsignedVector_append(self, *args)
    def empty(self) -> "bool" : return _Data.UnsignedVector_empty(self)
    def size(self) -> "std::vector< unsigned int >::size_type" : return _Data.UnsignedVector_size(self)
    def clear(self) -> "void" : return _Data.UnsignedVector_clear(self)
    def swap(self, *args) -> "void" : return _Data.UnsignedVector_swap(self, *args)
    def get_allocator(self) -> "std::vector< unsigned int >::allocator_type" : return _Data.UnsignedVector_get_allocator(self)
    def pop_back(self) -> "void" : return _Data.UnsignedVector_pop_back(self)
    def __init__(self, *args): 
        this = _Data.new_UnsignedVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args) -> "void" : return _Data.UnsignedVector_push_back(self, *args)
    def front(self) -> "std::vector< unsigned int >::value_type const &" : return _Data.UnsignedVector_front(self)
    def back(self) -> "std::vector< unsigned int >::value_type const &" : return _Data.UnsignedVector_back(self)
    def assign(self, *args) -> "void" : return _Data.UnsignedVector_assign(self, *args)
    def resize(self, *args) -> "void" : return _Data.UnsignedVector_resize(self, *args)
    def reserve(self, *args) -> "void" : return _Data.UnsignedVector_reserve(self, *args)
    def capacity(self) -> "std::vector< unsigned int >::size_type" : return _Data.UnsignedVector_capacity(self)
    __swig_destroy__ = _Data.delete_UnsignedVector
    __del__ = lambda self : None;
UnsignedVector_swigregister = _Data.UnsignedVector_swigregister
UnsignedVector_swigregister(UnsignedVector)

class StringMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, StringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringMap, name)
    __repr__ = _swig_repr
    def __nonzero__(self) -> "bool" : return _Data.StringMap___nonzero__(self)
    def __bool__(self) -> "bool" : return _Data.StringMap___bool__(self)
    def __len__(self) -> "std::map< std::wstring,std::wstring >::size_type" : return _Data.StringMap___len__(self)
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args) -> "std::map< std::wstring,std::wstring >::mapped_type const &" : return _Data.StringMap___getitem__(self, *args)
    def __delitem__(self, *args) -> "void" : return _Data.StringMap___delitem__(self, *args)
    def has_key(self, *args) -> "bool" : return _Data.StringMap_has_key(self, *args)
    def keys(self) -> "PyObject *" : return _Data.StringMap_keys(self)
    def values(self) -> "PyObject *" : return _Data.StringMap_values(self)
    def items(self) -> "PyObject *" : return _Data.StringMap_items(self)
    def __contains__(self, *args) -> "bool" : return _Data.StringMap___contains__(self, *args)
    def key_iterator(self) -> "swig::SwigPyIterator *" : return _Data.StringMap_key_iterator(self)
    def value_iterator(self) -> "swig::SwigPyIterator *" : return _Data.StringMap_value_iterator(self)
    def __setitem__(self, *args) -> "void" : return _Data.StringMap___setitem__(self, *args)
    def asdict(self) -> "PyObject *" : return _Data.StringMap_asdict(self)
    def __init__(self, *args): 
        this = _Data.new_StringMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self) -> "bool" : return _Data.StringMap_empty(self)
    def size(self) -> "std::map< std::wstring,std::wstring >::size_type" : return _Data.StringMap_size(self)
    def clear(self) -> "void" : return _Data.StringMap_clear(self)
    def swap(self, *args) -> "void" : return _Data.StringMap_swap(self, *args)
    def get_allocator(self) -> "std::map< std::wstring,std::wstring >::allocator_type" : return _Data.StringMap_get_allocator(self)
    def erase(self, *args) -> "std::map< std::wstring,std::wstring >::size_type" : return _Data.StringMap_erase(self, *args)
    def count(self, *args) -> "std::map< std::wstring,std::wstring >::size_type" : return _Data.StringMap_count(self, *args)
    __swig_destroy__ = _Data.delete_StringMap
    __del__ = lambda self : None;
StringMap_swigregister = _Data.StringMap_swigregister
StringMap_swigregister(StringMap)


def AbortUpdate() -> "void" :
  return _Data.AbortUpdate()
AbortUpdate = _Data.AbortUpdate

def Redraw() -> "void" :
  return _Data.Redraw()
Redraw = _Data.Redraw

def GetSelected() -> "TGraphElemPtr" :
  return _Data.GetSelected()
GetSelected = _Data.GetSelected

def SetSelected(*args) -> "void" :
  return _Data.SetSelected(*args)
SetSelected = _Data.SetSelected

def ChildCount(*args) -> "unsigned int" :
  return _Data.ChildCount(*args)
ChildCount = _Data.ChildCount

def GetChild(*args) -> "TGraphElemPtr" :
  return _Data.GetChild(*args)
GetChild = _Data.GetChild

def RemoveChild(*args) -> "void" :
  return _Data.RemoveChild(*args)
RemoveChild = _Data.RemoveChild

def InsertChild(*args) -> "void" :
  return _Data.InsertChild(*args)
InsertChild = _Data.InsertChild

def ReplaceChild(*args) -> "void" :
  return _Data.ReplaceChild(*args)
ReplaceChild = _Data.ReplaceChild

def CompareElem(*args) -> "bool" :
  return _Data.CompareElem(*args)
CompareElem = _Data.CompareElem

def GetPluginData() -> "std::map< std::wstring,std::wstring,std::less< std::wstring >,std::allocator< std::pair< std::wstring const,std::wstring > > > &" :
  return _Data.GetPluginData()
GetPluginData = _Data.GetPluginData

def GetTopElem() -> "boost::shared_ptr< TTopGraphElem > const &" :
  return _Data.GetTopElem()
GetTopElem = _Data.GetTopElem
class TGraphElem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TGraphElem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TGraphElem, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["_PluginData"] = _Data.TGraphElem__PluginData_set
    __swig_getmethods__["_PluginData"] = _Data.TGraphElem__PluginData_get
    if _newclass:_PluginData = _swig_property(_Data.TGraphElem__PluginData_get, _Data.TGraphElem__PluginData_set)
    def MakeLegendText(self) -> "std::wstring" : return _Data.TGraphElem_MakeLegendText(self)
    def MakeText(self) -> "std::wstring" : return _Data.TGraphElem_MakeText(self)
    def Clone(self) -> "TGraphElemPtr" : return _Data.TGraphElem_Clone(self)
    __swig_setmethods__["Visible"] = _Data.TGraphElem_Visible_set
    __swig_getmethods__["Visible"] = _Data.TGraphElem_Visible_get
    if _newclass:Visible = _swig_property(_Data.TGraphElem_Visible_get, _Data.TGraphElem_Visible_set)
    __swig_setmethods__["ShowInLegend"] = _Data.TGraphElem_ShowInLegend_set
    __swig_getmethods__["ShowInLegend"] = _Data.TGraphElem_ShowInLegend_get
    if _newclass:ShowInLegend = _swig_property(_Data.TGraphElem_ShowInLegend_get, _Data.TGraphElem_ShowInLegend_set)
    __swig_setmethods__["LegendText"] = _Data.TGraphElem_LegendText_set
    __swig_getmethods__["LegendText"] = _Data.TGraphElem_LegendText_get
    if _newclass:LegendText = _swig_property(_Data.TGraphElem_LegendText_get, _Data.TGraphElem_LegendText_set)
    __swig_getmethods__["Parent"] = _Data.TGraphElem_Parent_get
    if _newclass:Parent = _swig_property(_Data.TGraphElem_Parent_get)
    def ThisPtr(self) -> "int" : return _Data.TGraphElem_ThisPtr(self)
    def __eq__(self, rhs):
      if not isinstance(rhs, TGraphElem): return False
      return self.ThisPtr() == rhs.ThisPtr()

    __swig_destroy__ = _Data.delete_TGraphElem
    __del__ = lambda self : None;
TGraphElem_swigregister = _Data.TGraphElem_swigregister
TGraphElem_swigregister(TGraphElem)

dtAuto = _Data.dtAuto
dtDots = _Data.dtDots
dtLines = _Data.dtLines
class TBaseFuncType(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TBaseFuncType, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TBaseFuncType, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["sList"] = _Data.TBaseFuncType_sList_get
    if _newclass:sList = _swig_property(_Data.TBaseFuncType_sList_get)
    __swig_getmethods__["Points"] = _Data.TBaseFuncType_Points_get
    if _newclass:Points = _swig_property(_Data.TBaseFuncType_Points_get)
    __swig_getmethods__["PointNum"] = _Data.TBaseFuncType_PointNum_get
    if _newclass:PointNum = _swig_property(_Data.TBaseFuncType_PointNum_get)
    __swig_setmethods__["Color"] = _Data.TBaseFuncType_Color_set
    __swig_getmethods__["Color"] = _Data.TBaseFuncType_Color_get
    if _newclass:Color = _swig_property(_Data.TBaseFuncType_Color_get, _Data.TBaseFuncType_Color_set)
    __swig_setmethods__["Size"] = _Data.TBaseFuncType_Size_set
    __swig_getmethods__["Size"] = _Data.TBaseFuncType_Size_get
    if _newclass:Size = _swig_property(_Data.TBaseFuncType_Size_get, _Data.TBaseFuncType_Size_set)
    __swig_setmethods__["Style"] = _Data.TBaseFuncType_Style_set
    __swig_getmethods__["Style"] = _Data.TBaseFuncType_Style_get
    if _newclass:Style = _swig_property(_Data.TBaseFuncType_Style_get, _Data.TBaseFuncType_Style_set)
    __swig_setmethods__["From"] = _Data.TBaseFuncType_From_set
    __swig_getmethods__["From"] = _Data.TBaseFuncType_From_get
    if _newclass:From = _swig_property(_Data.TBaseFuncType_From_get, _Data.TBaseFuncType_From_set)
    __swig_setmethods__["To"] = _Data.TBaseFuncType_To_set
    __swig_getmethods__["To"] = _Data.TBaseFuncType_To_get
    if _newclass:To = _swig_property(_Data.TBaseFuncType_To_get, _Data.TBaseFuncType_To_set)
    __swig_setmethods__["StartPointStyle"] = _Data.TBaseFuncType_StartPointStyle_set
    __swig_getmethods__["StartPointStyle"] = _Data.TBaseFuncType_StartPointStyle_get
    if _newclass:StartPointStyle = _swig_property(_Data.TBaseFuncType_StartPointStyle_get, _Data.TBaseFuncType_StartPointStyle_set)
    __swig_setmethods__["EndPointStyle"] = _Data.TBaseFuncType_EndPointStyle_set
    __swig_getmethods__["EndPointStyle"] = _Data.TBaseFuncType_EndPointStyle_get
    if _newclass:EndPointStyle = _swig_property(_Data.TBaseFuncType_EndPointStyle_get, _Data.TBaseFuncType_EndPointStyle_set)
    __swig_setmethods__["DrawType"] = _Data.TBaseFuncType_DrawType_set
    __swig_getmethods__["DrawType"] = _Data.TBaseFuncType_DrawType_get
    if _newclass:DrawType = _swig_property(_Data.TBaseFuncType_DrawType_get, _Data.TBaseFuncType_DrawType_set)
    def MakeDifFunc(self) -> "boost::shared_ptr< TBaseFuncType >" : return _Data.TBaseFuncType_MakeDifFunc(self)
    def Eval(self, *args) -> "Func32::TCoord< long double >" : return _Data.TBaseFuncType_Eval(self, *args)
    def CalcArea(self, *args) -> "long double" : return _Data.TBaseFuncType_CalcArea(self, *args)
    __swig_setmethods__["Steps"] = _Data.TBaseFuncType_Steps_set
    __swig_getmethods__["Steps"] = _Data.TBaseFuncType_Steps_get
    if _newclass:Steps = _swig_property(_Data.TBaseFuncType_Steps_get, _Data.TBaseFuncType_Steps_set)
    __swig_getmethods__["Variable"] = _Data.TBaseFuncType_Variable_get
    if _newclass:Variable = _swig_property(_Data.TBaseFuncType_Variable_get)
    __swig_destroy__ = _Data.delete_TBaseFuncType
    __del__ = lambda self : None;
TBaseFuncType_swigregister = _Data.TBaseFuncType_swigregister
TBaseFuncType_swigregister(TBaseFuncType)

class TTopGraphElem(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TTopGraphElem, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TTopGraphElem, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _Data.delete_TTopGraphElem
    __del__ = lambda self : None;
TTopGraphElem_swigregister = _Data.TTopGraphElem_swigregister
TTopGraphElem_swigregister(TTopGraphElem)

class TStdFunc(TBaseFuncType):
    __swig_setmethods__ = {}
    for _s in [TBaseFuncType]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TStdFunc, name, value)
    __swig_getmethods__ = {}
    for _s in [TBaseFuncType]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TStdFunc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Text"] = _Data.TStdFunc_Text_get
    if _newclass:Text = _swig_property(_Data.TStdFunc_Text_get)
    def __init__(self, *args): 
        this = _Data.new_TStdFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TStdFunc
    __del__ = lambda self : None;
TStdFunc_swigregister = _Data.TStdFunc_swigregister
TStdFunc_swigregister(TStdFunc)

class TParFunc(TBaseFuncType):
    __swig_setmethods__ = {}
    for _s in [TBaseFuncType]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TParFunc, name, value)
    __swig_getmethods__ = {}
    for _s in [TBaseFuncType]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TParFunc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["xText"] = _Data.TParFunc_xText_get
    if _newclass:xText = _swig_property(_Data.TParFunc_xText_get)
    __swig_getmethods__["yText"] = _Data.TParFunc_yText_get
    if _newclass:yText = _swig_property(_Data.TParFunc_yText_get)
    def __init__(self, *args): 
        this = _Data.new_TParFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TParFunc
    __del__ = lambda self : None;
TParFunc_swigregister = _Data.TParFunc_swigregister
TParFunc_swigregister(TParFunc)

class TPolFunc(TBaseFuncType):
    __swig_setmethods__ = {}
    for _s in [TBaseFuncType]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TPolFunc, name, value)
    __swig_getmethods__ = {}
    for _s in [TBaseFuncType]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TPolFunc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Text"] = _Data.TPolFunc_Text_get
    if _newclass:Text = _swig_property(_Data.TPolFunc_Text_get)
    def __init__(self, *args): 
        this = _Data.new_TPolFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TPolFunc
    __del__ = lambda self : None;
TPolFunc_swigregister = _Data.TPolFunc_swigregister
TPolFunc_swigregister(TPolFunc)

ttTangent = _Data.ttTangent
ttNormal = _Data.ttNormal
class TTan(TBaseFuncType):
    __swig_setmethods__ = {}
    for _s in [TBaseFuncType]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TTan, name, value)
    __swig_getmethods__ = {}
    for _s in [TBaseFuncType]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TTan, name)
    __repr__ = _swig_repr
    __swig_setmethods__["t"] = _Data.TTan_t_set
    __swig_getmethods__["t"] = _Data.TTan_t_get
    if _newclass:t = _swig_property(_Data.TTan_t_get, _Data.TTan_t_set)
    __swig_setmethods__["TangentType"] = _Data.TTan_TangentType_set
    __swig_getmethods__["TangentType"] = _Data.TTan_TangentType_get
    if _newclass:TangentType = _swig_property(_Data.TTan_TangentType_get, _Data.TTan_TangentType_set)
    __swig_getmethods__["Valid"] = _Data.TTan_Valid_get
    if _newclass:Valid = _swig_property(_Data.TTan_Valid_get)
    def __init__(self): 
        this = _Data.new_TTan()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TTan
    __del__ = lambda self : None;
TTan_swigregister = _Data.TTan_swigregister
TTan_swigregister(TTan)

ebtNone = _Data.ebtNone
ebtFixed = _Data.ebtFixed
ebtRelative = _Data.ebtRelative
ebtCustom = _Data.ebtCustom
iaLinear = _Data.iaLinear
iaCubicSpline = _Data.iaCubicSpline
iaHalfCosine = _Data.iaHalfCosine
iaCubicSpline2 = _Data.iaCubicSpline2
ptCartesian = _Data.ptCartesian
ptPolar = _Data.ptPolar
lpAbove = _Data.lpAbove
lpBelow = _Data.lpBelow
lpLeft = _Data.lpLeft
lpRight = _Data.lpRight
lpAboveLeft = _Data.lpAboveLeft
lpAboveRight = _Data.lpAboveRight
lpBelowLeft = _Data.lpBelowLeft
lpBelowRight = _Data.lpBelowRight
class TPointSeries(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TPointSeries, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TPointSeries, name)
    __repr__ = _swig_repr
    def InsertDblPoint(self, *args) -> "void" : return _Data.TPointSeries_InsertDblPoint(self, *args)
    def InsertPoint(self, *args) -> "void" : return _Data.TPointSeries_InsertPoint(self, *args)
    def ReplaceDblPoint(self, *args) -> "void" : return _Data.TPointSeries_ReplaceDblPoint(self, *args)
    def ReplacePoint(self, *args) -> "void" : return _Data.TPointSeries_ReplacePoint(self, *args)
    def DeletePoint(self, *args) -> "void" : return _Data.TPointSeries_DeletePoint(self, *args)
    def GetDblPoint(self, *args) -> "Func32::TDblPoint const &" : return _Data.TPointSeries_GetDblPoint(self, *args)
    def GetPoint(self, *args) -> "TPointSeriesPoint const &" : return _Data.TPointSeries_GetPoint(self, *args)
    def PointCount(self) -> "unsigned int" : return _Data.TPointSeries_PointCount(self)
    __swig_setmethods__["xErrorBarType"] = _Data.TPointSeries_xErrorBarType_set
    __swig_getmethods__["xErrorBarType"] = _Data.TPointSeries_xErrorBarType_get
    if _newclass:xErrorBarType = _swig_property(_Data.TPointSeries_xErrorBarType_get, _Data.TPointSeries_xErrorBarType_set)
    __swig_setmethods__["yErrorBarType"] = _Data.TPointSeries_yErrorBarType_set
    __swig_getmethods__["yErrorBarType"] = _Data.TPointSeries_yErrorBarType_get
    if _newclass:yErrorBarType = _swig_property(_Data.TPointSeries_yErrorBarType_get, _Data.TPointSeries_yErrorBarType_set)
    __swig_setmethods__["xErrorValue"] = _Data.TPointSeries_xErrorValue_set
    __swig_getmethods__["xErrorValue"] = _Data.TPointSeries_xErrorValue_get
    if _newclass:xErrorValue = _swig_property(_Data.TPointSeries_xErrorValue_get, _Data.TPointSeries_xErrorValue_set)
    __swig_setmethods__["yErrorValue"] = _Data.TPointSeries_yErrorValue_set
    __swig_getmethods__["yErrorValue"] = _Data.TPointSeries_yErrorValue_get
    if _newclass:yErrorValue = _swig_property(_Data.TPointSeries_yErrorValue_get, _Data.TPointSeries_yErrorValue_set)
    __swig_setmethods__["FillColor"] = _Data.TPointSeries_FillColor_set
    __swig_getmethods__["FillColor"] = _Data.TPointSeries_FillColor_get
    if _newclass:FillColor = _swig_property(_Data.TPointSeries_FillColor_get, _Data.TPointSeries_FillColor_set)
    __swig_setmethods__["LineColor"] = _Data.TPointSeries_LineColor_set
    __swig_getmethods__["LineColor"] = _Data.TPointSeries_LineColor_get
    if _newclass:LineColor = _swig_property(_Data.TPointSeries_LineColor_get, _Data.TPointSeries_LineColor_set)
    __swig_setmethods__["FrameColor"] = _Data.TPointSeries_FrameColor_set
    __swig_getmethods__["FrameColor"] = _Data.TPointSeries_FrameColor_get
    if _newclass:FrameColor = _swig_property(_Data.TPointSeries_FrameColor_get, _Data.TPointSeries_FrameColor_set)
    __swig_setmethods__["Size"] = _Data.TPointSeries_Size_set
    __swig_getmethods__["Size"] = _Data.TPointSeries_Size_get
    if _newclass:Size = _swig_property(_Data.TPointSeries_Size_get, _Data.TPointSeries_Size_set)
    __swig_setmethods__["Style"] = _Data.TPointSeries_Style_set
    __swig_getmethods__["Style"] = _Data.TPointSeries_Style_get
    if _newclass:Style = _swig_property(_Data.TPointSeries_Style_get, _Data.TPointSeries_Style_set)
    __swig_setmethods__["LineSize"] = _Data.TPointSeries_LineSize_set
    __swig_getmethods__["LineSize"] = _Data.TPointSeries_LineSize_get
    if _newclass:LineSize = _swig_property(_Data.TPointSeries_LineSize_get, _Data.TPointSeries_LineSize_set)
    __swig_setmethods__["LineStyle"] = _Data.TPointSeries_LineStyle_set
    __swig_getmethods__["LineStyle"] = _Data.TPointSeries_LineStyle_get
    if _newclass:LineStyle = _swig_property(_Data.TPointSeries_LineStyle_get, _Data.TPointSeries_LineStyle_set)
    __swig_setmethods__["Interpolation"] = _Data.TPointSeries_Interpolation_set
    __swig_getmethods__["Interpolation"] = _Data.TPointSeries_Interpolation_get
    if _newclass:Interpolation = _swig_property(_Data.TPointSeries_Interpolation_get, _Data.TPointSeries_Interpolation_set)
    __swig_setmethods__["ShowLabels"] = _Data.TPointSeries_ShowLabels_set
    __swig_getmethods__["ShowLabels"] = _Data.TPointSeries_ShowLabels_get
    if _newclass:ShowLabels = _swig_property(_Data.TPointSeries_ShowLabels_get, _Data.TPointSeries_ShowLabels_set)
    __swig_getmethods__["Font"] = _Data.TPointSeries_Font_get
    if _newclass:Font = _swig_property(_Data.TPointSeries_Font_get)
    __swig_setmethods__["LabelPosition"] = _Data.TPointSeries_LabelPosition_set
    __swig_getmethods__["LabelPosition"] = _Data.TPointSeries_LabelPosition_get
    if _newclass:LabelPosition = _swig_property(_Data.TPointSeries_LabelPosition_get, _Data.TPointSeries_LabelPosition_set)
    __swig_setmethods__["PointType"] = _Data.TPointSeries_PointType_set
    __swig_getmethods__["PointType"] = _Data.TPointSeries_PointType_get
    if _newclass:PointType = _swig_property(_Data.TPointSeries_PointType_get, _Data.TPointSeries_PointType_set)
    def __init__(self): 
        this = _Data.new_TPointSeries()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TPointSeries
    __del__ = lambda self : None;
TPointSeries_swigregister = _Data.TPointSeries_swigregister
TPointSeries_swigregister(TPointSeries)

lpUserTopLeft = _Data.lpUserTopLeft
lpAboveX = _Data.lpAboveX
lpBelowX = _Data.lpBelowX
lpLeftOfY = _Data.lpLeftOfY
lpRightOfY = _Data.lpRightOfY
lpUserTopRight = _Data.lpUserTopRight
lpUserBottomLeft = _Data.lpUserBottomLeft
lpUserBottomRight = _Data.lpUserBottomRight
class TTextLabel(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TTextLabel, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TTextLabel, name)
    __repr__ = _swig_repr
    def Scale(self, *args) -> "void" : return _Data.TTextLabel_Scale(self, *args)
    def GetImage(self) -> "TMetafile *" : return _Data.TTextLabel_GetImage(self)
    __swig_getmethods__["Rect"] = _Data.TTextLabel_Rect_get
    if _newclass:Rect = _swig_property(_Data.TTextLabel_Rect_get)
    __swig_setmethods__["xPos"] = _Data.TTextLabel_xPos_set
    __swig_getmethods__["xPos"] = _Data.TTextLabel_xPos_get
    if _newclass:xPos = _swig_property(_Data.TTextLabel_xPos_get, _Data.TTextLabel_xPos_set)
    __swig_setmethods__["yPos"] = _Data.TTextLabel_yPos_set
    __swig_getmethods__["yPos"] = _Data.TTextLabel_yPos_get
    if _newclass:yPos = _swig_property(_Data.TTextLabel_yPos_get, _Data.TTextLabel_yPos_set)
    __swig_setmethods__["Text"] = _Data.TTextLabel_Text_set
    __swig_getmethods__["Text"] = _Data.TTextLabel_Text_get
    if _newclass:Text = _swig_property(_Data.TTextLabel_Text_get, _Data.TTextLabel_Text_set)
    __swig_setmethods__["BackgroundColor"] = _Data.TTextLabel_BackgroundColor_set
    __swig_getmethods__["BackgroundColor"] = _Data.TTextLabel_BackgroundColor_get
    if _newclass:BackgroundColor = _swig_property(_Data.TTextLabel_BackgroundColor_get, _Data.TTextLabel_BackgroundColor_set)
    __swig_setmethods__["Placement"] = _Data.TTextLabel_Placement_set
    __swig_getmethods__["Placement"] = _Data.TTextLabel_Placement_get
    if _newclass:Placement = _swig_property(_Data.TTextLabel_Placement_get, _Data.TTextLabel_Placement_set)
    __swig_setmethods__["Rotation"] = _Data.TTextLabel_Rotation_set
    __swig_getmethods__["Rotation"] = _Data.TTextLabel_Rotation_get
    if _newclass:Rotation = _swig_property(_Data.TTextLabel_Rotation_get, _Data.TTextLabel_Rotation_set)
    def __init__(self): 
        this = _Data.new_TTextLabel()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TTextLabel
    __del__ = lambda self : None;
TTextLabel_swigregister = _Data.TTextLabel_swigregister
TTextLabel_swigregister(TTextLabel)

ssAbove = _Data.ssAbove
ssBelow = _Data.ssBelow
ssXAxis = _Data.ssXAxis
ssYAxis = _Data.ssYAxis
ssBetween = _Data.ssBetween
ssInside = _Data.ssInside
class TShading(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TShading, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TShading, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ShadeStyle"] = _Data.TShading_ShadeStyle_set
    __swig_getmethods__["ShadeStyle"] = _Data.TShading_ShadeStyle_get
    if _newclass:ShadeStyle = _swig_property(_Data.TShading_ShadeStyle_get, _Data.TShading_ShadeStyle_set)
    __swig_setmethods__["BrushStyle"] = _Data.TShading_BrushStyle_set
    __swig_getmethods__["BrushStyle"] = _Data.TShading_BrushStyle_get
    if _newclass:BrushStyle = _swig_property(_Data.TShading_BrushStyle_get, _Data.TShading_BrushStyle_set)
    __swig_setmethods__["Color"] = _Data.TShading_Color_set
    __swig_getmethods__["Color"] = _Data.TShading_Color_get
    if _newclass:Color = _swig_property(_Data.TShading_Color_get, _Data.TShading_Color_set)
    __swig_setmethods__["Func2"] = _Data.TShading_Func2_set
    __swig_getmethods__["Func2"] = _Data.TShading_Func2_get
    if _newclass:Func2 = _swig_property(_Data.TShading_Func2_get, _Data.TShading_Func2_set)
    __swig_setmethods__["sMin"] = _Data.TShading_sMin_set
    __swig_getmethods__["sMin"] = _Data.TShading_sMin_get
    if _newclass:sMin = _swig_property(_Data.TShading_sMin_get, _Data.TShading_sMin_set)
    __swig_setmethods__["sMax"] = _Data.TShading_sMax_set
    __swig_getmethods__["sMax"] = _Data.TShading_sMax_get
    if _newclass:sMax = _swig_property(_Data.TShading_sMax_get, _Data.TShading_sMax_set)
    __swig_setmethods__["sMin2"] = _Data.TShading_sMin2_set
    __swig_getmethods__["sMin2"] = _Data.TShading_sMin2_get
    if _newclass:sMin2 = _swig_property(_Data.TShading_sMin2_get, _Data.TShading_sMin2_set)
    __swig_setmethods__["sMax2"] = _Data.TShading_sMax2_set
    __swig_getmethods__["sMax2"] = _Data.TShading_sMax2_get
    if _newclass:sMax2 = _swig_property(_Data.TShading_sMax2_get, _Data.TShading_sMax2_set)
    __swig_setmethods__["ExtendMinToIntercept"] = _Data.TShading_ExtendMinToIntercept_set
    __swig_getmethods__["ExtendMinToIntercept"] = _Data.TShading_ExtendMinToIntercept_get
    if _newclass:ExtendMinToIntercept = _swig_property(_Data.TShading_ExtendMinToIntercept_get, _Data.TShading_ExtendMinToIntercept_set)
    __swig_setmethods__["ExtendMaxToIntercept"] = _Data.TShading_ExtendMaxToIntercept_set
    __swig_getmethods__["ExtendMaxToIntercept"] = _Data.TShading_ExtendMaxToIntercept_get
    if _newclass:ExtendMaxToIntercept = _swig_property(_Data.TShading_ExtendMaxToIntercept_get, _Data.TShading_ExtendMaxToIntercept_set)
    __swig_setmethods__["ExtendMin2ToIntercept"] = _Data.TShading_ExtendMin2ToIntercept_set
    __swig_getmethods__["ExtendMin2ToIntercept"] = _Data.TShading_ExtendMin2ToIntercept_get
    if _newclass:ExtendMin2ToIntercept = _swig_property(_Data.TShading_ExtendMin2ToIntercept_get, _Data.TShading_ExtendMin2ToIntercept_set)
    __swig_setmethods__["ExtendMax2ToIntercept"] = _Data.TShading_ExtendMax2ToIntercept_set
    __swig_getmethods__["ExtendMax2ToIntercept"] = _Data.TShading_ExtendMax2ToIntercept_get
    if _newclass:ExtendMax2ToIntercept = _swig_property(_Data.TShading_ExtendMax2ToIntercept_get, _Data.TShading_ExtendMax2ToIntercept_set)
    __swig_setmethods__["MarkBorder"] = _Data.TShading_MarkBorder_set
    __swig_getmethods__["MarkBorder"] = _Data.TShading_MarkBorder_get
    if _newclass:MarkBorder = _swig_property(_Data.TShading_MarkBorder_get, _Data.TShading_MarkBorder_set)
    def __init__(self): 
        this = _Data.new_TShading()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TShading
    __del__ = lambda self : None;
TShading_swigregister = _Data.TShading_swigregister
TShading_swigregister(TShading)

rtEquation = _Data.rtEquation
rtInequality = _Data.rtInequality
class TRelation(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TRelation, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TRelation, name)
    __repr__ = _swig_repr
    def Eval(self, *args) -> "long double" : return _Data.TRelation_Eval(self, *args)
    __swig_setmethods__["Color"] = _Data.TRelation_Color_set
    __swig_getmethods__["Color"] = _Data.TRelation_Color_get
    if _newclass:Color = _swig_property(_Data.TRelation_Color_get, _Data.TRelation_Color_set)
    __swig_setmethods__["Alpha"] = _Data.TRelation_Alpha_set
    __swig_getmethods__["Alpha"] = _Data.TRelation_Alpha_get
    if _newclass:Alpha = _swig_property(_Data.TRelation_Alpha_get, _Data.TRelation_Alpha_set)
    __swig_setmethods__["BrushStyle"] = _Data.TRelation_BrushStyle_set
    __swig_getmethods__["BrushStyle"] = _Data.TRelation_BrushStyle_get
    if _newclass:BrushStyle = _swig_property(_Data.TRelation_BrushStyle_get, _Data.TRelation_BrushStyle_set)
    __swig_setmethods__["LineStyle"] = _Data.TRelation_LineStyle_set
    __swig_getmethods__["LineStyle"] = _Data.TRelation_LineStyle_get
    if _newclass:LineStyle = _swig_property(_Data.TRelation_LineStyle_get, _Data.TRelation_LineStyle_set)
    __swig_getmethods__["RelationType"] = _Data.TRelation_RelationType_get
    if _newclass:RelationType = _swig_property(_Data.TRelation_RelationType_get)
    __swig_getmethods__["Text"] = _Data.TRelation_Text_get
    if _newclass:Text = _swig_property(_Data.TRelation_Text_get)
    __swig_getmethods__["Constraints"] = _Data.TRelation_Constraints_get
    if _newclass:Constraints = _swig_property(_Data.TRelation_Constraints_get)
    __swig_setmethods__["Size"] = _Data.TRelation_Size_set
    __swig_getmethods__["Size"] = _Data.TRelation_Size_get
    if _newclass:Size = _swig_property(_Data.TRelation_Size_get, _Data.TRelation_Size_set)
    def __init__(self, *args): 
        this = _Data.new_TRelation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Data.delete_TRelation
    __del__ = lambda self : None;
TRelation_swigregister = _Data.TRelation_swigregister
TRelation_swigregister(TRelation)

class TAxesView(TGraphElem):
    __swig_setmethods__ = {}
    for _s in [TGraphElem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TAxesView, name, value)
    __swig_getmethods__ = {}
    for _s in [TGraphElem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TAxesView, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _Data.delete_TAxesView
    __del__ = lambda self : None;
TAxesView_swigregister = _Data.TAxesView_swigregister
TAxesView_swigregister(TAxesView)

class TData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr_nondynamic(self, TData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TData, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["Axes"] = _Data.TData_Axes_get
    if _newclass:Axes = _swig_property(_Data.TData_Axes_get)
TData_swigregister = _Data.TData_swigregister
TData_swigregister(TData)

import vcl
def GraphElemRepr(self):
  return '%s("%s")' % (self.__class__.__name__, self.MakeText())
TStdFunc.__repr__ = GraphElemRepr
TParFunc.__repr__ = GraphElemRepr
TPolFunc.__repr__ = GraphElemRepr
TTan.__repr__ = GraphElemRepr
TPointSeries.__repr__ = GraphElemRepr
TRelation.__repr__ = GraphElemRepr
TTextLabel.__repr__ = GraphElemRepr
TShading.__repr__ = GraphElemRepr
TAxesView.__repr__ = GraphElemRepr
TTopGraphElem.__repr__ = GraphElemRepr
def SetPoints(self, L):
  while len(self.Points) > 0: del self.Points[0]
  for n in L: self.Points.append(n)
TPointSeries.__swig_setmethods__["Points"] = SetPoints
TPointSeries.__swig_getmethods__["Points"] = lambda self: TPointDataList(self)
TPointSeries.__swig_getmethods__["PointData"] = lambda self: TPointList(self)

import collections
class TPointList(collections.MutableSequence):
  def __init__(self, PointSeries):
    self.PointSeries = PointSeries
  def __getitem__(self, key):
    return self.PointSeries.GetPoint(key)
  def __len__(self):
    return self.PointSeries.PointCount()
  def insert(self, key, value):
    self.PointSeries.InsertPoint(value, key)
  def __setitem__(self, key, value):
    self.PointSeries.ReplacePoint(value, key)
  def append(self, value):
    self.PointSeries.InsertPoint(value, -1)
  def __delitem__(self, key):
    self.PointSeries.DeletePoint(key)
  def __repr__(self):
    return repr(list(self))

class TPointDataList(collections.MutableSequence):
  def UnpackSlice(s):
    count = self.PointSeries.PointCount()
    start = 0 if key.start is None else (max(count+key.start, 0) if key.start < 0 else key.start)
    stop = count if key.stop is None else (max(count+key.stop, 0) if key.stop < 0 else min(key.stop, count))

  def __init__(self, PointSeries):
    self.PointSeries = PointSeries
  def __getitem__(self, key):
    if isinstance(key, slice):
      count = self.PointSeries.PointCount()
      start = 0 if key.start is None else (max(count+key.start,0) if key.start < 0 else key.start)
      stop = count if key.stop is None else (max(count+key.stop,0) if key.stop < 0 else min(key.stop, count))
      step = 1 if key.step is None else key.step
      return [self.PointSeries.GetDblPoint(i) for i in range(start, stop, step)]
    return self.PointSeries.GetDblPoint(key)
  def __len__(self):
    return self.PointSeries.PointCount()
  def insert(self, key, value):
    self.PointSeries.InsertDblPoint(value, key)
  def __setitem__(self, key, value):
    if isinstance(key, slice):
      count = self.PointSeries.PointCount()
      start = 0 if key.start is None else (count+key.start if key.start < 0 else key.start)
      stop = count if key.stop is None else (max(count+key.stop, 0) if key.stop < 0 else min(key.stop, count))
      if key.step is None or key.step == 1:
        self.PointSeries.DeletePoint(start, stop - start)
        for x in zip(value, range(start, start + len(value))):
          self.PointSeries.InsertDblPoint(x[0], x[1])
      elif len(range(start, stop, key.step)) == len(value):
        for x in zip(value, range(start, stop, key.step)):
          self.PointSeries.ReplaceDblPoint(x[0], x[1])
      else:
        raise ValueError("attempt to assign sequence of size %d to extended slice of size %d" % (len(value), len(range(start, stop, key.step))))
    else:
      self.PointSeries.ReplaceDblPoint(value, key)
  def append(self, value):
    self.PointSeries.InsertDblPoint(value, -1)
  def __delitem__(self, key):
    if isinstance(key, slice):
      count = self.PointSeries.PointCount()
      start = 0 if key.start is None else (count+key.start if key.start < 0 else key.start)
      stop = count if key.stop is None else (count+key.stop if key.stop < 0 else key.stop)
      if key.step is None or key.step == 1:
        self.PointSeries.DeletePoint(key.start, key.stop - key.start)
      else:
        for i in reversed(range(start, stop, key.step)):
          self.PointSeries.DeletePoint(i)
    else:
      self.PointSeries.DeletePoint(key)
  def __repr__(self):
    return repr(list(self))
  def __eq__(self, other):
    if self is other:
      return True
    if len(other) !=  self.PointSeries.PointCount():
      return False
    for i in range(len(other)):
      if other[i] != self.PointSeries.GetDblPoint(i):
        return False
    return True
  def __ne__(self, other):
    return not self == other

# This file is compatible with both classic and new-style classes.


