# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.6
#
# 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 False:
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_pcbnew', [dirname(__file__)])
        except ImportError:
            import _pcbnew
            return _pcbnew
        if fp is not None:
            try:
                _mod = imp.load_module('_pcbnew', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _pcbnew = swig_import_helper()
    del swig_import_helper
else:
    import _pcbnew
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:
        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):
    """Proxy of C++ swig::SwigPyIterator class"""
    __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__ = _pcbnew.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _pcbnew.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _pcbnew.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _pcbnew.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pcbnew.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator_copy(self)


    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator___next__(self)


    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pcbnew.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pcbnew.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _pcbnew.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _pcbnew.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class string(_object):
    """Proxy of C++ std::basic_string<(char)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string, name)
    __repr__ = _swig_repr

    def length(self):
        """length(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_length(self)


    def max_size(self):
        """max_size(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_max_size(self)


    def capacity(self):
        """capacity(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_capacity(self)


    def reserve(self, __res_arg=0):
        """
        reserve(string self, std::basic_string< char >::size_type __res_arg=0)
        reserve(string self)
        """
        return _pcbnew.string_reserve(self, __res_arg)


    def copy(self, __s, __n, __pos=0):
        """
        copy(string self, char * __s, std::basic_string< char >::size_type __n, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        copy(string self, char * __s, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_copy(self, __s, __n, __pos)


    def c_str(self):
        """c_str(string self) -> char const *"""
        return _pcbnew.string_c_str(self)


    def find(self, *args):
        """
        find(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find(string self, string __str) -> std::basic_string< char >::size_type
        find(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find(string self, char __c) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find(self, *args)


    def rfind(self, *args):
        """
        rfind(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
        rfind(string self, string __str) -> std::basic_string< char >::size_type
        rfind(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        rfind(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
        rfind(string self, char __c) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_rfind(self, *args)


    def find_first_of(self, *args):
        """
        find_first_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find_first_of(string self, string __str) -> std::basic_string< char >::size_type
        find_first_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_first_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find_first_of(string self, char __c) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_first_of(self, *args)


    def find_last_of(self, *args):
        """
        find_last_of(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
        find_last_of(string self, string __str) -> std::basic_string< char >::size_type
        find_last_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_last_of(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
        find_last_of(string self, char __c) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_last_of(self, *args)


    def find_first_not_of(self, *args):
        """
        find_first_not_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find_first_not_of(string self, string __str) -> std::basic_string< char >::size_type
        find_first_not_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_first_not_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find_first_not_of(string self, char __c) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_first_not_of(self, *args)


    def find_last_not_of(self, *args):
        """
        find_last_not_of(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
        find_last_not_of(string self, string __str) -> std::basic_string< char >::size_type
        find_last_not_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_last_not_of(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
        find_last_not_of(string self, char __c) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_last_not_of(self, *args)


    def substr(self, *args):
        """
        substr(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n) -> string
        substr(string self, std::basic_string< char >::size_type __pos=0) -> string
        substr(string self) -> string
        """
        return _pcbnew.string_substr(self, *args)


    def empty(self):
        """empty(string self) -> bool"""
        return _pcbnew.string_empty(self)


    def size(self):
        """size(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_size(self)


    def swap(self, v):
        """swap(string self, string v)"""
        return _pcbnew.string_swap(self, v)


    def get_allocator(self):
        """get_allocator(string self) -> std::basic_string< char >::allocator_type"""
        return _pcbnew.string_get_allocator(self)


    def begin(self):
        """begin(string self) -> std::basic_string< char >::iterator"""
        return _pcbnew.string_begin(self)


    def end(self):
        """end(string self) -> std::basic_string< char >::iterator"""
        return _pcbnew.string_end(self)


    def rbegin(self):
        """rbegin(string self) -> std::basic_string< char >::reverse_iterator"""
        return _pcbnew.string_rbegin(self)


    def rend(self):
        """rend(string self) -> std::basic_string< char >::reverse_iterator"""
        return _pcbnew.string_rend(self)


    def erase(self, *args):
        """
        erase(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n) -> string
        erase(string self, std::basic_string< char >::size_type __pos=0) -> string
        erase(string self) -> string
        erase(string self, std::basic_string< char >::iterator pos) -> std::basic_string< char >::iterator
        erase(string self, std::basic_string< char >::iterator first, std::basic_string< char >::iterator last) -> std::basic_string< char >::iterator
        """
        return _pcbnew.string_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::basic_string<(char)> self, char const * __s, std::basic_string< char >::size_type __n) -> string
        __init__(std::basic_string<(char)> self) -> string
        __init__(std::basic_string<(char)> self, string arg2) -> string
        __init__(std::basic_string<(char)> self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string
        """
        this = _pcbnew.new_string(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def assign(self, *args):
        """
        assign(string self, string __str) -> string
        assign(string self, string __str, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> string
        assign(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
        assign(string self, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
        """
        return _pcbnew.string_assign(self, *args)


    def resize(self, *args):
        """
        resize(string self, std::basic_string< char >::size_type new_size)
        resize(string self, std::basic_string< char >::size_type new_size, std::basic_string< char >::value_type x)
        """
        return _pcbnew.string_resize(self, *args)


    def iterator(self):
        """iterator(string self) -> SwigPyIterator"""
        return _pcbnew.string_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(string self) -> bool"""
        return _pcbnew.string___nonzero__(self)


    def __bool__(self):
        """__bool__(string self) -> bool"""
        return _pcbnew.string___bool__(self)


    def __len__(self):
        """__len__(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) -> string"""
        return _pcbnew.string___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v)
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)
        """
        return _pcbnew.string___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)"""
        return _pcbnew.string___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(string self, std::basic_string< char >::difference_type i)
        __delitem__(string self, PySliceObject * slice)
        """
        return _pcbnew.string___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(string self, PySliceObject * slice) -> string
        __getitem__(string self, std::basic_string< char >::difference_type i) -> std::basic_string< char >::value_type
        """
        return _pcbnew.string___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(string self, PySliceObject * slice, string v)
        __setitem__(string self, PySliceObject * slice)
        __setitem__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::value_type x)
        """
        return _pcbnew.string___setitem__(self, *args)


    def insert(self, *args):
        """
        insert(string self, std::basic_string< char >::size_type __pos1, string __str) -> string
        insert(string self, std::basic_string< char >::size_type __pos1, string __str, std::basic_string< char >::size_type __pos2, std::basic_string< char >::size_type __n) -> string
        insert(string self, std::basic_string< char >::size_type __pos, char const * __s, std::basic_string< char >::size_type __n) -> string
        insert(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, char __c) -> string
        insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::value_type x) -> std::basic_string< char >::iterator
        insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
        insert(string self, std::basic_string< char >::iterator __p, std::basic_string< char >::size_type __n, char __c)
        """
        return _pcbnew.string_insert(self, *args)


    def replace(self, *args):
        """
        replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, string __str) -> string
        replace(string self, std::basic_string< char >::size_type __pos1, std::basic_string< char >::size_type __n1, string __str, std::basic_string< char >::size_type __pos2, std::basic_string< char >::size_type __n2) -> string
        replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n1, char const * __s, std::basic_string< char >::size_type __n2) -> string
        replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n1, std::basic_string< char >::size_type __n2, char __c) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, string __str) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __s, std::basic_string< char >::size_type __n) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, std::basic_string< char >::size_type __n, char __c) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __k1, char const * __k2) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, std::basic_string< char >::const_iterator __k1, std::basic_string< char >::const_iterator __k2) -> string
        """
        return _pcbnew.string_replace(self, *args)


    def __iadd__(self, v):
        """__iadd__(string self, string v) -> string"""
        return _pcbnew.string___iadd__(self, v)


    def __add__(self, v):
        """__add__(string self, string v) -> string"""
        return _pcbnew.string___add__(self, v)


    def __radd__(self, v):
        """__radd__(string self, string v) -> string"""
        return _pcbnew.string___radd__(self, v)


    def __str__(self):
        """__str__(string self) -> string"""
        return _pcbnew.string___str__(self)


    def __rlshift__(self, out):
        """__rlshift__(string self, std::basic_ostream< char,std::char_traits< char > > & out) -> std::basic_ostream< char,std::char_traits< char > > &"""
        return _pcbnew.string___rlshift__(self, out)


    def __eq__(self, v):
        """__eq__(string self, string v) -> bool"""
        return _pcbnew.string___eq__(self, v)


    def __ne__(self, v):
        """__ne__(string self, string v) -> bool"""
        return _pcbnew.string___ne__(self, v)


    def __gt__(self, v):
        """__gt__(string self, string v) -> bool"""
        return _pcbnew.string___gt__(self, v)


    def __lt__(self, v):
        """__lt__(string self, string v) -> bool"""
        return _pcbnew.string___lt__(self, v)


    def __ge__(self, v):
        """__ge__(string self, string v) -> bool"""
        return _pcbnew.string___ge__(self, v)


    def __le__(self, v):
        """__le__(string self, string v) -> bool"""
        return _pcbnew.string___le__(self, v)

    __swig_destroy__ = _pcbnew.delete_string
    __del__ = lambda self: None
string_swigregister = _pcbnew.string_swigregister
string_swigregister(string)
cvar = _pcbnew.cvar
string.npos = _pcbnew.cvar.string_npos


def wxSetDefaultPyEncoding(encoding):
    """wxSetDefaultPyEncoding(char const * encoding)"""
    return _pcbnew.wxSetDefaultPyEncoding(encoding)

def wxGetDefaultPyEncoding():
    """wxGetDefaultPyEncoding() -> char const *"""
    return _pcbnew.wxGetDefaultPyEncoding()
class wxRect(_object):
    """Proxy of C++ wxRect class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wxRect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wxRect, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(wxRect self) -> wxRect
        __init__(wxRect self, int xx, int yy, int ww, int hh) -> wxRect
        __init__(wxRect self, wxPoint topLeft, wxPoint bottomRight) -> wxRect
        __init__(wxRect self, wxPoint pt, wxSize size) -> wxRect
        __init__(wxRect self, wxSize size) -> wxRect
        """
        this = _pcbnew.new_wxRect(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetX(self):
        """GetX(wxRect self) -> int"""
        return _pcbnew.wxRect_GetX(self)


    def SetX(self, xx):
        """SetX(wxRect self, int xx)"""
        return _pcbnew.wxRect_SetX(self, xx)


    def GetY(self):
        """GetY(wxRect self) -> int"""
        return _pcbnew.wxRect_GetY(self)


    def SetY(self, yy):
        """SetY(wxRect self, int yy)"""
        return _pcbnew.wxRect_SetY(self, yy)


    def GetWidth(self):
        """GetWidth(wxRect self) -> int"""
        return _pcbnew.wxRect_GetWidth(self)


    def SetWidth(self, w):
        """SetWidth(wxRect self, int w)"""
        return _pcbnew.wxRect_SetWidth(self, w)


    def GetHeight(self):
        """GetHeight(wxRect self) -> int"""
        return _pcbnew.wxRect_GetHeight(self)


    def SetHeight(self, h):
        """SetHeight(wxRect self, int h)"""
        return _pcbnew.wxRect_SetHeight(self, h)


    def GetPosition(self):
        """GetPosition(wxRect self) -> wxPoint"""
        return _pcbnew.wxRect_GetPosition(self)


    def SetPosition(self, p):
        """SetPosition(wxRect self, wxPoint p)"""
        return _pcbnew.wxRect_SetPosition(self, p)

    __swig_setmethods__["x"] = _pcbnew.wxRect_x_set
    __swig_getmethods__["x"] = _pcbnew.wxRect_x_get
    if _newclass:
        x = _swig_property(_pcbnew.wxRect_x_get, _pcbnew.wxRect_x_set)
    __swig_setmethods__["y"] = _pcbnew.wxRect_y_set
    __swig_getmethods__["y"] = _pcbnew.wxRect_y_get
    if _newclass:
        y = _swig_property(_pcbnew.wxRect_y_get, _pcbnew.wxRect_y_set)
    __swig_setmethods__["width"] = _pcbnew.wxRect_width_set
    __swig_getmethods__["width"] = _pcbnew.wxRect_width_get
    if _newclass:
        width = _swig_property(_pcbnew.wxRect_width_get, _pcbnew.wxRect_width_set)
    __swig_setmethods__["height"] = _pcbnew.wxRect_height_set
    __swig_getmethods__["height"] = _pcbnew.wxRect_height_get
    if _newclass:
        height = _swig_property(_pcbnew.wxRect_height_get, _pcbnew.wxRect_height_set)

    def Get(self):
        """Get(wxRect self) -> PyObject *"""
        return _pcbnew.wxRect_Get(self)



    def __eq__(self,other):
        return self.x==other.x and self.y==other.y and self.width==other.width and self.height==other.height
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wxRect'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if  index == 0:     self.SetX(val)
        elif    index == 1:     self.SetY(val)
        elif    index == 2:     self.SetWidth(val)
        elif    index == 3:     self.SetHeight(val)
        else:           raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0,0,0)
    __safe_for_unpickling__ = True

    __swig_destroy__ = _pcbnew.delete_wxRect
    __del__ = lambda self: None
wxRect_swigregister = _pcbnew.wxRect_swigregister
wxRect_swigregister(wxRect)

class wxSize(_object):
    """Proxy of C++ wxSize class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wxSize, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wxSize, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _pcbnew.wxSize_x_set
    __swig_getmethods__["x"] = _pcbnew.wxSize_x_get
    if _newclass:
        x = _swig_property(_pcbnew.wxSize_x_get, _pcbnew.wxSize_x_set)
    __swig_setmethods__["y"] = _pcbnew.wxSize_y_set
    __swig_getmethods__["y"] = _pcbnew.wxSize_y_get
    if _newclass:
        y = _swig_property(_pcbnew.wxSize_y_get, _pcbnew.wxSize_y_set)

    def __init__(self, *args):
        """
        __init__(wxSize self, int xx, int yy) -> wxSize
        __init__(wxSize self, double xx, double yy) -> wxSize
        """
        this = _pcbnew.new_wxSize(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Get(self):
        """Get(wxSize self) -> PyObject *"""
        return _pcbnew.wxSize_Get(self)

    __swig_destroy__ = _pcbnew.delete_wxSize
    __del__ = lambda self: None

    def SetWidth(self, w):
        """SetWidth(wxSize self, int w)"""
        return _pcbnew.wxSize_SetWidth(self, w)


    def SetHeight(self, h):
        """SetHeight(wxSize self, int h)"""
        return _pcbnew.wxSize_SetHeight(self, h)


    def GetWidth(self):
        """GetWidth(wxSize self) -> int"""
        return _pcbnew.wxSize_GetWidth(self)


    def GetHeight(self):
        """GetHeight(wxSize self) -> int"""
        return _pcbnew.wxSize_GetHeight(self)


    def Scale(self,xscale,yscale):
        return wxSize(self.x*xscale,self.y*yscale)
    def __eq__(self,other):
        return self.GetWidth()==other.GetWidth() and self.GetHeight()==other.GetHeight()
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wxSize'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if  index == 0:     self.SetWidth(val)
        elif    index == 1:     self.SetHeight(val)
        else:           raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    __safe_for_unpickling__ = True


wxSize_swigregister = _pcbnew.wxSize_swigregister
wxSize_swigregister(wxSize)

class wxPoint(_object):
    """Proxy of C++ wxPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wxPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wxPoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _pcbnew.wxPoint_x_set
    __swig_getmethods__["x"] = _pcbnew.wxPoint_x_get
    if _newclass:
        x = _swig_property(_pcbnew.wxPoint_x_get, _pcbnew.wxPoint_x_set)
    __swig_setmethods__["y"] = _pcbnew.wxPoint_y_set
    __swig_getmethods__["y"] = _pcbnew.wxPoint_y_get
    if _newclass:
        y = _swig_property(_pcbnew.wxPoint_y_get, _pcbnew.wxPoint_y_set)

    def __init__(self, *args):
        """
        __init__(wxPoint self, int xx, int yy) -> wxPoint
        __init__(wxPoint self, double xx, double yy) -> wxPoint
        """
        this = _pcbnew.new_wxPoint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_wxPoint
    __del__ = lambda self: None

    def __add__(self, pt):
        """__add__(wxPoint self, wxPoint pt) -> wxPoint"""
        return _pcbnew.wxPoint___add__(self, pt)


    def __sub__(self, pt):
        """__sub__(wxPoint self, wxPoint pt) -> wxPoint"""
        return _pcbnew.wxPoint___sub__(self, pt)


    def Set(self, x, y):
        """Set(wxPoint self, long x, long y)"""
        return _pcbnew.wxPoint_Set(self, x, y)


    def Get(self):
        """Get(wxPoint self) -> PyObject *"""
        return _pcbnew.wxPoint_Get(self)


    def __eq__(self,other):            return (self.x==other.x and self.y==other.y)
    def __ne__(self,other):            return not (self==other)
    def __str__(self):                 return str(self.Get())
    def __repr__(self):                return 'wxPoint'+str(self.Get())
    def __len__(self):                 return len(self.Get())
    def __getitem__(self, index):      return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0:
            self.x = val
        elif index == 1:
            self.y = val
        else:
            raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)


wxPoint_swigregister = _pcbnew.wxPoint_swigregister
wxPoint_swigregister(wxPoint)

class wxPoint_Vector(_object):
    """Proxy of C++ std::vector<(wxPoint)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wxPoint_Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wxPoint_Vector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(wxPoint_Vector self) -> SwigPyIterator"""
        return _pcbnew.wxPoint_Vector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(wxPoint_Vector self) -> bool"""
        return _pcbnew.wxPoint_Vector___nonzero__(self)


    def __bool__(self):
        """__bool__(wxPoint_Vector self) -> bool"""
        return _pcbnew.wxPoint_Vector___bool__(self)


    def __len__(self):
        """__len__(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
        return _pcbnew.wxPoint_Vector___len__(self)


    def pop(self):
        """pop(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j) -> wxPoint_Vector"""
        return _pcbnew.wxPoint_Vector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j, wxPoint_Vector v)
        __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j)
        """
        return _pcbnew.wxPoint_Vector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j)"""
        return _pcbnew.wxPoint_Vector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i)
        __delitem__(wxPoint_Vector self, PySliceObject * slice)
        """
        return _pcbnew.wxPoint_Vector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(wxPoint_Vector self, PySliceObject * slice) -> wxPoint_Vector
        __getitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i) -> wxPoint
        """
        return _pcbnew.wxPoint_Vector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(wxPoint_Vector self, PySliceObject * slice, wxPoint_Vector v)
        __setitem__(wxPoint_Vector self, PySliceObject * slice)
        __setitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, wxPoint x)
        """
        return _pcbnew.wxPoint_Vector___setitem__(self, *args)


    def append(self, x):
        """append(wxPoint_Vector self, wxPoint x)"""
        return _pcbnew.wxPoint_Vector_append(self, x)


    def empty(self):
        """empty(wxPoint_Vector self) -> bool"""
        return _pcbnew.wxPoint_Vector_empty(self)


    def size(self):
        """size(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
        return _pcbnew.wxPoint_Vector_size(self)


    def clear(self):
        """clear(wxPoint_Vector self)"""
        return _pcbnew.wxPoint_Vector_clear(self)


    def swap(self, v):
        """swap(wxPoint_Vector self, wxPoint_Vector v)"""
        return _pcbnew.wxPoint_Vector_swap(self, v)


    def get_allocator(self):
        """get_allocator(wxPoint_Vector self) -> std::vector< wxPoint >::allocator_type"""
        return _pcbnew.wxPoint_Vector_get_allocator(self)


    def begin(self):
        """begin(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
        return _pcbnew.wxPoint_Vector_begin(self)


    def end(self):
        """end(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
        return _pcbnew.wxPoint_Vector_end(self)


    def rbegin(self):
        """rbegin(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
        return _pcbnew.wxPoint_Vector_rbegin(self)


    def rend(self):
        """rend(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
        return _pcbnew.wxPoint_Vector_rend(self)


    def pop_back(self):
        """pop_back(wxPoint_Vector self)"""
        return _pcbnew.wxPoint_Vector_pop_back(self)


    def erase(self, *args):
        """
        erase(wxPoint_Vector self, std::vector< wxPoint >::iterator pos) -> std::vector< wxPoint >::iterator
        erase(wxPoint_Vector self, std::vector< wxPoint >::iterator first, std::vector< wxPoint >::iterator last) -> std::vector< wxPoint >::iterator
        """
        return _pcbnew.wxPoint_Vector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(wxPoint)> self) -> wxPoint_Vector
        __init__(std::vector<(wxPoint)> self, wxPoint_Vector arg2) -> wxPoint_Vector
        __init__(std::vector<(wxPoint)> self, std::vector< wxPoint >::size_type size) -> wxPoint_Vector
        __init__(std::vector<(wxPoint)> self, std::vector< wxPoint >::size_type size, wxPoint value) -> wxPoint_Vector
        """
        this = _pcbnew.new_wxPoint_Vector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(wxPoint_Vector self, wxPoint x)"""
        return _pcbnew.wxPoint_Vector_push_back(self, x)


    def front(self):
        """front(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_front(self)


    def back(self):
        """back(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_back(self)


    def assign(self, n, x):
        """assign(wxPoint_Vector self, std::vector< wxPoint >::size_type n, wxPoint x)"""
        return _pcbnew.wxPoint_Vector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(wxPoint_Vector self, std::vector< wxPoint >::size_type new_size)
        resize(wxPoint_Vector self, std::vector< wxPoint >::size_type new_size, wxPoint x)
        """
        return _pcbnew.wxPoint_Vector_resize(self, *args)


    def insert(self, *args):
        """
        insert(wxPoint_Vector self, std::vector< wxPoint >::iterator pos, wxPoint x) -> std::vector< wxPoint >::iterator
        insert(wxPoint_Vector self, std::vector< wxPoint >::iterator pos, std::vector< wxPoint >::size_type n, wxPoint x)
        """
        return _pcbnew.wxPoint_Vector_insert(self, *args)


    def reserve(self, n):
        """reserve(wxPoint_Vector self, std::vector< wxPoint >::size_type n)"""
        return _pcbnew.wxPoint_Vector_reserve(self, n)


    def capacity(self):
        """capacity(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
        return _pcbnew.wxPoint_Vector_capacity(self)

    __swig_destroy__ = _pcbnew.delete_wxPoint_Vector
    __del__ = lambda self: None
wxPoint_Vector_swigregister = _pcbnew.wxPoint_Vector_swigregister
wxPoint_Vector_swigregister(wxPoint_Vector)

class DHEAD(_object):
    """Proxy of C++ DHEAD class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DHEAD, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DHEAD, name)

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

    def DeleteAll(self):
        """DeleteAll(DHEAD self)"""
        return _pcbnew.DHEAD_DeleteAll(self)


    def SetOwnership(self, Iown):
        """SetOwnership(DHEAD self, bool Iown)"""
        return _pcbnew.DHEAD_SetOwnership(self, Iown)


    def GetCount(self):
        """GetCount(DHEAD self) -> unsigned int"""
        return _pcbnew.DHEAD_GetCount(self)

DHEAD_swigregister = _pcbnew.DHEAD_swigregister
DHEAD_swigregister(DHEAD)


_pcbnew.NO_FILL_swigconstant(_pcbnew)
NO_FILL = _pcbnew.NO_FILL

_pcbnew.FILLED_SHAPE_swigconstant(_pcbnew)
FILLED_SHAPE = _pcbnew.FILLED_SHAPE

_pcbnew.FILLED_WITH_BG_BODYCOLOR_swigconstant(_pcbnew)
FILLED_WITH_BG_BODYCOLOR = _pcbnew.FILLED_WITH_BG_BODYCOLOR

_pcbnew.SEARCH_QUIT_swigconstant(_pcbnew)
SEARCH_QUIT = _pcbnew.SEARCH_QUIT

_pcbnew.SEARCH_CONTINUE_swigconstant(_pcbnew)
SEARCH_CONTINUE = _pcbnew.SEARCH_CONTINUE
class INSPECTOR(_object):
    """Proxy of C++ INSPECTOR class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, INSPECTOR, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, INSPECTOR, name)

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

    def Inspect(self, aItem, aTestData):
        """Inspect(INSPECTOR self, EDA_ITEM aItem, void const * aTestData) -> SEARCH_RESULT"""
        return _pcbnew.INSPECTOR_Inspect(self, aItem, aTestData)

INSPECTOR_swigregister = _pcbnew.INSPECTOR_swigregister
INSPECTOR_swigregister(INSPECTOR)
traceFindReplace = cvar.traceFindReplace


_pcbnew.IS_CHANGED_swigconstant(_pcbnew)
IS_CHANGED = _pcbnew.IS_CHANGED

_pcbnew.IS_LINKED_swigconstant(_pcbnew)
IS_LINKED = _pcbnew.IS_LINKED

_pcbnew.IN_EDIT_swigconstant(_pcbnew)
IN_EDIT = _pcbnew.IN_EDIT

_pcbnew.IS_MOVED_swigconstant(_pcbnew)
IS_MOVED = _pcbnew.IS_MOVED

_pcbnew.IS_NEW_swigconstant(_pcbnew)
IS_NEW = _pcbnew.IS_NEW

_pcbnew.IS_RESIZED_swigconstant(_pcbnew)
IS_RESIZED = _pcbnew.IS_RESIZED

_pcbnew.IS_DRAGGED_swigconstant(_pcbnew)
IS_DRAGGED = _pcbnew.IS_DRAGGED

_pcbnew.IS_DELETED_swigconstant(_pcbnew)
IS_DELETED = _pcbnew.IS_DELETED

_pcbnew.IS_WIRE_IMAGE_swigconstant(_pcbnew)
IS_WIRE_IMAGE = _pcbnew.IS_WIRE_IMAGE

_pcbnew.STARTPOINT_swigconstant(_pcbnew)
STARTPOINT = _pcbnew.STARTPOINT

_pcbnew.ENDPOINT_swigconstant(_pcbnew)
ENDPOINT = _pcbnew.ENDPOINT

_pcbnew.SELECTED_swigconstant(_pcbnew)
SELECTED = _pcbnew.SELECTED

_pcbnew.SELECTEDNODE_swigconstant(_pcbnew)
SELECTEDNODE = _pcbnew.SELECTEDNODE

_pcbnew.STRUCT_DELETED_swigconstant(_pcbnew)
STRUCT_DELETED = _pcbnew.STRUCT_DELETED

_pcbnew.CANDIDATE_swigconstant(_pcbnew)
CANDIDATE = _pcbnew.CANDIDATE

_pcbnew.SKIP_STRUCT_swigconstant(_pcbnew)
SKIP_STRUCT = _pcbnew.SKIP_STRUCT

_pcbnew.DO_NOT_DRAW_swigconstant(_pcbnew)
DO_NOT_DRAW = _pcbnew.DO_NOT_DRAW

_pcbnew.IS_CANCELLED_swigconstant(_pcbnew)
IS_CANCELLED = _pcbnew.IS_CANCELLED

_pcbnew.TRACK_LOCKED_swigconstant(_pcbnew)
TRACK_LOCKED = _pcbnew.TRACK_LOCKED

_pcbnew.TRACK_AR_swigconstant(_pcbnew)
TRACK_AR = _pcbnew.TRACK_AR

_pcbnew.FLAG1_swigconstant(_pcbnew)
FLAG1 = _pcbnew.FLAG1

_pcbnew.FLAG0_swigconstant(_pcbnew)
FLAG0 = _pcbnew.FLAG0

_pcbnew.BEGIN_ONPAD_swigconstant(_pcbnew)
BEGIN_ONPAD = _pcbnew.BEGIN_ONPAD

_pcbnew.END_ONPAD_swigconstant(_pcbnew)
END_ONPAD = _pcbnew.END_ONPAD

_pcbnew.BUSY_swigconstant(_pcbnew)
BUSY = _pcbnew.BUSY

_pcbnew.HIGHLIGHTED_swigconstant(_pcbnew)
HIGHLIGHTED = _pcbnew.HIGHLIGHTED

_pcbnew.BRIGHTENED_swigconstant(_pcbnew)
BRIGHTENED = _pcbnew.BRIGHTENED

_pcbnew.DP_COUPLED_swigconstant(_pcbnew)
DP_COUPLED = _pcbnew.DP_COUPLED

_pcbnew.EDA_ITEM_ALL_FLAGS_swigconstant(_pcbnew)
EDA_ITEM_ALL_FLAGS = _pcbnew.EDA_ITEM_ALL_FLAGS
class EDA_ITEM(_object):
    """Proxy of C++ EDA_ITEM class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_ITEM, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EDA_ITEM, name)

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

    def Type(self):
        """Type(EDA_ITEM self) -> KICAD_T"""
        return _pcbnew.EDA_ITEM_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(EDA_ITEM self, time_t aNewTimeStamp)"""
        return _pcbnew.EDA_ITEM_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(EDA_ITEM self) -> time_t"""
        return _pcbnew.EDA_ITEM_GetTimeStamp(self)


    def Next(self):
        """Next(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_Next(self)


    def Back(self):
        """Back(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_Back(self)


    def GetParent(self):
        """GetParent(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_GetParent(self)


    def GetList(self):
        """GetList(EDA_ITEM self) -> DHEAD"""
        return _pcbnew.EDA_ITEM_GetList(self)


    def SetParent(self, aParent):
        """SetParent(EDA_ITEM self, EDA_ITEM aParent)"""
        return _pcbnew.EDA_ITEM_SetParent(self, aParent)


    def SetList(self, aList):
        """SetList(EDA_ITEM self, DHEAD aList)"""
        return _pcbnew.EDA_ITEM_SetList(self, aList)


    def IsNew(self):
        """IsNew(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsNew(self)


    def IsModified(self):
        """IsModified(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsModified(self)


    def IsMoving(self):
        """IsMoving(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsMoving(self)


    def IsDragging(self):
        """IsDragging(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsDragging(self)


    def IsWireImage(self):
        """IsWireImage(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsWireImage(self)


    def IsSelected(self):
        """IsSelected(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsSelected(self)


    def IsResized(self):
        """IsResized(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsResized(self)


    def IsHighlighted(self):
        """IsHighlighted(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsHighlighted(self)


    def IsBrightened(self):
        """IsBrightened(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsBrightened(self)


    def SetWireImage(self):
        """SetWireImage(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetWireImage(self)


    def SetSelected(self):
        """SetSelected(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetSelected(self)


    def SetHighlighted(self):
        """SetHighlighted(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetHighlighted(self)


    def SetBrightened(self):
        """SetBrightened(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetBrightened(self)


    def ClearSelected(self):
        """ClearSelected(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearSelected(self)


    def ClearHighlighted(self):
        """ClearHighlighted(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearHighlighted(self)


    def ClearBrightened(self):
        """ClearBrightened(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearBrightened(self)


    def SetModified(self):
        """SetModified(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetModified(self)


    def GetState(self, type):
        """GetState(EDA_ITEM self, int type) -> int"""
        return _pcbnew.EDA_ITEM_GetState(self, type)


    def SetState(self, type, state):
        """SetState(EDA_ITEM self, int type, int state)"""
        return _pcbnew.EDA_ITEM_SetState(self, type, state)


    def GetStatus(self):
        """GetStatus(EDA_ITEM self) -> STATUS_FLAGS"""
        return _pcbnew.EDA_ITEM_GetStatus(self)


    def SetStatus(self, aStatus):
        """SetStatus(EDA_ITEM self, STATUS_FLAGS aStatus)"""
        return _pcbnew.EDA_ITEM_SetStatus(self, aStatus)


    def SetFlags(self, aMask):
        """SetFlags(EDA_ITEM self, STATUS_FLAGS aMask)"""
        return _pcbnew.EDA_ITEM_SetFlags(self, aMask)


    def ClearFlags(self, aMask=-1):
        """
        ClearFlags(EDA_ITEM self, STATUS_FLAGS aMask=-1)
        ClearFlags(EDA_ITEM self)
        """
        return _pcbnew.EDA_ITEM_ClearFlags(self, aMask)


    def GetFlags(self):
        """GetFlags(EDA_ITEM self) -> STATUS_FLAGS"""
        return _pcbnew.EDA_ITEM_GetFlags(self)


    def SetImage(self, aItem):
        """SetImage(EDA_ITEM self, EDA_ITEM aItem)"""
        return _pcbnew.EDA_ITEM_SetImage(self, aItem)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(EDA_ITEM self, bool aEnable)"""
        return _pcbnew.EDA_ITEM_SetForceVisible(self, aEnable)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(EDA_ITEM self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDA_ITEM_GetMsgPanelInfo(self, aList)


    def HitTest(self, aPosition):
        """HitTest(EDA_ITEM self, wxPoint aPosition) -> bool"""
        return _pcbnew.EDA_ITEM_HitTest(self, aPosition)


    def GetBoundingBox(self):
        """GetBoundingBox(EDA_ITEM self) -> EDA_RECT"""
        return _pcbnew.EDA_ITEM_GetBoundingBox(self)


    def Clone(self):
        """Clone(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_Clone(self)


    def IterateForward(listStart, inspector, testData, scanTypes):
        """IterateForward(EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes)

    if _newclass:
        IterateForward = staticmethod(IterateForward)
    __swig_getmethods__["IterateForward"] = lambda x: IterateForward

    def Visit(self, inspector, testData, scanTypes):
        """Visit(EDA_ITEM self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.EDA_ITEM_Visit(self, inspector, testData, scanTypes)


    def GetClass(self):
        """GetClass(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(EDA_ITEM self) -> BITMAP_DEF"""
        return _pcbnew.EDA_ITEM_GetMenuImage(self)


    def Matches(self, aSearchData, aAuxData, aFindLocation):
        """Matches(EDA_ITEM self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.EDA_ITEM_Matches(self, aSearchData, aAuxData, aFindLocation)


    def Replace(self, *args):
        """
        Replace(EDA_ITEM self, wxFindReplaceData & aSearchData, wxString & aText) -> bool
        Replace(EDA_ITEM self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        Replace(EDA_ITEM self, wxFindReplaceData & aSearchData) -> bool
        """
        return _pcbnew.EDA_ITEM_Replace(self, *args)


    def IsReplaceable(self):
        """IsReplaceable(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsReplaceable(self)


    def __lt__(self, aItem):
        """__lt__(EDA_ITEM self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.EDA_ITEM___lt__(self, aItem)


    def Sort(aLeft, aRight):
        """Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)

    if _newclass:
        Sort = staticmethod(Sort)
    __swig_getmethods__["Sort"] = lambda x: Sort

    def ViewBBox(self):
        """ViewBBox(EDA_ITEM self) -> BOX2I const"""
        return _pcbnew.EDA_ITEM_ViewBBox(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(EDA_ITEM self, int [] aLayers, int & aCount)"""
        return _pcbnew.EDA_ITEM_ViewGetLayers(self, aLayers, aCount)

EDA_ITEM_swigregister = _pcbnew.EDA_ITEM_swigregister
EDA_ITEM_swigregister(EDA_ITEM)

def EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes):
    """EDA_ITEM_IterateForward(EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
    return _pcbnew.EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes)

def EDA_ITEM_Sort(aLeft, aRight):
    """EDA_ITEM_Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
    return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)


def new_clone(aItem):
    """new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
    return _pcbnew.new_clone(aItem)
class EDA_RECT(_object):
    """Proxy of C++ EDA_RECT class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_RECT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EDA_RECT, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(EDA_RECT self) -> EDA_RECT
        __init__(EDA_RECT self, wxPoint aPos, wxSize aSize) -> EDA_RECT
        """
        this = _pcbnew.new_EDA_RECT(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Centre(self):
        """Centre(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_Centre(self)


    def Move(self, aMoveVector):
        """Move(EDA_RECT self, wxPoint aMoveVector)"""
        return _pcbnew.EDA_RECT_Move(self, aMoveVector)


    def Normalize(self):
        """Normalize(EDA_RECT self)"""
        return _pcbnew.EDA_RECT_Normalize(self)


    def Contains(self, *args):
        """
        Contains(EDA_RECT self, wxPoint aPoint) -> bool
        Contains(EDA_RECT self, int x, int y) -> bool
        Contains(EDA_RECT self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.EDA_RECT_Contains(self, *args)


    def GetSize(self):
        """GetSize(EDA_RECT self) -> wxSize"""
        return _pcbnew.EDA_RECT_GetSize(self)


    def GetX(self):
        """GetX(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetX(self)


    def GetY(self):
        """GetY(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetY(self)


    def GetOrigin(self):
        """GetOrigin(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetOrigin(self)


    def GetPosition(self):
        """GetPosition(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetPosition(self)


    def GetEnd(self):
        """GetEnd(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetEnd(self)


    def GetWidth(self):
        """GetWidth(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetWidth(self)


    def GetHeight(self):
        """GetHeight(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetHeight(self)


    def GetRight(self):
        """GetRight(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetRight(self)


    def GetLeft(self):
        """GetLeft(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetLeft(self)


    def GetBottom(self):
        """GetBottom(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetBottom(self)


    def SetOrigin(self, *args):
        """
        SetOrigin(EDA_RECT self, wxPoint pos)
        SetOrigin(EDA_RECT self, int x, int y)
        """
        return _pcbnew.EDA_RECT_SetOrigin(self, *args)


    def SetSize(self, *args):
        """
        SetSize(EDA_RECT self, wxSize size)
        SetSize(EDA_RECT self, int w, int h)
        """
        return _pcbnew.EDA_RECT_SetSize(self, *args)


    def Offset(self, *args):
        """
        Offset(EDA_RECT self, int dx, int dy)
        Offset(EDA_RECT self, wxPoint offset)
        """
        return _pcbnew.EDA_RECT_Offset(self, *args)


    def SetX(self, val):
        """SetX(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetX(self, val)


    def SetY(self, val):
        """SetY(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetY(self, val)


    def SetWidth(self, val):
        """SetWidth(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetWidth(self, val)


    def SetHeight(self, val):
        """SetHeight(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetHeight(self, val)


    def SetEnd(self, *args):
        """
        SetEnd(EDA_RECT self, int x, int y)
        SetEnd(EDA_RECT self, wxPoint pos)
        """
        return _pcbnew.EDA_RECT_SetEnd(self, *args)


    def RevertYAxis(self):
        """RevertYAxis(EDA_RECT self)"""
        return _pcbnew.EDA_RECT_RevertYAxis(self)


    def Intersects(self, *args):
        """
        Intersects(EDA_RECT self, EDA_RECT aRect) -> bool
        Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2) -> bool
        """
        return _pcbnew.EDA_RECT_Intersects(self, *args)


    def getWxRect(self):
        """getWxRect(EDA_RECT self) -> wxRect"""
        return _pcbnew.EDA_RECT_getWxRect(self)


    def Inflate(self, *args):
        """
        Inflate(EDA_RECT self, wxCoord dx, wxCoord dy) -> EDA_RECT
        Inflate(EDA_RECT self, int aDelta) -> EDA_RECT
        """
        return _pcbnew.EDA_RECT_Inflate(self, *args)


    def Merge(self, *args):
        """
        Merge(EDA_RECT self, EDA_RECT aRect)
        Merge(EDA_RECT self, wxPoint aPoint)
        """
        return _pcbnew.EDA_RECT_Merge(self, *args)


    def GetArea(self):
        """GetArea(EDA_RECT self) -> double"""
        return _pcbnew.EDA_RECT_GetArea(self)


    def Common(self, aRect):
        """Common(EDA_RECT self, EDA_RECT aRect) -> EDA_RECT"""
        return _pcbnew.EDA_RECT_Common(self, aRect)


    def GetBoundingBoxRotated(self, aRotCenter, aAngle):
        """GetBoundingBoxRotated(EDA_RECT self, wxPoint aRotCenter, double aAngle) -> EDA_RECT"""
        return _pcbnew.EDA_RECT_GetBoundingBoxRotated(self, aRotCenter, aAngle)

    __swig_destroy__ = _pcbnew.delete_EDA_RECT
    __del__ = lambda self: None
EDA_RECT_swigregister = _pcbnew.EDA_RECT_swigregister
EDA_RECT_swigregister(EDA_RECT)


_pcbnew.GR_KB_RIGHTSHIFT_swigconstant(_pcbnew)
GR_KB_RIGHTSHIFT = _pcbnew.GR_KB_RIGHTSHIFT

_pcbnew.GR_KB_LEFTSHIFT_swigconstant(_pcbnew)
GR_KB_LEFTSHIFT = _pcbnew.GR_KB_LEFTSHIFT

_pcbnew.GR_KB_CTRL_swigconstant(_pcbnew)
GR_KB_CTRL = _pcbnew.GR_KB_CTRL

_pcbnew.GR_KB_ALT_swigconstant(_pcbnew)
GR_KB_ALT = _pcbnew.GR_KB_ALT

_pcbnew.GR_KB_SHIFT_swigconstant(_pcbnew)
GR_KB_SHIFT = _pcbnew.GR_KB_SHIFT

_pcbnew.GR_KB_SHIFTCTRL_swigconstant(_pcbnew)
GR_KB_SHIFTCTRL = _pcbnew.GR_KB_SHIFTCTRL

_pcbnew.MOUSE_MIDDLE_swigconstant(_pcbnew)
MOUSE_MIDDLE = _pcbnew.MOUSE_MIDDLE

_pcbnew.EDA_PANNING_UP_KEY_swigconstant(_pcbnew)
EDA_PANNING_UP_KEY = _pcbnew.EDA_PANNING_UP_KEY

_pcbnew.EDA_PANNING_DOWN_KEY_swigconstant(_pcbnew)
EDA_PANNING_DOWN_KEY = _pcbnew.EDA_PANNING_DOWN_KEY

_pcbnew.EDA_PANNING_LEFT_KEY_swigconstant(_pcbnew)
EDA_PANNING_LEFT_KEY = _pcbnew.EDA_PANNING_LEFT_KEY

_pcbnew.EDA_PANNING_RIGHT_KEY_swigconstant(_pcbnew)
EDA_PANNING_RIGHT_KEY = _pcbnew.EDA_PANNING_RIGHT_KEY

_pcbnew.EDA_ZOOM_IN_FROM_MOUSE_swigconstant(_pcbnew)
EDA_ZOOM_IN_FROM_MOUSE = _pcbnew.EDA_ZOOM_IN_FROM_MOUSE

_pcbnew.EDA_ZOOM_OUT_FROM_MOUSE_swigconstant(_pcbnew)
EDA_ZOOM_OUT_FROM_MOUSE = _pcbnew.EDA_ZOOM_OUT_FROM_MOUSE

_pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE_swigconstant(_pcbnew)
EDA_ZOOM_CENTER_FROM_MOUSE = _pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE

_pcbnew.ESC_swigconstant(_pcbnew)
ESC = _pcbnew.ESC

_pcbnew.TEXT_ORIENT_HORIZ_swigconstant(_pcbnew)
TEXT_ORIENT_HORIZ = _pcbnew.TEXT_ORIENT_HORIZ

_pcbnew.TEXT_ORIENT_VERT_swigconstant(_pcbnew)
TEXT_ORIENT_VERT = _pcbnew.TEXT_ORIENT_VERT

def KiROUND(v):
    """KiROUND(double v) -> int"""
    return _pcbnew.KiROUND(v)

def Mm2mils(x):
    """Mm2mils(double x) -> int"""
    return _pcbnew.Mm2mils(x)

def Mils2mm(x):
    """Mils2mm(double x) -> int"""
    return _pcbnew.Mils2mm(x)

_pcbnew.INCHES_swigconstant(_pcbnew)
INCHES = _pcbnew.INCHES

_pcbnew.MILLIMETRES_swigconstant(_pcbnew)
MILLIMETRES = _pcbnew.MILLIMETRES

_pcbnew.UNSCALED_UNITS_swigconstant(_pcbnew)
UNSCALED_UNITS = _pcbnew.UNSCALED_UNITS

_pcbnew.DEGREES_swigconstant(_pcbnew)
DEGREES = _pcbnew.DEGREES

def SetLocaleTo_C_standard():
    """SetLocaleTo_C_standard()"""
    return _pcbnew.SetLocaleTo_C_standard()

def SetLocaleTo_Default():
    """SetLocaleTo_Default()"""
    return _pcbnew.SetLocaleTo_Default()
class LOCALE_IO(_object):
    """Proxy of C++ LOCALE_IO class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LOCALE_IO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LOCALE_IO, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(LOCALE_IO self) -> LOCALE_IO"""
        this = _pcbnew.new_LOCALE_IO()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_LOCALE_IO
    __del__ = lambda self: None
LOCALE_IO_swigregister = _pcbnew.LOCALE_IO_swigregister
LOCALE_IO_swigregister(LOCALE_IO)


def GetTextSize(aSingleLine, aWindow):
    """GetTextSize(wxString const & aSingleLine, wxWindow * aWindow) -> wxSize"""
    return _pcbnew.GetTextSize(aSingleLine, aWindow)

def EnsureTextCtrlWidth(aCtrl, aString=None):
    """
    EnsureTextCtrlWidth(wxTextCtrl * aCtrl, wxString const * aString=None) -> bool
    EnsureTextCtrlWidth(wxTextCtrl * aCtrl) -> bool
    """
    return _pcbnew.EnsureTextCtrlWidth(aCtrl, aString)

def ProcessExecute(*args):
    """
    ProcessExecute(wxString const & aCommandLine, int aFlags, wxProcess * callback=None) -> int
    ProcessExecute(wxString const & aCommandLine, int aFlags) -> int
    ProcessExecute(wxString const & aCommandLine) -> int
    """
    return _pcbnew.ProcessExecute(*args)

def GetNewTimeStamp():
    """GetNewTimeStamp() -> time_t"""
    return _pcbnew.GetNewTimeStamp()

def DisplayColorFrame(parent, OldColor):
    """DisplayColorFrame(wxWindow * parent, int OldColor) -> EDA_COLOR_T"""
    return _pcbnew.DisplayColorFrame(parent, OldColor)

def ReturnUnitSymbol(*args):
    """
    ReturnUnitSymbol(EDA_UNITS_T aUnits, wxString const & aFormatString) -> wxString
    ReturnUnitSymbol(EDA_UNITS_T aUnits) -> wxString
    ReturnUnitSymbol() -> wxString
    """
    return _pcbnew.ReturnUnitSymbol(*args)

def GetUnitsLabel(aUnits):
    """GetUnitsLabel(EDA_UNITS_T aUnits) -> wxString"""
    return _pcbnew.GetUnitsLabel(aUnits)

def GetAbbreviatedUnitsLabel(*args):
    """
    GetAbbreviatedUnitsLabel(EDA_UNITS_T aUnit) -> wxString
    GetAbbreviatedUnitsLabel() -> wxString
    """
    return _pcbnew.GetAbbreviatedUnitsLabel(*args)

def AddUnitSymbol(*args):
    """
    AddUnitSymbol(wxStaticText & Stext, EDA_UNITS_T aUnit)
    AddUnitSymbol(wxStaticText & Stext)
    """
    return _pcbnew.AddUnitSymbol(*args)

def RoundTo0(x, precision):
    """RoundTo0(double x, double precision) -> double"""
    return _pcbnew.RoundTo0(x, precision)

def wxStringSplit(aText, aStrings, aSplitter):
    """wxStringSplit(wxString const & aText, wxArrayString & aStrings, wxChar aSplitter)"""
    return _pcbnew.wxStringSplit(aText, aStrings, aSplitter)

def GetRunningMicroSecs():
    """GetRunningMicroSecs() -> unsigned int"""
    return _pcbnew.GetRunningMicroSecs()

def SystemDirsAppend(aSearchStack):
    """SystemDirsAppend(SEARCH_STACK * aSearchStack)"""
    return _pcbnew.SystemDirsAppend(aSearchStack)

def SearchHelpFileFullPath(aSearchStack, aBaseName):
    """SearchHelpFileFullPath(SEARCH_STACK const & aSearchStack, wxString const & aBaseName) -> wxString"""
    return _pcbnew.SearchHelpFileFullPath(aSearchStack, aBaseName)

def EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter=None):
    """
    EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString const & aBaseFilename, REPORTER * aReporter=None) -> bool
    EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString const & aBaseFilename) -> bool
    """
    return _pcbnew.EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter)

def LockFile(aFileName):
    """LockFile(wxString const & aFileName) -> wxSingleInstanceChecker *"""
    return _pcbnew.LockFile(aFileName)

def PrePendPath(aEnvVar, aPriorityPath):
    """PrePendPath(wxString const & aEnvVar, wxString const & aPriorityPath) -> wxString const"""
    return _pcbnew.PrePendPath(aEnvVar, aPriorityPath)

def GetNewConfig(aProgName):
    """GetNewConfig(wxString const & aProgName) -> wxConfigBase *"""
    return _pcbnew.GetNewConfig(aProgName)

def GetKicadLockFilePath():
    """GetKicadLockFilePath() -> wxString"""
    return _pcbnew.GetKicadLockFilePath()

def GetKicadConfigPath():
    """GetKicadConfigPath() -> wxString"""
    return _pcbnew.GetKicadConfigPath()

def ExpandEnvVarSubstitutions(aString):
    """ExpandEnvVarSubstitutions(wxString const & aString) -> wxString const"""
    return _pcbnew.ExpandEnvVarSubstitutions(aString)
class TITLE_BLOCK(_object):
    """Proxy of C++ TITLE_BLOCK class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TITLE_BLOCK, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TITLE_BLOCK, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(TITLE_BLOCK self) -> TITLE_BLOCK"""
        this = _pcbnew.new_TITLE_BLOCK()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_TITLE_BLOCK
    __del__ = lambda self: None

    def SetTitle(self, aTitle):
        """SetTitle(TITLE_BLOCK self, wxString const & aTitle)"""
        return _pcbnew.TITLE_BLOCK_SetTitle(self, aTitle)


    def GetTitle(self):
        """GetTitle(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetTitle(self)


    def SetDate(self, aDate):
        """SetDate(TITLE_BLOCK self, wxString const & aDate)"""
        return _pcbnew.TITLE_BLOCK_SetDate(self, aDate)


    def GetDate(self):
        """GetDate(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetDate(self)


    def SetRevision(self, aRevision):
        """SetRevision(TITLE_BLOCK self, wxString const & aRevision)"""
        return _pcbnew.TITLE_BLOCK_SetRevision(self, aRevision)


    def GetRevision(self):
        """GetRevision(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetRevision(self)


    def SetCompany(self, aCompany):
        """SetCompany(TITLE_BLOCK self, wxString const & aCompany)"""
        return _pcbnew.TITLE_BLOCK_SetCompany(self, aCompany)


    def GetCompany(self):
        """GetCompany(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetCompany(self)


    def SetComment(self, aIdx, aComment):
        """SetComment(TITLE_BLOCK self, int aIdx, wxString const & aComment)"""
        return _pcbnew.TITLE_BLOCK_SetComment(self, aIdx, aComment)


    def GetComment(self, aIdx):
        """GetComment(TITLE_BLOCK self, int aIdx) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetComment(self, aIdx)


    def SetComment1(self, aComment):
        """SetComment1(TITLE_BLOCK self, wxString const & aComment)"""
        return _pcbnew.TITLE_BLOCK_SetComment1(self, aComment)


    def SetComment2(self, aComment):
        """SetComment2(TITLE_BLOCK self, wxString const & aComment)"""
        return _pcbnew.TITLE_BLOCK_SetComment2(self, aComment)


    def SetComment3(self, aComment):
        """SetComment3(TITLE_BLOCK self, wxString const & aComment)"""
        return _pcbnew.TITLE_BLOCK_SetComment3(self, aComment)


    def SetComment4(self, aComment):
        """SetComment4(TITLE_BLOCK self, wxString const & aComment)"""
        return _pcbnew.TITLE_BLOCK_SetComment4(self, aComment)


    def GetComment1(self):
        """GetComment1(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetComment1(self)


    def GetComment2(self):
        """GetComment2(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetComment2(self)


    def GetComment3(self):
        """GetComment3(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetComment3(self)


    def GetComment4(self):
        """GetComment4(TITLE_BLOCK self) -> wxString const &"""
        return _pcbnew.TITLE_BLOCK_GetComment4(self)


    def Clear(self):
        """Clear(TITLE_BLOCK self)"""
        return _pcbnew.TITLE_BLOCK_Clear(self)


    def Format(self, aFormatter, aNestLevel, aControlBits):
        """Format(TITLE_BLOCK self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)"""
        return _pcbnew.TITLE_BLOCK_Format(self, aFormatter, aNestLevel, aControlBits)

TITLE_BLOCK_swigregister = _pcbnew.TITLE_BLOCK_swigregister
TITLE_BLOCK_swigregister(TITLE_BLOCK)

class COLORS_DESIGN_SETTINGS(_object):
    """Proxy of C++ COLORS_DESIGN_SETTINGS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, COLORS_DESIGN_SETTINGS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, COLORS_DESIGN_SETTINGS, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set
    __swig_getmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get
    if _newclass:
        m_LayersColors = _swig_property(_pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get, _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set)
    __swig_setmethods__["m_ItemsColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_ItemsColors_set
    __swig_getmethods__["m_ItemsColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_ItemsColors_get
    if _newclass:
        m_ItemsColors = _swig_property(_pcbnew.COLORS_DESIGN_SETTINGS_m_ItemsColors_get, _pcbnew.COLORS_DESIGN_SETTINGS_m_ItemsColors_set)

    def __init__(self):
        """__init__(COLORS_DESIGN_SETTINGS self) -> COLORS_DESIGN_SETTINGS"""
        this = _pcbnew.new_COLORS_DESIGN_SETTINGS()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetLayerColor(self, aLayer):
        """GetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer) -> EDA_COLOR_T"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_GetLayerColor(self, aLayer)


    def SetLayerColor(self, aLayer, aColor):
        """SetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer, EDA_COLOR_T aColor)"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_SetLayerColor(self, aLayer, aColor)


    def GetItemColor(self, aItemIdx):
        """GetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx) -> EDA_COLOR_T"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_GetItemColor(self, aItemIdx)


    def SetItemColor(self, aItemIdx, aColor):
        """SetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx, EDA_COLOR_T aColor)"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_SetItemColor(self, aItemIdx, aColor)


    def SetAllColorsAs(self, aColor):
        """SetAllColorsAs(COLORS_DESIGN_SETTINGS self, EDA_COLOR_T aColor)"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_SetAllColorsAs(self, aColor)

    __swig_destroy__ = _pcbnew.delete_COLORS_DESIGN_SETTINGS
    __del__ = lambda self: None
COLORS_DESIGN_SETTINGS_swigregister = _pcbnew.COLORS_DESIGN_SETTINGS_swigregister
COLORS_DESIGN_SETTINGS_swigregister(COLORS_DESIGN_SETTINGS)

class MARKER_BASE(_object):
    """Proxy of C++ MARKER_BASE class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MARKER_BASE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MARKER_BASE, name)
    __repr__ = _swig_repr
    MARKER_UNSPEC = _pcbnew.MARKER_BASE_MARKER_UNSPEC
    MARKER_ERC = _pcbnew.MARKER_BASE_MARKER_ERC
    MARKER_PCB = _pcbnew.MARKER_BASE_MARKER_PCB
    MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
    MARKER_SEVERITY_UNSPEC = _pcbnew.MARKER_BASE_MARKER_SEVERITY_UNSPEC
    MARKER_SEVERITY_INFO = _pcbnew.MARKER_BASE_MARKER_SEVERITY_INFO
    MARKER_SEVERITY_WARNING = _pcbnew.MARKER_BASE_MARKER_SEVERITY_WARNING
    MARKER_SEVERITY_ERROR = _pcbnew.MARKER_BASE_MARKER_SEVERITY_ERROR
    __swig_setmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_set
    __swig_getmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_get
    if _newclass:
        m_Pos = _swig_property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set)

    def __init__(self, *args):
        """
        __init__(MARKER_BASE self) -> MARKER_BASE
        __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString const & aText, wxPoint aPos, wxString const & bText, wxPoint bPos) -> MARKER_BASE
        __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString const & aText, wxPoint aPos) -> MARKER_BASE
        __init__(MARKER_BASE self, MARKER_BASE aMarker) -> MARKER_BASE
        """
        this = _pcbnew.new_MARKER_BASE(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MARKER_BASE
    __del__ = lambda self: None

    def DrawMarker(self, aPanel, aDC, aDrawMode, aOffset):
        """DrawMarker(MARKER_BASE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)"""
        return _pcbnew.MARKER_BASE_DrawMarker(self, aPanel, aDC, aDrawMode, aOffset)


    def GetPos(self):
        """GetPos(MARKER_BASE self) -> wxPoint"""
        return _pcbnew.MARKER_BASE_GetPos(self)


    def SetColor(self, aColor):
        """SetColor(MARKER_BASE self, EDA_COLOR_T aColor)"""
        return _pcbnew.MARKER_BASE_SetColor(self, aColor)


    def SetErrorLevel(self, aErrorLevel):
        """SetErrorLevel(MARKER_BASE self, MARKER_BASE::MARKER_SEVERITY aErrorLevel)"""
        return _pcbnew.MARKER_BASE_SetErrorLevel(self, aErrorLevel)


    def GetErrorLevel(self):
        """GetErrorLevel(MARKER_BASE self) -> MARKER_BASE::MARKER_SEVERITY"""
        return _pcbnew.MARKER_BASE_GetErrorLevel(self)


    def SetMarkerType(self, aMarkerType):
        """SetMarkerType(MARKER_BASE self, enum MARKER_BASE::TYPEMARKER aMarkerType)"""
        return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)


    def GetMarkerType(self):
        """GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::TYPEMARKER"""
        return _pcbnew.MARKER_BASE_GetMarkerType(self)


    def SetData(self, *args):
        """
        SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString const & aText, wxPoint aPos, wxString const & bText, wxPoint bPos)
        SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString const & aText, wxPoint aPos)
        """
        return _pcbnew.MARKER_BASE_SetData(self, *args)


    def SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos):
        """SetAuxiliaryData(MARKER_BASE self, wxString const & aAuxiliaryText, wxPoint aAuxiliaryPos)"""
        return _pcbnew.MARKER_BASE_SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos)


    def SetShowNoCoordinate(self):
        """SetShowNoCoordinate(MARKER_BASE self)"""
        return _pcbnew.MARKER_BASE_SetShowNoCoordinate(self)


    def GetReporter(self):
        """GetReporter(MARKER_BASE self) -> DRC_ITEM const &"""
        return _pcbnew.MARKER_BASE_GetReporter(self)


    def DisplayMarkerInfo(self, aFrame):
        """DisplayMarkerInfo(MARKER_BASE self, EDA_DRAW_FRAME * aFrame)"""
        return _pcbnew.MARKER_BASE_DisplayMarkerInfo(self, aFrame)


    def HitTestMarker(self, ref_pos):
        """HitTestMarker(MARKER_BASE self, wxPoint ref_pos) -> bool"""
        return _pcbnew.MARKER_BASE_HitTestMarker(self, ref_pos)


    def GetBoundingBoxMarker(self):
        """GetBoundingBoxMarker(MARKER_BASE self) -> EDA_RECT"""
        return _pcbnew.MARKER_BASE_GetBoundingBoxMarker(self)

MARKER_BASE_swigregister = _pcbnew.MARKER_BASE_swigregister
MARKER_BASE_swigregister(MARKER_BASE)


_pcbnew.GR_TEXT_HJUSTIFY_LEFT_swigconstant(_pcbnew)
GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT

_pcbnew.GR_TEXT_HJUSTIFY_CENTER_swigconstant(_pcbnew)
GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER

_pcbnew.GR_TEXT_HJUSTIFY_RIGHT_swigconstant(_pcbnew)
GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT

_pcbnew.GR_TEXT_VJUSTIFY_TOP_swigconstant(_pcbnew)
GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP

_pcbnew.GR_TEXT_VJUSTIFY_CENTER_swigconstant(_pcbnew)
GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER

_pcbnew.GR_TEXT_VJUSTIFY_BOTTOM_swigconstant(_pcbnew)
GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM

_pcbnew.FILLED_swigconstant(_pcbnew)
FILLED = _pcbnew.FILLED

_pcbnew.SKETCH_swigconstant(_pcbnew)
SKETCH = _pcbnew.SKETCH

_pcbnew.DEFAULT_SIZE_TEXT_swigconstant(_pcbnew)
DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT

_pcbnew.TEXT_NO_VISIBLE_swigconstant(_pcbnew)
TEXT_NO_VISIBLE = _pcbnew.TEXT_NO_VISIBLE

_pcbnew.DIM_ANCRE_TEXTE_swigconstant(_pcbnew)
DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE
class EDA_TEXT(_object):
    """Proxy of C++ EDA_TEXT class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_TEXT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EDA_TEXT, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(EDA_TEXT self, wxString const & text) -> EDA_TEXT
        __init__(EDA_TEXT self) -> EDA_TEXT
        __init__(EDA_TEXT self, EDA_TEXT aText) -> EDA_TEXT
        """
        this = _pcbnew.new_EDA_TEXT(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_EDA_TEXT
    __del__ = lambda self: None

    def GetText(self):
        """GetText(EDA_TEXT self) -> wxString const &"""
        return _pcbnew.EDA_TEXT_GetText(self)


    def GetShownText(self):
        """GetShownText(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetShownText(self)


    def ShortenedShownText(self):
        """ShortenedShownText(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_ShortenedShownText(self)


    def SetText(self, aText):
        """SetText(EDA_TEXT self, wxString const & aText)"""
        return _pcbnew.EDA_TEXT_SetText(self, aText)


    def SetThickness(self, aNewThickness):
        """SetThickness(EDA_TEXT self, int aNewThickness)"""
        return _pcbnew.EDA_TEXT_SetThickness(self, aNewThickness)


    def GetThickness(self):
        """GetThickness(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetThickness(self)


    def SetOrientation(self, aOrientation):
        """SetOrientation(EDA_TEXT self, double aOrientation)"""
        return _pcbnew.EDA_TEXT_SetOrientation(self, aOrientation)


    def GetOrientation(self):
        """GetOrientation(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetOrientation(self)


    def SetItalic(self, isItalic):
        """SetItalic(EDA_TEXT self, bool isItalic)"""
        return _pcbnew.EDA_TEXT_SetItalic(self, isItalic)


    def IsItalic(self):
        """IsItalic(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsItalic(self)


    def SetBold(self, aBold):
        """SetBold(EDA_TEXT self, bool aBold)"""
        return _pcbnew.EDA_TEXT_SetBold(self, aBold)


    def IsBold(self):
        """IsBold(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsBold(self)


    def SetVisible(self, aVisible):
        """SetVisible(EDA_TEXT self, bool aVisible)"""
        return _pcbnew.EDA_TEXT_SetVisible(self, aVisible)


    def IsVisible(self):
        """IsVisible(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsVisible(self)


    def SetMirrored(self, isMirrored):
        """SetMirrored(EDA_TEXT self, bool isMirrored)"""
        return _pcbnew.EDA_TEXT_SetMirrored(self, isMirrored)


    def IsMirrored(self):
        """IsMirrored(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsMirrored(self)


    def SetAttributes(self, aAttributes):
        """SetAttributes(EDA_TEXT self, int aAttributes)"""
        return _pcbnew.EDA_TEXT_SetAttributes(self, aAttributes)


    def GetAttributes(self):
        """GetAttributes(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetAttributes(self)


    def IsDefaultFormatting(self):
        """IsDefaultFormatting(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)


    def SetSize(self, aNewSize):
        """SetSize(EDA_TEXT self, wxSize aNewSize)"""
        return _pcbnew.EDA_TEXT_SetSize(self, aNewSize)


    def GetSize(self):
        """GetSize(EDA_TEXT self) -> wxSize"""
        return _pcbnew.EDA_TEXT_GetSize(self)


    def SetWidth(self, aWidth):
        """SetWidth(EDA_TEXT self, int aWidth)"""
        return _pcbnew.EDA_TEXT_SetWidth(self, aWidth)


    def GetWidth(self):
        """GetWidth(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetWidth(self)


    def SetHeight(self, aHeight):
        """SetHeight(EDA_TEXT self, int aHeight)"""
        return _pcbnew.EDA_TEXT_SetHeight(self, aHeight)


    def GetHeight(self):
        """GetHeight(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetHeight(self)


    def SetTextPosition(self, aPoint):
        """SetTextPosition(EDA_TEXT self, wxPoint aPoint)"""
        return _pcbnew.EDA_TEXT_SetTextPosition(self, aPoint)


    def GetTextPosition(self):
        """GetTextPosition(EDA_TEXT self) -> wxPoint"""
        return _pcbnew.EDA_TEXT_GetTextPosition(self)


    def SetMultilineAllowed(self, aAllow):
        """SetMultilineAllowed(EDA_TEXT self, bool aAllow)"""
        return _pcbnew.EDA_TEXT_SetMultilineAllowed(self, aAllow)


    def IsMultilineAllowed(self):
        """IsMultilineAllowed(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsMultilineAllowed(self)


    def Offset(self, aOffset):
        """Offset(EDA_TEXT self, wxPoint aOffset)"""
        return _pcbnew.EDA_TEXT_Offset(self, aOffset)


    def Empty(self):
        """Empty(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_Empty(self)


    def Draw(self, *args):
        """
        Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED, EDA_COLOR_T aAnchor_color)
        Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED)
        Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.EDA_TEXT_Draw(self, *args)


    def TransformTextShapeToSegmentList(self, aCornerBuffer):
        """TransformTextShapeToSegmentList(EDA_TEXT self, wxPoint_Vector aCornerBuffer)"""
        return _pcbnew.EDA_TEXT_TransformTextShapeToSegmentList(self, aCornerBuffer)


    def TextHitTest(self, *args):
        """
        TextHitTest(EDA_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
        TextHitTest(EDA_TEXT self, wxPoint aPoint) -> bool
        TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False, int aAccuracy=0) -> bool
        TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False) -> bool
        TextHitTest(EDA_TEXT self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.EDA_TEXT_TextHitTest(self, *args)


    def LenSize(self, aLine):
        """LenSize(EDA_TEXT self, wxString const & aLine) -> int"""
        return _pcbnew.EDA_TEXT_LenSize(self, aLine)


    def GetTextBox(self, aLine=-1, aThickness=-1, aInvertY=False):
        """
        GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1, bool aInvertY=False) -> EDA_RECT
        GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1) -> EDA_RECT
        GetTextBox(EDA_TEXT self, int aLine=-1) -> EDA_RECT
        GetTextBox(EDA_TEXT self) -> EDA_RECT
        """
        return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aThickness, aInvertY)


    def GetInterline(self, aTextThickness=-1):
        """
        GetInterline(EDA_TEXT self, int aTextThickness=-1) -> int
        GetInterline(EDA_TEXT self) -> int
        """
        return _pcbnew.EDA_TEXT_GetInterline(self, aTextThickness)


    def GetTextStyleName(self):
        """GetTextStyleName(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetTextStyleName(self)


    def GetHorizJustify(self):
        """GetHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_GetHorizJustify(self)


    def GetVertJustify(self):
        """GetVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_GetVertJustify(self)


    def SetHorizJustify(self, aType):
        """SetHorizJustify(EDA_TEXT self, EDA_TEXT_HJUSTIFY_T aType)"""
        return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)


    def SetVertJustify(self, aType):
        """SetVertJustify(EDA_TEXT self, EDA_TEXT_VJUSTIFY_T aType)"""
        return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)


    def GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount):
        """GetPositionsOfLinesOfMultilineText(EDA_TEXT self, wxPoint_Vector aPositions, int aLineCount)"""
        return _pcbnew.EDA_TEXT_GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount)


    def Format(self, aFormatter, aNestLevel, aControlBits):
        """Format(EDA_TEXT self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)"""
        return _pcbnew.EDA_TEXT_Format(self, aFormatter, aNestLevel, aControlBits)

EDA_TEXT_swigregister = _pcbnew.EDA_TEXT_swigregister
EDA_TEXT_swigregister(EDA_TEXT)


_pcbnew.MM_PER_IU_swigconstant(_pcbnew)
MM_PER_IU = _pcbnew.MM_PER_IU

_pcbnew.MILS_PER_IU_swigconstant(_pcbnew)
MILS_PER_IU = _pcbnew.MILS_PER_IU

_pcbnew.DECIMILS_PER_IU_swigconstant(_pcbnew)
DECIMILS_PER_IU = _pcbnew.DECIMILS_PER_IU

def Iu2Mils(iu):
    """Iu2Mils(int iu) -> int"""
    return _pcbnew.Iu2Mils(iu)

def Iu2DMils(iu):
    """Iu2DMils(int iu) -> int"""
    return _pcbnew.Iu2DMils(iu)

_pcbnew.IU_PER_MM_swigconstant(_pcbnew)
IU_PER_MM = _pcbnew.IU_PER_MM

_pcbnew.IU_PER_MILS_swigconstant(_pcbnew)
IU_PER_MILS = _pcbnew.IU_PER_MILS

_pcbnew.IU_PER_DECIMILS_swigconstant(_pcbnew)
IU_PER_DECIMILS = _pcbnew.IU_PER_DECIMILS

def Mils2iu(mils):
    """Mils2iu(int mils) -> int"""
    return _pcbnew.Mils2iu(mils)

def DMils2iu(dmils):
    """DMils2iu(int dmils) -> int"""
    return _pcbnew.DMils2iu(dmils)

def Millimeter2iu(mm):
    """Millimeter2iu(double mm) -> int"""
    return _pcbnew.Millimeter2iu(mm)
class FPID(_object):
    """Proxy of C++ FPID class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FPID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FPID, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FPID self) -> FPID
        __init__(FPID self, string aId) -> FPID
        __init__(FPID self, wxString const & aId) -> FPID
        """
        this = _pcbnew.new_FPID(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Parse(self, aId):
        """Parse(FPID self, UTF8 aId) -> int"""
        return _pcbnew.FPID_Parse(self, aId)


    def GetLibNickname(self):
        """GetLibNickname(FPID self) -> UTF8"""
        return _pcbnew.FPID_GetLibNickname(self)


    def SetLibNickname(self, aNickname):
        """SetLibNickname(FPID self, UTF8 aNickname) -> int"""
        return _pcbnew.FPID_SetLibNickname(self, aNickname)


    def GetFootprintName(self):
        """GetFootprintName(FPID self) -> UTF8"""
        return _pcbnew.FPID_GetFootprintName(self)


    def SetFootprintName(self, aFootprintName):
        """SetFootprintName(FPID self, UTF8 aFootprintName) -> int"""
        return _pcbnew.FPID_SetFootprintName(self, aFootprintName)


    def SetRevision(self, aRevision):
        """SetRevision(FPID self, UTF8 aRevision) -> int"""
        return _pcbnew.FPID_SetRevision(self, aRevision)


    def GetRevision(self):
        """GetRevision(FPID self) -> UTF8"""
        return _pcbnew.FPID_GetRevision(self)


    def GetFootprintNameAndRev(self):
        """GetFootprintNameAndRev(FPID self) -> UTF8"""
        return _pcbnew.FPID_GetFootprintNameAndRev(self)


    def Format(self):
        """Format(FPID self) -> UTF8"""
        return _pcbnew.FPID_Format(self)


    def IsValid(self):
        """IsValid(FPID self) -> bool"""
        return _pcbnew.FPID_IsValid(self)


    def IsLegacy(self):
        """IsLegacy(FPID self) -> bool"""
        return _pcbnew.FPID_IsLegacy(self)


    def clear(self):
        """clear(FPID self)"""
        return _pcbnew.FPID_clear(self)


    def empty(self):
        """empty(FPID self) -> bool"""
        return _pcbnew.FPID_empty(self)


    def compare(self, aFPID):
        """compare(FPID self, FPID aFPID) -> int"""
        return _pcbnew.FPID_compare(self, aFPID)


    def __lt__(self, aFPID):
        """__lt__(FPID self, FPID aFPID) -> bool"""
        return _pcbnew.FPID___lt__(self, aFPID)


    def __gt__(self, aFPID):
        """__gt__(FPID self, FPID aFPID) -> bool"""
        return _pcbnew.FPID___gt__(self, aFPID)


    def __eq__(self, aFPID):
        """__eq__(FPID self, FPID aFPID) -> bool"""
        return _pcbnew.FPID___eq__(self, aFPID)


    def __ne__(self, aFPID):
        """__ne__(FPID self, FPID aFPID) -> bool"""
        return _pcbnew.FPID___ne__(self, aFPID)

    __swig_destroy__ = _pcbnew.delete_FPID
    __del__ = lambda self: None
FPID_swigregister = _pcbnew.FPID_swigregister
FPID_swigregister(FPID)

class intVector(_object):
    """Proxy of C++ std::vector<(int)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(intVector self) -> SwigPyIterator"""
        return _pcbnew.intVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(intVector self) -> bool"""
        return _pcbnew.intVector___nonzero__(self)


    def __bool__(self):
        """__bool__(intVector self) -> bool"""
        return _pcbnew.intVector___bool__(self)


    def __len__(self):
        """__len__(intVector self) -> std::vector< int >::size_type"""
        return _pcbnew.intVector___len__(self)


    def pop(self):
        """pop(intVector self) -> std::vector< int >::value_type"""
        return _pcbnew.intVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> intVector"""
        return _pcbnew.intVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, intVector v)
        __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        """
        return _pcbnew.intVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _pcbnew.intVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(intVector self, std::vector< int >::difference_type i)
        __delitem__(intVector self, PySliceObject * slice)
        """
        return _pcbnew.intVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(intVector self, PySliceObject * slice) -> intVector
        __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _pcbnew.intVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(intVector self, PySliceObject * slice, intVector v)
        __setitem__(intVector self, PySliceObject * slice)
        __setitem__(intVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _pcbnew.intVector___setitem__(self, *args)


    def append(self, x):
        """append(intVector self, std::vector< int >::value_type const & x)"""
        return _pcbnew.intVector_append(self, x)


    def empty(self):
        """empty(intVector self) -> bool"""
        return _pcbnew.intVector_empty(self)


    def size(self):
        """size(intVector self) -> std::vector< int >::size_type"""
        return _pcbnew.intVector_size(self)


    def clear(self):
        """clear(intVector self)"""
        return _pcbnew.intVector_clear(self)


    def swap(self, v):
        """swap(intVector self, intVector v)"""
        return _pcbnew.intVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(intVector self) -> std::vector< int >::allocator_type"""
        return _pcbnew.intVector_get_allocator(self)


    def begin(self):
        """begin(intVector self) -> std::vector< int >::iterator"""
        return _pcbnew.intVector_begin(self)


    def end(self):
        """end(intVector self) -> std::vector< int >::iterator"""
        return _pcbnew.intVector_end(self)


    def rbegin(self):
        """rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
        return _pcbnew.intVector_rbegin(self)


    def rend(self):
        """rend(intVector self) -> std::vector< int >::reverse_iterator"""
        return _pcbnew.intVector_rend(self)


    def pop_back(self):
        """pop_back(intVector self)"""
        return _pcbnew.intVector_pop_back(self)


    def erase(self, *args):
        """
        erase(intVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(intVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _pcbnew.intVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int)> self) -> intVector
        __init__(std::vector<(int)> self, intVector arg2) -> intVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> intVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
        """
        this = _pcbnew.new_intVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(intVector self, std::vector< int >::value_type const & x)"""
        return _pcbnew.intVector_push_back(self, x)


    def front(self):
        """front(intVector self) -> std::vector< int >::value_type const &"""
        return _pcbnew.intVector_front(self)


    def back(self):
        """back(intVector self) -> std::vector< int >::value_type const &"""
        return _pcbnew.intVector_back(self)


    def assign(self, n, x):
        """assign(intVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _pcbnew.intVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(intVector self, std::vector< int >::size_type new_size)
        resize(intVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _pcbnew.intVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _pcbnew.intVector_insert(self, *args)


    def reserve(self, n):
        """reserve(intVector self, std::vector< int >::size_type n)"""
        return _pcbnew.intVector_reserve(self, n)


    def capacity(self):
        """capacity(intVector self) -> std::vector< int >::size_type"""
        return _pcbnew.intVector_capacity(self)

    __swig_destroy__ = _pcbnew.delete_intVector
    __del__ = lambda self: None
intVector_swigregister = _pcbnew.intVector_swigregister
intVector_swigregister(intVector)

class str_utf8_Map(_object):
    """Proxy of C++ std::map<(std::string,UTF8)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, str_utf8_Map, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, str_utf8_Map, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(str_utf8_Map self) -> SwigPyIterator"""
        return _pcbnew.str_utf8_Map_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(str_utf8_Map self) -> bool"""
        return _pcbnew.str_utf8_Map___nonzero__(self)


    def __bool__(self):
        """__bool__(str_utf8_Map self) -> bool"""
        return _pcbnew.str_utf8_Map___bool__(self)


    def __len__(self):
        """__len__(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
        return _pcbnew.str_utf8_Map___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, key):
        """__getitem__(str_utf8_Map self, string key) -> UTF8"""
        return _pcbnew.str_utf8_Map___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(str_utf8_Map self, string key)"""
        return _pcbnew.str_utf8_Map___delitem__(self, key)


    def has_key(self, key):
        """has_key(str_utf8_Map self, string key) -> bool"""
        return _pcbnew.str_utf8_Map_has_key(self, key)


    def keys(self):
        """keys(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_keys(self)


    def values(self):
        """values(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_values(self)


    def items(self):
        """items(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_items(self)


    def __contains__(self, key):
        """__contains__(str_utf8_Map self, string key) -> bool"""
        return _pcbnew.str_utf8_Map___contains__(self, key)


    def key_iterator(self):
        """key_iterator(str_utf8_Map self) -> SwigPyIterator"""
        return _pcbnew.str_utf8_Map_key_iterator(self)


    def value_iterator(self):
        """value_iterator(str_utf8_Map self) -> SwigPyIterator"""
        return _pcbnew.str_utf8_Map_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(str_utf8_Map self, string key)
        __setitem__(str_utf8_Map self, string key, UTF8 x)
        """
        return _pcbnew.str_utf8_Map___setitem__(self, *args)


    def asdict(self):
        """asdict(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,UTF8)> self, std::less< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > const & arg2) -> str_utf8_Map
        __init__(std::map<(std::string,UTF8)> self) -> str_utf8_Map
        __init__(std::map<(std::string,UTF8)> self, str_utf8_Map arg2) -> str_utf8_Map
        """
        this = _pcbnew.new_str_utf8_Map(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        """empty(str_utf8_Map self) -> bool"""
        return _pcbnew.str_utf8_Map_empty(self)


    def size(self):
        """size(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
        return _pcbnew.str_utf8_Map_size(self)


    def clear(self):
        """clear(str_utf8_Map self)"""
        return _pcbnew.str_utf8_Map_clear(self)


    def swap(self, v):
        """swap(str_utf8_Map self, str_utf8_Map v)"""
        return _pcbnew.str_utf8_Map_swap(self, v)


    def get_allocator(self):
        """get_allocator(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type"""
        return _pcbnew.str_utf8_Map_get_allocator(self)


    def begin(self):
        """begin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_begin(self)


    def end(self):
        """end(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_end(self)


    def rbegin(self):
        """rbegin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
        return _pcbnew.str_utf8_Map_rbegin(self)


    def rend(self):
        """rend(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
        return _pcbnew.str_utf8_Map_rend(self)


    def count(self, x):
        """count(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
        return _pcbnew.str_utf8_Map_count(self, x)


    def erase(self, *args):
        """
        erase(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type
        erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator position)
        erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator first, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator last)
        """
        return _pcbnew.str_utf8_Map_erase(self, *args)


    def find(self, x):
        """find(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_find(self, x)


    def lower_bound(self, x):
        """lower_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_upper_bound(self, x)

    __swig_destroy__ = _pcbnew.delete_str_utf8_Map
    __del__ = lambda self: None
str_utf8_Map_swigregister = _pcbnew.str_utf8_Map_swigregister
str_utf8_Map_swigregister(str_utf8_Map)

class base_seqVect(_object):
    """Proxy of C++ std::vector<(enum LAYER_ID)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, base_seqVect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, base_seqVect, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(base_seqVect self) -> SwigPyIterator"""
        return _pcbnew.base_seqVect_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(base_seqVect self) -> bool"""
        return _pcbnew.base_seqVect___nonzero__(self)


    def __bool__(self):
        """__bool__(base_seqVect self) -> bool"""
        return _pcbnew.base_seqVect___bool__(self)


    def __len__(self):
        """__len__(base_seqVect self) -> std::vector< enum LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect___len__(self)


    def pop(self):
        """pop(base_seqVect self) -> std::vector< enum LAYER_ID >::value_type"""
        return _pcbnew.base_seqVect_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i, std::vector< enum LAYER_ID >::difference_type j) -> base_seqVect"""
        return _pcbnew.base_seqVect___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i, std::vector< enum LAYER_ID >::difference_type j, base_seqVect v)
        __setslice__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i, std::vector< enum LAYER_ID >::difference_type j)
        """
        return _pcbnew.base_seqVect___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i, std::vector< enum LAYER_ID >::difference_type j)"""
        return _pcbnew.base_seqVect___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i)
        __delitem__(base_seqVect self, PySliceObject * slice)
        """
        return _pcbnew.base_seqVect___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(base_seqVect self, PySliceObject * slice) -> base_seqVect
        __getitem__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i) -> std::vector< enum LAYER_ID >::value_type const &
        """
        return _pcbnew.base_seqVect___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(base_seqVect self, PySliceObject * slice, base_seqVect v)
        __setitem__(base_seqVect self, PySliceObject * slice)
        __setitem__(base_seqVect self, std::vector< enum LAYER_ID >::difference_type i, std::vector< enum LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect___setitem__(self, *args)


    def append(self, x):
        """append(base_seqVect self, std::vector< enum LAYER_ID >::value_type const & x)"""
        return _pcbnew.base_seqVect_append(self, x)


    def empty(self):
        """empty(base_seqVect self) -> bool"""
        return _pcbnew.base_seqVect_empty(self)


    def size(self):
        """size(base_seqVect self) -> std::vector< enum LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect_size(self)


    def clear(self):
        """clear(base_seqVect self)"""
        return _pcbnew.base_seqVect_clear(self)


    def swap(self, v):
        """swap(base_seqVect self, base_seqVect v)"""
        return _pcbnew.base_seqVect_swap(self, v)


    def get_allocator(self):
        """get_allocator(base_seqVect self) -> std::vector< enum LAYER_ID >::allocator_type"""
        return _pcbnew.base_seqVect_get_allocator(self)


    def begin(self):
        """begin(base_seqVect self) -> std::vector< enum LAYER_ID >::iterator"""
        return _pcbnew.base_seqVect_begin(self)


    def end(self):
        """end(base_seqVect self) -> std::vector< enum LAYER_ID >::iterator"""
        return _pcbnew.base_seqVect_end(self)


    def rbegin(self):
        """rbegin(base_seqVect self) -> std::vector< enum LAYER_ID >::reverse_iterator"""
        return _pcbnew.base_seqVect_rbegin(self)


    def rend(self):
        """rend(base_seqVect self) -> std::vector< enum LAYER_ID >::reverse_iterator"""
        return _pcbnew.base_seqVect_rend(self)


    def pop_back(self):
        """pop_back(base_seqVect self)"""
        return _pcbnew.base_seqVect_pop_back(self)


    def erase(self, *args):
        """
        erase(base_seqVect self, std::vector< enum LAYER_ID >::iterator pos) -> std::vector< enum LAYER_ID >::iterator
        erase(base_seqVect self, std::vector< enum LAYER_ID >::iterator first, std::vector< enum LAYER_ID >::iterator last) -> std::vector< enum LAYER_ID >::iterator
        """
        return _pcbnew.base_seqVect_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(enum LAYER_ID)> self) -> base_seqVect
        __init__(std::vector<(enum LAYER_ID)> self, base_seqVect arg2) -> base_seqVect
        __init__(std::vector<(enum LAYER_ID)> self, std::vector< enum LAYER_ID >::size_type size) -> base_seqVect
        __init__(std::vector<(enum LAYER_ID)> self, std::vector< enum LAYER_ID >::size_type size, std::vector< enum LAYER_ID >::value_type const & value) -> base_seqVect
        """
        this = _pcbnew.new_base_seqVect(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(base_seqVect self, std::vector< enum LAYER_ID >::value_type const & x)"""
        return _pcbnew.base_seqVect_push_back(self, x)


    def front(self):
        """front(base_seqVect self) -> std::vector< enum LAYER_ID >::value_type const &"""
        return _pcbnew.base_seqVect_front(self)


    def back(self):
        """back(base_seqVect self) -> std::vector< enum LAYER_ID >::value_type const &"""
        return _pcbnew.base_seqVect_back(self)


    def assign(self, n, x):
        """assign(base_seqVect self, std::vector< enum LAYER_ID >::size_type n, std::vector< enum LAYER_ID >::value_type const & x)"""
        return _pcbnew.base_seqVect_assign(self, n, x)


    def resize(self, *args):
        """
        resize(base_seqVect self, std::vector< enum LAYER_ID >::size_type new_size)
        resize(base_seqVect self, std::vector< enum LAYER_ID >::size_type new_size, std::vector< enum LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect_resize(self, *args)


    def insert(self, *args):
        """
        insert(base_seqVect self, std::vector< enum LAYER_ID >::iterator pos, std::vector< enum LAYER_ID >::value_type const & x) -> std::vector< enum LAYER_ID >::iterator
        insert(base_seqVect self, std::vector< enum LAYER_ID >::iterator pos, std::vector< enum LAYER_ID >::size_type n, std::vector< enum LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect_insert(self, *args)


    def reserve(self, n):
        """reserve(base_seqVect self, std::vector< enum LAYER_ID >::size_type n)"""
        return _pcbnew.base_seqVect_reserve(self, n)


    def capacity(self):
        """capacity(base_seqVect self) -> std::vector< enum LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect_capacity(self)

    __swig_destroy__ = _pcbnew.delete_base_seqVect
    __del__ = lambda self: None
base_seqVect_swigregister = _pcbnew.base_seqVect_swigregister
base_seqVect_swigregister(base_seqVect)



KICAD_PLUGINS={}

def ReloadPlugin(name):
    if not KICAD_PLUGINS.has_key(name):
        return False

    KICAD_PLUGINS[name]["object"].deregister()
    mod = reload(KICAD_PLUGINS[name]["module"])
    KICAD_PLUGINS[name]["object"]= mod.register()


def ReloadPlugins():
    import os.path
    for k in KICAD_PLUGINS.keys():
        plugin = KICAD_PLUGINS[k]

        filename = plugin["filename"]
        mtime = plugin["modification_time"]
        now_mtime = os.path.getmtime(filename)

        if mtime!=now_mtime:
            print filename, " is modified, reloading"
            KICAD_PLUGINS[k]["modification_time"]=now_mtime
            ReloadPlugin(k)


def LoadPlugins( plugpath ):
    import os
    import sys

    kicad_path = os.environ.get('KICAD_PATH')
    plugin_directories=[]

    if plugpath and os.path.isdir( plugpath ):
        plugin_directories.append( plugpath )

    if kicad_path and os.path.isdir(kicad_path):
        plugin_directories.append(os.path.join(kicad_path, 'scripting', 'plugins'))

    if sys.platform.startswith('linux'):
        plugin_directories.append(os.environ['HOME']+'/.kicad_plugins/')
        plugin_directories.append(os.environ['HOME']+'/.kicad/scripting/plugins/')

    if sys.platform.startswith('darwin'):
        for singlepath in sys.path:
            if os.path.isdir( os.path.join( singlepath, 'scripting', 'plugins') ):
                plugin_directories.append( os.path.join( singlepath, 'scripting', 'plugins') )

    for plugins_dir in plugin_directories:
        sys.path.append(plugins_dir)

        if not os.path.isdir(plugins_dir):
            continue

        for module in os.listdir(plugins_dir):
            if os.path.isdir(plugins_dir+module):
                __import__(module, locals(), globals())

            if module == '__init__.py' or module[-3:] != '.py':
                continue

            mod = __import__(module[:-3], locals(), globals())

            module_filename = plugins_dir+"/"+module
            mtime = os.path.getmtime(module_filename)
            if hasattr(mod,'register'):
                KICAD_PLUGINS[module]={"filename":module_filename,
                                       "modification_time":mtime,
                                       "object":mod.register(),
                                       "module":mod}



class KiCadPlugin:
    def __init__(self):
        pass

    def register(self):
        if isinstance(self,FilePlugin):
            pass # register to file plugins in C++
        if isinstance(self,FootprintWizardPlugin):
            PYTHON_FOOTPRINT_WIZARDS.register_wizard(self)
            return

        if isinstance(self,ActionPlugin):
            pass # register to action plugins in C++

        return

    def deregister(self):
        if isinstance(self,FilePlugin):
            pass # register to file plugins in C++
        if isinstance(self,FootprintWizardPlugin):
            PYTHON_FOOTPRINT_WIZARDS.deregister_wizard(self)
            return

        if isinstance(self,ActionPlugin):
            pass # register to action plugins in C++

        return




class FilePlugin(KiCadPlugin):
    def __init__(self):
        KiCadPlugin.__init__(self)



class FootprintWizardPlugin(KiCadPlugin):
    def __init__(self):
        KiCadPlugin.__init__(self)
        self.defaults()

    def defaults(self):
        self.module = None
        self.parameters = {}
        self.parameter_errors={}
        self.name = "Undefined Footprint Wizard plugin"
        self.description = ""
        self.image = ""

    def GetName(self):
        return self.name

    def GetImage(self):
        return self.image

    def GetDescription(self):
        return self.description


    def GetNumParameterPages(self):
        return len(self.parameters)

    def GetParameterPageName(self,page_n):
        return self.parameters.keys()[page_n]

    def GetParameterNames(self,page_n):
        name = self.GetParameterPageName(page_n)
        return self.parameters[name].keys()

    def GetParameterValues(self,page_n):
        name = self.GetParameterPageName(page_n)
        values = self.parameters[name].values()
        return map( lambda x: str(x) , values) # list elements as strings

    def GetParameterErrors(self,page_n):
        self.CheckParameters()
        name = self.GetParameterPageName(page_n)
        values = self.parameter_errors[name].values()
        return map( lambda x: str(x) , values) # list elements as strings

    def CheckParameters(self):
        return ""

    def TryConvertToFloat(self,value):
        v = value
        try:
            v = float(value)
        except:
            pass

        return v

    def SetParameterValues(self,page_n,values):
        name = self.GetParameterPageName(page_n)
        keys = self.parameters[name].keys()
        n=0
        for key in keys:
            val = self.TryConvertToFloat(values[n])
            self.parameters[name][key] = val
            print "[%s][%s]<="%(name,key),val
            n+=1


    def ClearErrors(self):
        errs={}

        for page in self.parameters.keys():
            page_dict = self.parameters[page]
            page_params = {}
            for param in page_dict.keys():
                page_params[param]=""

            errs[page]=page_params

        self.parameter_errors = errs


    def GetModule(self):
        self.BuildFootprint()
        return self.module

    def BuildFootprint(self):
        return

    def Show(self):
        print "Footprint Wizard Name:        ",self.GetName()
        print "Footprint Wizard Description: ",self.GetDescription()
        n_pages = self.GetNumParameterPages()
        print " setup pages: ",n_pages
        for page in range(0,n_pages):
            name = self.GetParameterPageName(page)
            values = self.GetParameterValues(page)
            names =  self.GetParameterNames(page)
            print "page %d) %s"%(page,name)
            for n in range (0,len(values)):
                print "\t%s\t:\t%s"%(names[n],values[n])

class ActionPlugin(KiCadPlugin):
    def __init__(self):
        KiCadPlugin.__init__(self)


class CSegment(_object):
    """Proxy of C++ CSegment class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSegment, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSegment, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Start"] = _pcbnew.CSegment_m_Start_set
    __swig_getmethods__["m_Start"] = _pcbnew.CSegment_m_Start_get
    if _newclass:
        m_Start = _swig_property(_pcbnew.CSegment_m_Start_get, _pcbnew.CSegment_m_Start_set)
    __swig_setmethods__["m_End"] = _pcbnew.CSegment_m_End_set
    __swig_getmethods__["m_End"] = _pcbnew.CSegment_m_End_get
    if _newclass:
        m_End = _swig_property(_pcbnew.CSegment_m_End_get, _pcbnew.CSegment_m_End_set)

    def __init__(self, *args):
        """
        __init__(CSegment self) -> CSegment
        __init__(CSegment self, wxPoint aStart, wxPoint aEnd) -> CSegment
        __init__(CSegment self, int x0, int y0, int x1, int y1) -> CSegment
        """
        this = _pcbnew.new_CSegment(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_CSegment
    __del__ = lambda self: None
CSegment_swigregister = _pcbnew.CSegment_swigregister
CSegment_swigregister(CSegment)

class CPolyPt(wxPoint):
    """Proxy of C++ CPolyPt class"""
    __swig_setmethods__ = {}
    for _s in [wxPoint]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyPt, name, value)
    __swig_getmethods__ = {}
    for _s in [wxPoint]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CPolyPt, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False, int aUtility=0) -> CPolyPt
        __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False) -> CPolyPt
        __init__(CPolyPt self, int aX=0, int aY=0) -> CPolyPt
        __init__(CPolyPt self, int aX=0) -> CPolyPt
        __init__(CPolyPt self) -> CPolyPt
        __init__(CPolyPt self, CPolyPt aPt) -> CPolyPt
        __init__(CPolyPt self, wxPoint aPoint) -> CPolyPt
        """
        this = _pcbnew.new_CPolyPt(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_set
    __swig_getmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_get
    if _newclass:
        end_contour = _swig_property(_pcbnew.CPolyPt_end_contour_get, _pcbnew.CPolyPt_end_contour_set)
    __swig_setmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_set
    __swig_getmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_get
    if _newclass:
        m_flags = _swig_property(_pcbnew.CPolyPt_m_flags_get, _pcbnew.CPolyPt_m_flags_set)

    def __eq__(self, cpt2):
        """__eq__(CPolyPt self, CPolyPt cpt2) -> bool"""
        return _pcbnew.CPolyPt___eq__(self, cpt2)


    def __ne__(self, cpt2):
        """__ne__(CPolyPt self, CPolyPt cpt2) -> bool"""
        return _pcbnew.CPolyPt___ne__(self, cpt2)

    __swig_destroy__ = _pcbnew.delete_CPolyPt
    __del__ = lambda self: None
CPolyPt_swigregister = _pcbnew.CPolyPt_swigregister
CPolyPt_swigregister(CPolyPt)

class CPOLYGONS_LIST(_object):
    """Proxy of C++ CPOLYGONS_LIST class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPOLYGONS_LIST, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPOLYGONS_LIST, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(CPOLYGONS_LIST self) -> CPOLYGONS_LIST"""
        this = _pcbnew.new_CPOLYGONS_LIST()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetList(self):
        """GetList(CPOLYGONS_LIST self) -> std::vector< CPolyPt,std::allocator< CPolyPt > > const &"""
        return _pcbnew.CPOLYGONS_LIST_GetList(self)


    def GetX(self, ic):
        """GetX(CPOLYGONS_LIST self, int ic) -> int"""
        return _pcbnew.CPOLYGONS_LIST_GetX(self, ic)


    def SetX(self, ic, aValue):
        """SetX(CPOLYGONS_LIST self, int ic, int aValue)"""
        return _pcbnew.CPOLYGONS_LIST_SetX(self, ic, aValue)


    def GetY(self, ic):
        """GetY(CPOLYGONS_LIST self, int ic) -> int"""
        return _pcbnew.CPOLYGONS_LIST_GetY(self, ic)


    def SetY(self, ic, aValue):
        """SetY(CPOLYGONS_LIST self, int ic, int aValue)"""
        return _pcbnew.CPOLYGONS_LIST_SetY(self, ic, aValue)


    def IsEndContour(self, ic):
        """IsEndContour(CPOLYGONS_LIST self, int ic) -> bool"""
        return _pcbnew.CPOLYGONS_LIST_IsEndContour(self, ic)


    def GetPos(self, ic):
        """GetPos(CPOLYGONS_LIST self, int ic) -> wxPoint"""
        return _pcbnew.CPOLYGONS_LIST_GetPos(self, ic)


    def GetCorner(self, ic):
        """GetCorner(CPOLYGONS_LIST self, int ic) -> CPolyPt"""
        return _pcbnew.CPOLYGONS_LIST_GetCorner(self, ic)


    def reserve(self, aSize):
        """reserve(CPOLYGONS_LIST self, int aSize)"""
        return _pcbnew.CPOLYGONS_LIST_reserve(self, aSize)


    def RemoveAllContours(self):
        """RemoveAllContours(CPOLYGONS_LIST self)"""
        return _pcbnew.CPOLYGONS_LIST_RemoveAllContours(self)


    def GetLastCorner(self):
        """GetLastCorner(CPOLYGONS_LIST self) -> CPolyPt"""
        return _pcbnew.CPOLYGONS_LIST_GetLastCorner(self)


    def GetCornersCount(self):
        """GetCornersCount(CPOLYGONS_LIST self) -> unsigned int"""
        return _pcbnew.CPOLYGONS_LIST_GetCornersCount(self)


    def DeleteCorner(self, aIdx):
        """DeleteCorner(CPOLYGONS_LIST self, int aIdx)"""
        return _pcbnew.CPOLYGONS_LIST_DeleteCorner(self, aIdx)


    def DeleteCorners(self, aIdFirstCorner, aIdLastCorner):
        """DeleteCorners(CPOLYGONS_LIST self, int aIdFirstCorner, int aIdLastCorner)"""
        return _pcbnew.CPOLYGONS_LIST_DeleteCorners(self, aIdFirstCorner, aIdLastCorner)


    def Append(self, *args):
        """
        Append(CPOLYGONS_LIST self, CPOLYGONS_LIST aList)
        Append(CPOLYGONS_LIST self, CPolyPt aItem)
        Append(CPOLYGONS_LIST self, wxPoint aItem)
        """
        return _pcbnew.CPOLYGONS_LIST_Append(self, *args)


    def InsertCorner(self, aPosition, aItem):
        """InsertCorner(CPOLYGONS_LIST self, int aPosition, CPolyPt aItem)"""
        return _pcbnew.CPOLYGONS_LIST_InsertCorner(self, aPosition, aItem)


    def AddCorner(self, aCorner):
        """AddCorner(CPOLYGONS_LIST self, CPolyPt aCorner)"""
        return _pcbnew.CPOLYGONS_LIST_AddCorner(self, aCorner)


    def CloseLastContour(self):
        """CloseLastContour(CPOLYGONS_LIST self)"""
        return _pcbnew.CPOLYGONS_LIST_CloseLastContour(self)


    def GetContoursCount(self):
        """GetContoursCount(CPOLYGONS_LIST self) -> int"""
        return _pcbnew.CPOLYGONS_LIST_GetContoursCount(self)

    __swig_destroy__ = _pcbnew.delete_CPOLYGONS_LIST
    __del__ = lambda self: None
CPOLYGONS_LIST_swigregister = _pcbnew.CPOLYGONS_LIST_swigregister
CPOLYGONS_LIST_swigregister(CPOLYGONS_LIST)

class CPolyLine(_object):
    """Proxy of C++ CPolyLine class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyLine, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPolyLine, name)
    __repr__ = _swig_repr
    NO_HATCH = _pcbnew.CPolyLine_NO_HATCH
    DIAGONAL_FULL = _pcbnew.CPolyLine_DIAGONAL_FULL
    DIAGONAL_EDGE = _pcbnew.CPolyLine_DIAGONAL_EDGE

    def __init__(self, *args):
        """
        __init__(CPolyLine self) -> CPolyLine
        __init__(CPolyLine self, CPolyLine aCPolyLine) -> CPolyLine
        """
        this = _pcbnew.new_CPolyLine(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_CPolyLine
    __del__ = lambda self: None

    def ImportSettings(self, aPoly):
        """ImportSettings(CPolyLine self, CPolyLine aPoly)"""
        return _pcbnew.CPolyLine_ImportSettings(self, aPoly)


    def Start(self, layer, x, y, hatch):
        """Start(CPolyLine self, LAYER_NUM layer, int x, int y, int hatch)"""
        return _pcbnew.CPolyLine_Start(self, layer, x, y, hatch)


    def AppendCorner(self, x, y):
        """AppendCorner(CPolyLine self, int x, int y)"""
        return _pcbnew.CPolyLine_AppendCorner(self, x, y)


    def InsertCorner(self, ic, x, y):
        """InsertCorner(CPolyLine self, int ic, int x, int y)"""
        return _pcbnew.CPolyLine_InsertCorner(self, ic, x, y)


    def DeleteCorner(self, ic):
        """DeleteCorner(CPolyLine self, int ic)"""
        return _pcbnew.CPolyLine_DeleteCorner(self, ic)


    def MoveCorner(self, ic, x, y):
        """MoveCorner(CPolyLine self, int ic, int x, int y)"""
        return _pcbnew.CPolyLine_MoveCorner(self, ic, x, y)


    def CloseLastContour(self):
        """CloseLastContour(CPolyLine self)"""
        return _pcbnew.CPolyLine_CloseLastContour(self)


    def RemoveContour(self, icont):
        """RemoveContour(CPolyLine self, int icont)"""
        return _pcbnew.CPolyLine_RemoveContour(self, icont)


    def IsPolygonSelfIntersecting(self):
        """IsPolygonSelfIntersecting(CPolyLine self) -> bool"""
        return _pcbnew.CPolyLine_IsPolygonSelfIntersecting(self)


    def Chamfer(self, aDistance):
        """Chamfer(CPolyLine self, unsigned int aDistance) -> CPolyLine"""
        return _pcbnew.CPolyLine_Chamfer(self, aDistance)


    def Fillet(self, aRadius, aSegments):
        """Fillet(CPolyLine self, unsigned int aRadius, unsigned int aSegments) -> CPolyLine"""
        return _pcbnew.CPolyLine_Fillet(self, aRadius, aSegments)


    def RemoveNullSegments(self):
        """RemoveNullSegments(CPolyLine self) -> int"""
        return _pcbnew.CPolyLine_RemoveNullSegments(self)


    def RemoveAllContours(self):
        """RemoveAllContours(CPolyLine self)"""
        return _pcbnew.CPolyLine_RemoveAllContours(self)


    def UnHatch(self):
        """UnHatch(CPolyLine self)"""
        return _pcbnew.CPolyLine_UnHatch(self)


    def Hatch(self):
        """Hatch(CPolyLine self)"""
        return _pcbnew.CPolyLine_Hatch(self)


    def MoveOrigin(self, x_off, y_off):
        """MoveOrigin(CPolyLine self, int x_off, int y_off)"""
        return _pcbnew.CPolyLine_MoveOrigin(self, x_off, y_off)


    def GetBoundingBox(self, *args):
        """
        GetBoundingBox(CPolyLine self) -> EDA_RECT
        GetBoundingBox(CPolyLine self, int icont) -> EDA_RECT
        """
        return _pcbnew.CPolyLine_GetBoundingBox(self, *args)


    def Copy(self, src):
        """Copy(CPolyLine self, CPolyLine src)"""
        return _pcbnew.CPolyLine_Copy(self, src)


    def TestPointInside(self, x, y):
        """TestPointInside(CPolyLine self, int x, int y) -> bool"""
        return _pcbnew.CPolyLine_TestPointInside(self, x, y)


    def IsCutoutContour(self, aCornerIdx):
        """IsCutoutContour(CPolyLine self, int aCornerIdx) -> bool"""
        return _pcbnew.CPolyLine_IsCutoutContour(self, aCornerIdx)


    def AppendArc(self, xi, yi, xf, yf, xc, yc, num):
        """AppendArc(CPolyLine self, int xi, int yi, int xf, int yf, int xc, int yc, int num)"""
        return _pcbnew.CPolyLine_AppendArc(self, xi, yi, xf, yf, xc, yc, num)


    def SetLayer(self, aLayer):
        """SetLayer(CPolyLine self, LAYER_NUM aLayer)"""
        return _pcbnew.CPolyLine_SetLayer(self, aLayer)


    def GetLayer(self):
        """GetLayer(CPolyLine self) -> LAYER_NUM"""
        return _pcbnew.CPolyLine_GetLayer(self)


    def GetCornersCount(self):
        """GetCornersCount(CPolyLine self) -> int"""
        return _pcbnew.CPolyLine_GetCornersCount(self)


    def GetClosed(self):
        """GetClosed(CPolyLine self) -> bool"""
        return _pcbnew.CPolyLine_GetClosed(self)


    def GetContoursCount(self):
        """GetContoursCount(CPolyLine self) -> int"""
        return _pcbnew.CPolyLine_GetContoursCount(self)


    def GetContour(self, ic):
        """GetContour(CPolyLine self, int ic) -> int"""
        return _pcbnew.CPolyLine_GetContour(self, ic)


    def GetContourStart(self, icont):
        """GetContourStart(CPolyLine self, int icont) -> int"""
        return _pcbnew.CPolyLine_GetContourStart(self, icont)


    def GetContourEnd(self, icont):
        """GetContourEnd(CPolyLine self, int icont) -> int"""
        return _pcbnew.CPolyLine_GetContourEnd(self, icont)


    def GetContourSize(self, icont):
        """GetContourSize(CPolyLine self, int icont) -> int"""
        return _pcbnew.CPolyLine_GetContourSize(self, icont)


    def GetX(self, ic):
        """GetX(CPolyLine self, int ic) -> int"""
        return _pcbnew.CPolyLine_GetX(self, ic)


    def GetY(self, ic):
        """GetY(CPolyLine self, int ic) -> int"""
        return _pcbnew.CPolyLine_GetY(self, ic)


    def IsEndContour(self, ic):
        """IsEndContour(CPolyLine self, int ic) -> bool"""
        return _pcbnew.CPolyLine_IsEndContour(self, ic)


    def GetPos(self, ic):
        """GetPos(CPolyLine self, int ic) -> wxPoint"""
        return _pcbnew.CPolyLine_GetPos(self, ic)


    def GetHatchPitch(self):
        """GetHatchPitch(CPolyLine self) -> int"""
        return _pcbnew.CPolyLine_GetHatchPitch(self)


    def GetDefaultHatchPitchMils():
        """GetDefaultHatchPitchMils() -> int"""
        return _pcbnew.CPolyLine_GetDefaultHatchPitchMils()

    if _newclass:
        GetDefaultHatchPitchMils = staticmethod(GetDefaultHatchPitchMils)
    __swig_getmethods__["GetDefaultHatchPitchMils"] = lambda x: GetDefaultHatchPitchMils

    def GetHatchStyle(self):
        """GetHatchStyle(CPolyLine self) -> enum CPolyLine::HATCH_STYLE"""
        return _pcbnew.CPolyLine_GetHatchStyle(self)


    def SetHatch(self, aHatchStyle, aHatchPitch, aRebuildHatch):
        """SetHatch(CPolyLine self, int aHatchStyle, int aHatchPitch, bool aRebuildHatch)"""
        return _pcbnew.CPolyLine_SetHatch(self, aHatchStyle, aHatchPitch, aRebuildHatch)


    def SetX(self, ic, x):
        """SetX(CPolyLine self, int ic, int x)"""
        return _pcbnew.CPolyLine_SetX(self, ic, x)


    def SetY(self, ic, y):
        """SetY(CPolyLine self, int ic, int y)"""
        return _pcbnew.CPolyLine_SetY(self, ic, y)


    def SetHatchStyle(self, style):
        """SetHatchStyle(CPolyLine self, enum CPolyLine::HATCH_STYLE style)"""
        return _pcbnew.CPolyLine_SetHatchStyle(self, style)


    def SetHatchPitch(self, pitch):
        """SetHatchPitch(CPolyLine self, int pitch)"""
        return _pcbnew.CPolyLine_SetHatchPitch(self, pitch)


    def NormalizeAreaOutlines(self, aNewPolygonList):
        """NormalizeAreaOutlines(CPolyLine self, std::vector< CPolyLine *,std::allocator< CPolyLine * > > * aNewPolygonList) -> int"""
        return _pcbnew.CPolyLine_NormalizeAreaOutlines(self, aNewPolygonList)


    def AppendBezier(self, *args):
        """
        AppendBezier(CPolyLine self, int x1, int y1, int x2, int y2, int x3, int y3)
        AppendBezier(CPolyLine self, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
        """
        return _pcbnew.CPolyLine_AppendBezier(self, *args)


    def Distance(self, *args):
        """
        Distance(CPolyLine self, wxPoint aPoint) -> int
        Distance(CPolyLine self, wxPoint aStart, wxPoint aEnd, int aWidth) -> int
        """
        return _pcbnew.CPolyLine_Distance(self, *args)


    def HitTestForEdge(self, aPos, aDistMax):
        """HitTestForEdge(CPolyLine self, wxPoint aPos, int aDistMax) -> int"""
        return _pcbnew.CPolyLine_HitTestForEdge(self, aPos, aDistMax)


    def HitTestForCorner(self, aPos, aDistMax):
        """HitTestForCorner(CPolyLine self, wxPoint aPos, int aDistMax) -> int"""
        return _pcbnew.CPolyLine_HitTestForCorner(self, aPos, aDistMax)

    __swig_setmethods__["m_CornersList"] = _pcbnew.CPolyLine_m_CornersList_set
    __swig_getmethods__["m_CornersList"] = _pcbnew.CPolyLine_m_CornersList_get
    if _newclass:
        m_CornersList = _swig_property(_pcbnew.CPolyLine_m_CornersList_get, _pcbnew.CPolyLine_m_CornersList_set)
    __swig_setmethods__["m_HatchLines"] = _pcbnew.CPolyLine_m_HatchLines_set
    __swig_getmethods__["m_HatchLines"] = _pcbnew.CPolyLine_m_HatchLines_get
    if _newclass:
        m_HatchLines = _swig_property(_pcbnew.CPolyLine_m_HatchLines_get, _pcbnew.CPolyLine_m_HatchLines_set)
CPolyLine_swigregister = _pcbnew.CPolyLine_swigregister
CPolyLine_swigregister(CPolyLine)

def CPolyLine_GetDefaultHatchPitchMils():
    """CPolyLine_GetDefaultHatchPitchMils() -> int"""
    return _pcbnew.CPolyLine_GetDefaultHatchPitchMils()


def ConvertPolyListToPolySet(aList):
    """ConvertPolyListToPolySet(CPOLYGONS_LIST aList) -> SHAPE_POLY_SET const"""
    return _pcbnew.ConvertPolyListToPolySet(aList)

def ConvertPolySetToPolyList(aPolyset):
    """ConvertPolySetToPolyList(SHAPE_POLY_SET const & aPolyset) -> CPOLYGONS_LIST"""
    return _pcbnew.ConvertPolySetToPolyList(aPolyset)
class UTF8(string):
    """Proxy of C++ UTF8 class"""
    __swig_setmethods__ = {}
    for _s in [string]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UTF8, name, value)
    __swig_getmethods__ = {}
    for _s in [string]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, UTF8, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(UTF8 self, wxString const & o) -> UTF8
        __init__(UTF8 self, char const * txt) -> UTF8
        __init__(UTF8 self, wchar_t const * txt) -> UTF8
        __init__(UTF8 self, string o) -> UTF8
        __init__(UTF8 self) -> UTF8
        """
        this = _pcbnew.new_UTF8(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_UTF8
    __del__ = lambda self: None

    def substr(self, *args):
        """
        substr(UTF8 self, size_t pos=0, size_t len) -> UTF8
        substr(UTF8 self, size_t pos=0) -> UTF8
        substr(UTF8 self) -> UTF8
        """
        return _pcbnew.UTF8_substr(self, *args)


    def utf8_to_wxstring(self):
        """utf8_to_wxstring(UTF8 self) -> wxString"""
        return _pcbnew.UTF8_utf8_to_wxstring(self)


    def utf8_to_charptr(self):
        """utf8_to_charptr(UTF8 self) -> char *"""
        return _pcbnew.UTF8_utf8_to_charptr(self)


    def uni_forward(aSequence, aResult=None):
        """
        uni_forward(unsigned char const * aSequence, unsigned int * aResult=None) -> int
        uni_forward(unsigned char const * aSequence) -> int
        """
        return _pcbnew.UTF8_uni_forward(aSequence, aResult)

    if _newclass:
        uni_forward = staticmethod(uni_forward)
    __swig_getmethods__["uni_forward"] = lambda x: uni_forward

    def ubegin(self):
        """ubegin(UTF8 self) -> UTF8::uni_iter"""
        return _pcbnew.UTF8_ubegin(self)


    def uend(self):
        """uend(UTF8 self) -> UTF8::uni_iter"""
        return _pcbnew.UTF8_uend(self)


    def Cast_to_CChar(self):
        """Cast_to_CChar(UTF8 self) -> char const *"""
        return _pcbnew.UTF8_Cast_to_CChar(self)



        # Get the char buffer of the UTF8 string
    def GetChars(self):
        return self.Cast_to_CChar()

    # Convert the UTF8 string to a python string
    # Same as GetChars(), but more easy to use in print command
    def __str__(self):
        return self.GetChars()


UTF8_swigregister = _pcbnew.UTF8_swigregister
UTF8_swigregister(UTF8)

def UTF8_uni_forward(aSequence, aResult=None):
    """
    uni_forward(unsigned char const * aSequence, unsigned int * aResult=None) -> int
    UTF8_uni_forward(unsigned char const * aSequence) -> int
    """
    return _pcbnew.UTF8_uni_forward(aSequence, aResult)


_pcbnew.S_SEGMENT_swigconstant(_pcbnew)
S_SEGMENT = _pcbnew.S_SEGMENT

_pcbnew.S_RECT_swigconstant(_pcbnew)
S_RECT = _pcbnew.S_RECT

_pcbnew.S_ARC_swigconstant(_pcbnew)
S_ARC = _pcbnew.S_ARC

_pcbnew.S_CIRCLE_swigconstant(_pcbnew)
S_CIRCLE = _pcbnew.S_CIRCLE

_pcbnew.S_POLYGON_swigconstant(_pcbnew)
S_POLYGON = _pcbnew.S_POLYGON

_pcbnew.S_CURVE_swigconstant(_pcbnew)
S_CURVE = _pcbnew.S_CURVE

_pcbnew.S_LAST_swigconstant(_pcbnew)
S_LAST = _pcbnew.S_LAST
class BOARD_ITEM(EDA_ITEM):
    """Proxy of C++ BOARD_ITEM class"""
    __swig_setmethods__ = {}
    for _s in [EDA_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BOARD_ITEM, name, value)
    __swig_getmethods__ = {}
    for _s in [EDA_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BOARD_ITEM, name)

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

    def GetPosition(self):
        """GetPosition(BOARD_ITEM self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_GetPosition(self)


    def GetCenter(self):
        """GetCenter(BOARD_ITEM self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_GetCenter(self)


    def SetPosition(self, aPos):
        """SetPosition(BOARD_ITEM self, wxPoint aPos)"""
        return _pcbnew.BOARD_ITEM_SetPosition(self, aPos)


    def IsConnected(self):
        """IsConnected(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsConnected(self)


    def Next(self):
        """Next(BOARD_ITEM self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_Next(self)


    def Back(self):
        """Back(BOARD_ITEM self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_Back(self)


    def GetParent(self):
        """GetParent(BOARD_ITEM self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_GetParent(self)


    def GetLayer(self):
        """GetLayer(BOARD_ITEM self) -> LAYER_ID"""
        return _pcbnew.BOARD_ITEM_GetLayer(self)


    def GetLayerSet(self):
        """GetLayerSet(BOARD_ITEM self) -> LSET"""
        return _pcbnew.BOARD_ITEM_GetLayerSet(self)


    def SetLayer(self, aLayer):
        """SetLayer(BOARD_ITEM self, LAYER_ID aLayer)"""
        return _pcbnew.BOARD_ITEM_SetLayer(self, aLayer)


    def Draw(self, *args):
        """
        Draw(BOARD_ITEM self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(BOARD_ITEM self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.BOARD_ITEM_Draw(self, *args)


    def SwapData(self, aImage):
        """SwapData(BOARD_ITEM self, BOARD_ITEM aImage)"""
        return _pcbnew.BOARD_ITEM_SwapData(self, aImage)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(BOARD_ITEM self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_ITEM_IsOnLayer(self, aLayer)


    def IsTrack(self):
        """IsTrack(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsTrack(self)


    def IsLocked(self):
        """IsLocked(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsLocked(self)


    def UnLink(self):
        """UnLink(BOARD_ITEM self)"""
        return _pcbnew.BOARD_ITEM_UnLink(self)


    def DeleteStructure(self):
        """DeleteStructure(BOARD_ITEM self)"""
        return _pcbnew.BOARD_ITEM_DeleteStructure(self)


    def ShowShape(aShape):
        """ShowShape(STROKE_T aShape) -> wxString"""
        return _pcbnew.BOARD_ITEM_ShowShape(aShape)

    if _newclass:
        ShowShape = staticmethod(ShowShape)
    __swig_getmethods__["ShowShape"] = lambda x: ShowShape

    def Move(self, aMoveVector):
        """Move(BOARD_ITEM self, wxPoint aMoveVector)"""
        return _pcbnew.BOARD_ITEM_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(BOARD_ITEM self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.BOARD_ITEM_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(BOARD_ITEM self, wxPoint aCentre)"""
        return _pcbnew.BOARD_ITEM_Flip(self, aCentre)


    def GetBoard(self):
        """GetBoard(BOARD_ITEM self) -> BOARD"""
        return _pcbnew.BOARD_ITEM_GetBoard(self)


    def GetLayerName(self):
        """GetLayerName(BOARD_ITEM self) -> wxString"""
        return _pcbnew.BOARD_ITEM_GetLayerName(self)


    def HitTest(self, *args):
        """
        HitTest(BOARD_ITEM self, wxPoint aPosition) -> bool
        HitTest(BOARD_ITEM self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(BOARD_ITEM self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(BOARD_ITEM self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.BOARD_ITEM_HitTest(self, *args)


    def FormatAngle(aAngle):
        """FormatAngle(double aAngle) -> string"""
        return _pcbnew.BOARD_ITEM_FormatAngle(aAngle)

    if _newclass:
        FormatAngle = staticmethod(FormatAngle)
    __swig_getmethods__["FormatAngle"] = lambda x: FormatAngle

    def FormatInternalUnits(*args):
        """
        FormatInternalUnits(int aValue) -> string
        FormatInternalUnits(wxPoint aPoint) -> string
        FormatInternalUnits(wxSize aSize) -> string
        """
        return _pcbnew.BOARD_ITEM_FormatInternalUnits(*args)

    if _newclass:
        FormatInternalUnits = staticmethod(FormatInternalUnits)
    __swig_getmethods__["FormatInternalUnits"] = lambda x: FormatInternalUnits

    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(BOARD_ITEM self, int [] aLayers, int & aCount)"""
        return _pcbnew.BOARD_ITEM_ViewGetLayers(self, aLayers, aCount)


    def IncrementItemReference(self):
        """IncrementItemReference(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IncrementItemReference(self)


    def Cast_to_TEXTE_PCB(self):
        """Cast_to_TEXTE_PCB(BOARD_ITEM self) -> TEXTE_PCB"""
        return _pcbnew.BOARD_ITEM_Cast_to_TEXTE_PCB(self)


    def Cast_to_DIMENSION(self):
        """Cast_to_DIMENSION(BOARD_ITEM self) -> DIMENSION"""
        return _pcbnew.BOARD_ITEM_Cast_to_DIMENSION(self)


    def Cast_to_MODULE(self):
        """Cast_to_MODULE(BOARD_ITEM self) -> MODULE"""
        return _pcbnew.BOARD_ITEM_Cast_to_MODULE(self)


    def Cast_to_TEXTE_MODULE(self):
        """Cast_to_TEXTE_MODULE(BOARD_ITEM self) -> TEXTE_MODULE"""
        return _pcbnew.BOARD_ITEM_Cast_to_TEXTE_MODULE(self)


    def Cast_to_DRAWSEGMENT(self):
        """Cast_to_DRAWSEGMENT(BOARD_ITEM self) -> DRAWSEGMENT"""
        return _pcbnew.BOARD_ITEM_Cast_to_DRAWSEGMENT(self)


    def Cast_to_MARKER_PCB(self):
        """Cast_to_MARKER_PCB(BOARD_ITEM self) -> MARKER_PCB"""
        return _pcbnew.BOARD_ITEM_Cast_to_MARKER_PCB(self)


    def Cast_to_BOARD(self):
        """Cast_to_BOARD(BOARD_ITEM self) -> BOARD"""
        return _pcbnew.BOARD_ITEM_Cast_to_BOARD(self)


    def Cast_to_EDGE_MODULE(self):
        """Cast_to_EDGE_MODULE(BOARD_ITEM self) -> EDGE_MODULE"""
        return _pcbnew.BOARD_ITEM_Cast_to_EDGE_MODULE(self)


    def Cast_to_D_PAD(self):
        """Cast_to_D_PAD(BOARD_ITEM self) -> D_PAD"""
        return _pcbnew.BOARD_ITEM_Cast_to_D_PAD(self)


    def Cast_to_TRACK(self):
        """Cast_to_TRACK(BOARD_ITEM self) -> TRACK"""
        return _pcbnew.BOARD_ITEM_Cast_to_TRACK(self)


    def Cast_to_VIA(self):
        """Cast_to_VIA(BOARD_ITEM self) -> VIA"""
        return _pcbnew.BOARD_ITEM_Cast_to_VIA(self)


    def Cast_to_ZONE_CONTAINER(self):
        """Cast_to_ZONE_CONTAINER(BOARD_ITEM self) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_ITEM_Cast_to_ZONE_CONTAINER(self)


    def Cast_to_PCB_TARGET(self):
        """Cast_to_PCB_TARGET(BOARD_ITEM self) -> PCB_TARGET"""
        return _pcbnew.BOARD_ITEM_Cast_to_PCB_TARGET(self)


    def Cast(self):

        ct = self.GetClass()

        if ct=="PTEXT":
            return self.Cast_to_TEXTE_PCB()
        elif ct=="BOARD":
            return self.Cast_to_BOARD()
        elif ct=="DIMENSION":
            return self.Cast_to_DIMENSION()
        elif ct=="DRAWSEGMENT":
            return self.Cast_to_DRAWSEGMENT()
        elif ct=="MGRAPHIC":
            return self.Cast_to_EDGE_MODULE()
        elif ct=="MODULE":
            return self.Cast_to_MODULE()
        elif ct=="PAD":
            return self.Cast_to_D_PAD()
        elif ct=="MTEXT":
            return self.Cast_to_TEXTE_MODULE()
        elif ct=="VIA":
            return self.Cast_to_VIA()
        elif ct=="TRACK":
            return self.Cast_to_TRACK()
        elif ct=="PCB_TARGET":
            return self.Cast_to_PCB_TARGET()
        elif ct=="ZONE_CONTAINER":
            return self.Cast_to_ZONE_CONTAINER()
        else:
            return None


    def Duplicate(self):

        ct = self.GetClass()

        if ct=="BOARD":
            return None
        else:
            return Cast_to_BOARD_ITEM(self.Clone()).Cast()


    def SetPos(self,p):
        self.SetPosition(p)
        self.SetPos0(p)

    def SetStartEnd(self,start,end):
        self.SetStart(start)
        self.SetStart0(start)
        self.SetEnd(end)
        self.SetEnd0(end)

    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM
    __del__ = lambda self: None
BOARD_ITEM_swigregister = _pcbnew.BOARD_ITEM_swigregister
BOARD_ITEM_swigregister(BOARD_ITEM)

def BOARD_ITEM_ShowShape(aShape):
    """BOARD_ITEM_ShowShape(STROKE_T aShape) -> wxString"""
    return _pcbnew.BOARD_ITEM_ShowShape(aShape)

def BOARD_ITEM_FormatAngle(aAngle):
    """BOARD_ITEM_FormatAngle(double aAngle) -> string"""
    return _pcbnew.BOARD_ITEM_FormatAngle(aAngle)

def BOARD_ITEM_FormatInternalUnits(*args):
    """
    FormatInternalUnits(int aValue) -> string
    FormatInternalUnits(wxPoint aPoint) -> string
    BOARD_ITEM_FormatInternalUnits(wxSize aSize) -> string
    """
    return _pcbnew.BOARD_ITEM_FormatInternalUnits(*args)

class BOARD_CONNECTED_ITEM(BOARD_ITEM):
    """Proxy of C++ BOARD_CONNECTED_ITEM class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BOARD_CONNECTED_ITEM, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BOARD_CONNECTED_ITEM, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["m_TracksConnected"] = _pcbnew.BOARD_CONNECTED_ITEM_m_TracksConnected_set
    __swig_getmethods__["m_TracksConnected"] = _pcbnew.BOARD_CONNECTED_ITEM_m_TracksConnected_get
    if _newclass:
        m_TracksConnected = _swig_property(_pcbnew.BOARD_CONNECTED_ITEM_m_TracksConnected_get, _pcbnew.BOARD_CONNECTED_ITEM_m_TracksConnected_set)
    __swig_setmethods__["m_PadsConnected"] = _pcbnew.BOARD_CONNECTED_ITEM_m_PadsConnected_set
    __swig_getmethods__["m_PadsConnected"] = _pcbnew.BOARD_CONNECTED_ITEM_m_PadsConnected_get
    if _newclass:
        m_PadsConnected = _swig_property(_pcbnew.BOARD_CONNECTED_ITEM_m_PadsConnected_get, _pcbnew.BOARD_CONNECTED_ITEM_m_PadsConnected_set)

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def IsConnected(self):
        """IsConnected(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_IsConnected(self)


    def GetNet(self):
        """GetNet(BOARD_CONNECTED_ITEM self) -> NETINFO_ITEM"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNet(self)


    def GetNetCode(self):
        """GetNetCode(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetCode(self)


    def SetNetCode(self, aNetCode, aNoAssert=False):
        """
        SetNetCode(BOARD_CONNECTED_ITEM self, int aNetCode, bool aNoAssert=False) -> bool
        SetNetCode(BOARD_CONNECTED_ITEM self, int aNetCode) -> bool
        """
        return _pcbnew.BOARD_CONNECTED_ITEM_SetNetCode(self, aNetCode, aNoAssert)


    def GetSubNet(self):
        """GetSubNet(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetSubNet(self)


    def SetSubNet(self, aSubNetCode):
        """SetSubNet(BOARD_CONNECTED_ITEM self, int aSubNetCode)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetSubNet(self, aSubNetCode)


    def GetZoneSubNet(self):
        """GetZoneSubNet(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetZoneSubNet(self)


    def SetZoneSubNet(self, aSubNetCode):
        """SetZoneSubNet(BOARD_CONNECTED_ITEM self, int aSubNetCode)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetZoneSubNet(self, aSubNetCode)


    def GetNetname(self):
        """GetNetname(BOARD_CONNECTED_ITEM self) -> wxString const &"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetname(self)


    def GetShortNetname(self):
        """GetShortNetname(BOARD_CONNECTED_ITEM self) -> wxString const &"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetShortNetname(self)


    def GetClearance(self, aItem=None):
        """
        GetClearance(BOARD_CONNECTED_ITEM self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(BOARD_CONNECTED_ITEM self) -> int
        """
        return _pcbnew.BOARD_CONNECTED_ITEM_GetClearance(self, aItem)


    def GetNetClass(self):
        """GetNetClass(BOARD_CONNECTED_ITEM self) -> boost::shared_ptr< NETCLASS >"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetClass(self)


    def GetNetClassName(self):
        """GetNetClassName(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetClassName(self)

    __swig_destroy__ = _pcbnew.delete_BOARD_CONNECTED_ITEM
    __del__ = lambda self: None
BOARD_CONNECTED_ITEM_swigregister = _pcbnew.BOARD_CONNECTED_ITEM_swigregister
BOARD_CONNECTED_ITEM_swigregister(BOARD_CONNECTED_ITEM)

def BOARD_CONNECTED_ITEM_ClassOf(aItem):
    """BOARD_CONNECTED_ITEM_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.BOARD_CONNECTED_ITEM_ClassOf(aItem)


_pcbnew.DEFAULT_TEXT_MODULE_SIZE_swigconstant(_pcbnew)
DEFAULT_TEXT_MODULE_SIZE = _pcbnew.DEFAULT_TEXT_MODULE_SIZE

_pcbnew.DEFAULT_GR_MODULE_THICKNESS_swigconstant(_pcbnew)
DEFAULT_GR_MODULE_THICKNESS = _pcbnew.DEFAULT_GR_MODULE_THICKNESS

_pcbnew.DEFAULT_BOARD_THICKNESS_MM_swigconstant(_pcbnew)
DEFAULT_BOARD_THICKNESS_MM = _pcbnew.DEFAULT_BOARD_THICKNESS_MM

_pcbnew.DEFAULT_TEXT_PCB_SIZE_swigconstant(_pcbnew)
DEFAULT_TEXT_PCB_SIZE = _pcbnew.DEFAULT_TEXT_PCB_SIZE

_pcbnew.DEFAULT_TEXT_PCB_THICKNESS_swigconstant(_pcbnew)
DEFAULT_TEXT_PCB_THICKNESS = _pcbnew.DEFAULT_TEXT_PCB_THICKNESS

_pcbnew.DEFAULT_PCB_EDGE_THICKNESS_swigconstant(_pcbnew)
DEFAULT_PCB_EDGE_THICKNESS = _pcbnew.DEFAULT_PCB_EDGE_THICKNESS

_pcbnew.DEFAULT_GRAPHIC_THICKNESS_swigconstant(_pcbnew)
DEFAULT_GRAPHIC_THICKNESS = _pcbnew.DEFAULT_GRAPHIC_THICKNESS

_pcbnew.DEFAULT_SOLDERMASK_CLEARANCE_swigconstant(_pcbnew)
DEFAULT_SOLDERMASK_CLEARANCE = _pcbnew.DEFAULT_SOLDERMASK_CLEARANCE

_pcbnew.DEFAULT_CUSTOMTRACKWIDTH_swigconstant(_pcbnew)
DEFAULT_CUSTOMTRACKWIDTH = _pcbnew.DEFAULT_CUSTOMTRACKWIDTH

_pcbnew.DEFAULT_TRACKMINWIDTH_swigconstant(_pcbnew)
DEFAULT_TRACKMINWIDTH = _pcbnew.DEFAULT_TRACKMINWIDTH

_pcbnew.DEFAULT_VIASMINSIZE_swigconstant(_pcbnew)
DEFAULT_VIASMINSIZE = _pcbnew.DEFAULT_VIASMINSIZE

_pcbnew.DEFAULT_VIASMINDRILL_swigconstant(_pcbnew)
DEFAULT_VIASMINDRILL = _pcbnew.DEFAULT_VIASMINDRILL

_pcbnew.DEFAULT_MICROVIASMINSIZE_swigconstant(_pcbnew)
DEFAULT_MICROVIASMINSIZE = _pcbnew.DEFAULT_MICROVIASMINSIZE

_pcbnew.DEFAULT_MICROVIASMINDRILL_swigconstant(_pcbnew)
DEFAULT_MICROVIASMINDRILL = _pcbnew.DEFAULT_MICROVIASMINDRILL
class VIA_DIMENSION(_object):
    """Proxy of C++ VIA_DIMENSION class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VIA_DIMENSION, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VIA_DIMENSION, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Diameter"] = _pcbnew.VIA_DIMENSION_m_Diameter_set
    __swig_getmethods__["m_Diameter"] = _pcbnew.VIA_DIMENSION_m_Diameter_get
    if _newclass:
        m_Diameter = _swig_property(_pcbnew.VIA_DIMENSION_m_Diameter_get, _pcbnew.VIA_DIMENSION_m_Diameter_set)
    __swig_setmethods__["m_Drill"] = _pcbnew.VIA_DIMENSION_m_Drill_set
    __swig_getmethods__["m_Drill"] = _pcbnew.VIA_DIMENSION_m_Drill_get
    if _newclass:
        m_Drill = _swig_property(_pcbnew.VIA_DIMENSION_m_Drill_get, _pcbnew.VIA_DIMENSION_m_Drill_set)

    def __init__(self, *args):
        """
        __init__(VIA_DIMENSION self) -> VIA_DIMENSION
        __init__(VIA_DIMENSION self, int aDiameter, int aDrill) -> VIA_DIMENSION
        """
        this = _pcbnew.new_VIA_DIMENSION(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __eq__(self, aOther):
        """__eq__(VIA_DIMENSION self, VIA_DIMENSION aOther) -> bool"""
        return _pcbnew.VIA_DIMENSION___eq__(self, aOther)


    def __lt__(self, aOther):
        """__lt__(VIA_DIMENSION self, VIA_DIMENSION aOther) -> bool"""
        return _pcbnew.VIA_DIMENSION___lt__(self, aOther)

    __swig_destroy__ = _pcbnew.delete_VIA_DIMENSION
    __del__ = lambda self: None
VIA_DIMENSION_swigregister = _pcbnew.VIA_DIMENSION_swigregister
VIA_DIMENSION_swigregister(VIA_DIMENSION)

class BOARD_DESIGN_SETTINGS(_object):
    """Proxy of C++ BOARD_DESIGN_SETTINGS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BOARD_DESIGN_SETTINGS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BOARD_DESIGN_SETTINGS, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_ViasDimensionsList"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_set
    __swig_getmethods__["m_ViasDimensionsList"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_get
    if _newclass:
        m_ViasDimensionsList = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_set)
    __swig_setmethods__["m_TrackWidthList"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_set
    __swig_getmethods__["m_TrackWidthList"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_get
    if _newclass:
        m_TrackWidthList = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_set)
    __swig_setmethods__["m_NetClasses"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_NetClasses_set
    __swig_getmethods__["m_NetClasses"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_NetClasses_get
    if _newclass:
        m_NetClasses = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_NetClasses_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_NetClasses_set)
    __swig_setmethods__["m_MicroViasAllowed"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_set
    __swig_getmethods__["m_MicroViasAllowed"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_get
    if _newclass:
        m_MicroViasAllowed = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_set)
    __swig_setmethods__["m_BlindBuriedViaAllowed"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_set
    __swig_getmethods__["m_BlindBuriedViaAllowed"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_get
    if _newclass:
        m_BlindBuriedViaAllowed = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_set)
    __swig_setmethods__["m_CurrentViaType"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_set
    __swig_getmethods__["m_CurrentViaType"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_get
    if _newclass:
        m_CurrentViaType = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_set)
    __swig_setmethods__["m_UseConnectedTrackWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_set
    __swig_getmethods__["m_UseConnectedTrackWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_get
    if _newclass:
        m_UseConnectedTrackWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_set)
    __swig_setmethods__["m_DrawSegmentWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_DrawSegmentWidth_set
    __swig_getmethods__["m_DrawSegmentWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_DrawSegmentWidth_get
    if _newclass:
        m_DrawSegmentWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DrawSegmentWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DrawSegmentWidth_set)
    __swig_setmethods__["m_EdgeSegmentWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_EdgeSegmentWidth_set
    __swig_getmethods__["m_EdgeSegmentWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_EdgeSegmentWidth_get
    if _newclass:
        m_EdgeSegmentWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_EdgeSegmentWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_EdgeSegmentWidth_set)
    __swig_setmethods__["m_PcbTextWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextWidth_set
    __swig_getmethods__["m_PcbTextWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextWidth_get
    if _newclass:
        m_PcbTextWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextWidth_set)
    __swig_setmethods__["m_PcbTextSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextSize_set
    __swig_getmethods__["m_PcbTextSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextSize_get
    if _newclass:
        m_PcbTextSize = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_PcbTextSize_set)
    __swig_setmethods__["m_TrackMinWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_set
    __swig_getmethods__["m_TrackMinWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_get
    if _newclass:
        m_TrackMinWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_set)
    __swig_setmethods__["m_ViasMinSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_set
    __swig_getmethods__["m_ViasMinSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_get
    if _newclass:
        m_ViasMinSize = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_set)
    __swig_setmethods__["m_ViasMinDrill"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinDrill_set
    __swig_getmethods__["m_ViasMinDrill"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinDrill_get
    if _newclass:
        m_ViasMinDrill = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinDrill_set)
    __swig_setmethods__["m_MicroViasMinSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_set
    __swig_getmethods__["m_MicroViasMinSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_get
    if _newclass:
        m_MicroViasMinSize = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_set)
    __swig_setmethods__["m_MicroViasMinDrill"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_set
    __swig_getmethods__["m_MicroViasMinDrill"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_get
    if _newclass:
        m_MicroViasMinDrill = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_set)
    __swig_setmethods__["m_SolderMaskMargin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_set
    __swig_getmethods__["m_SolderMaskMargin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_get
    if _newclass:
        m_SolderMaskMargin = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_set)
    __swig_setmethods__["m_SolderMaskMinWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_set
    __swig_getmethods__["m_SolderMaskMinWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_get
    if _newclass:
        m_SolderMaskMinWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_set)
    __swig_setmethods__["m_SolderPasteMargin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_set
    __swig_getmethods__["m_SolderPasteMargin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_get
    if _newclass:
        m_SolderPasteMargin = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_set)
    __swig_setmethods__["m_SolderPasteMarginRatio"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_set
    __swig_getmethods__["m_SolderPasteMarginRatio"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_get
    if _newclass:
        m_SolderPasteMarginRatio = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_set)
    __swig_setmethods__["m_ModuleSegmentWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleSegmentWidth_set
    __swig_getmethods__["m_ModuleSegmentWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleSegmentWidth_get
    if _newclass:
        m_ModuleSegmentWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleSegmentWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleSegmentWidth_set)
    __swig_setmethods__["m_ModuleTextSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextSize_set
    __swig_getmethods__["m_ModuleTextSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextSize_get
    if _newclass:
        m_ModuleTextSize = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextSize_set)
    __swig_setmethods__["m_ModuleTextWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextWidth_set
    __swig_getmethods__["m_ModuleTextWidth"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextWidth_get
    if _newclass:
        m_ModuleTextWidth = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ModuleTextWidth_set)
    __swig_setmethods__["m_RefDefaultText"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultText_set
    __swig_getmethods__["m_RefDefaultText"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultText_get
    if _newclass:
        m_RefDefaultText = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultText_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultText_set)
    __swig_setmethods__["m_RefDefaultVisibility"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultVisibility_set
    __swig_getmethods__["m_RefDefaultVisibility"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultVisibility_get
    if _newclass:
        m_RefDefaultVisibility = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultVisibility_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultVisibility_set)
    __swig_setmethods__["m_RefDefaultlayer"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultlayer_set
    __swig_getmethods__["m_RefDefaultlayer"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultlayer_get
    if _newclass:
        m_RefDefaultlayer = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultlayer_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultlayer_set)
    __swig_setmethods__["m_ValueDefaultText"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultText_set
    __swig_getmethods__["m_ValueDefaultText"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultText_get
    if _newclass:
        m_ValueDefaultText = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultText_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultText_set)
    __swig_setmethods__["m_ValueDefaultVisibility"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultVisibility_set
    __swig_getmethods__["m_ValueDefaultVisibility"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultVisibility_get
    if _newclass:
        m_ValueDefaultVisibility = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultVisibility_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultVisibility_set)
    __swig_setmethods__["m_ValueDefaultlayer"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultlayer_set
    __swig_getmethods__["m_ValueDefaultlayer"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultlayer_get
    if _newclass:
        m_ValueDefaultlayer = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultlayer_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultlayer_set)
    __swig_setmethods__["m_AuxOrigin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_AuxOrigin_set
    __swig_getmethods__["m_AuxOrigin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_AuxOrigin_get
    if _newclass:
        m_AuxOrigin = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_AuxOrigin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_AuxOrigin_set)
    __swig_setmethods__["m_GridOrigin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_GridOrigin_set
    __swig_getmethods__["m_GridOrigin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_GridOrigin_get
    if _newclass:
        m_GridOrigin = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_GridOrigin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_GridOrigin_set)
    __swig_setmethods__["m_Pad_Master"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_Pad_Master_set
    __swig_getmethods__["m_Pad_Master"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_Pad_Master_get
    if _newclass:
        m_Pad_Master = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_Pad_Master_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_Pad_Master_set)

    def __init__(self):
        """__init__(BOARD_DESIGN_SETTINGS self) -> BOARD_DESIGN_SETTINGS"""
        this = _pcbnew.new_BOARD_DESIGN_SETTINGS()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetDefault(self):
        """GetDefault(BOARD_DESIGN_SETTINGS self) -> NETCLASSPTR"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDefault(self)


    def GetCurrentNetClassName(self):
        """GetCurrentNetClassName(BOARD_DESIGN_SETTINGS self) -> wxString const &"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentNetClassName(self)


    def UseNetClassTrack(self):
        """UseNetClassTrack(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassTrack(self)


    def UseNetClassVia(self):
        """UseNetClassVia(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassVia(self)


    def SetCurrentNetClass(self, aNetClassName):
        """SetCurrentNetClass(BOARD_DESIGN_SETTINGS self, wxString const & aNetClassName) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCurrentNetClass(self, aNetClassName)


    def GetBiggestClearanceValue(self):
        """GetBiggestClearanceValue(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetBiggestClearanceValue(self)


    def GetSmallestClearanceValue(self):
        """GetSmallestClearanceValue(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetSmallestClearanceValue(self)


    def GetCurrentMicroViaSize(self):
        """GetCurrentMicroViaSize(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentMicroViaSize(self)


    def GetCurrentMicroViaDrill(self):
        """GetCurrentMicroViaDrill(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentMicroViaDrill(self)


    def GetTrackWidthIndex(self):
        """GetTrackWidthIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTrackWidthIndex(self)


    def SetTrackWidthIndex(self, aIndex):
        """SetTrackWidthIndex(BOARD_DESIGN_SETTINGS self, unsigned int aIndex)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetTrackWidthIndex(self, aIndex)


    def GetCurrentTrackWidth(self):
        """GetCurrentTrackWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentTrackWidth(self)


    def SetCustomTrackWidth(self, aWidth):
        """SetCustomTrackWidth(BOARD_DESIGN_SETTINGS self, int aWidth)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomTrackWidth(self, aWidth)


    def GetCustomTrackWidth(self):
        """GetCustomTrackWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomTrackWidth(self)


    def GetViaSizeIndex(self):
        """GetViaSizeIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetViaSizeIndex(self)


    def SetViaSizeIndex(self, aIndex):
        """SetViaSizeIndex(BOARD_DESIGN_SETTINGS self, unsigned int aIndex)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetViaSizeIndex(self, aIndex)


    def GetCurrentViaSize(self):
        """GetCurrentViaSize(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentViaSize(self)


    def SetCustomViaSize(self, aSize):
        """SetCustomViaSize(BOARD_DESIGN_SETTINGS self, int aSize)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomViaSize(self, aSize)


    def GetCustomViaSize(self):
        """GetCustomViaSize(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomViaSize(self)


    def GetCurrentViaDrill(self):
        """GetCurrentViaDrill(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentViaDrill(self)


    def SetCustomViaDrill(self, aDrill):
        """SetCustomViaDrill(BOARD_DESIGN_SETTINGS self, int aDrill)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomViaDrill(self, aDrill)


    def GetCustomViaDrill(self):
        """GetCustomViaDrill(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomViaDrill(self)


    def UseCustomTrackViaSize(self, *args):
        """
        UseCustomTrackViaSize(BOARD_DESIGN_SETTINGS self, bool aEnabled)
        UseCustomTrackViaSize(BOARD_DESIGN_SETTINGS self) -> bool
        """
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseCustomTrackViaSize(self, *args)


    def GetVisibleLayers(self):
        """GetVisibleLayers(BOARD_DESIGN_SETTINGS self) -> LSET"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetVisibleLayers(self)


    def SetVisibleAlls(self):
        """SetVisibleAlls(BOARD_DESIGN_SETTINGS self)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetVisibleAlls(self)


    def SetVisibleLayers(self, aMask):
        """SetVisibleLayers(BOARD_DESIGN_SETTINGS self, LSET aMask)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetVisibleLayers(self, aMask)


    def IsLayerVisible(self, aLayerId):
        """IsLayerVisible(BOARD_DESIGN_SETTINGS self, LAYER_ID aLayerId) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_IsLayerVisible(self, aLayerId)


    def SetLayerVisibility(self, aLayerId, aNewState):
        """SetLayerVisibility(BOARD_DESIGN_SETTINGS self, LAYER_ID aLayerId, bool aNewState)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetLayerVisibility(self, aLayerId, aNewState)


    def GetVisibleElements(self):
        """GetVisibleElements(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetVisibleElements(self)


    def SetVisibleElements(self, aMask):
        """SetVisibleElements(BOARD_DESIGN_SETTINGS self, int aMask)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetVisibleElements(self, aMask)


    def IsElementVisible(self, aElementCategory):
        """IsElementVisible(BOARD_DESIGN_SETTINGS self, int aElementCategory) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_IsElementVisible(self, aElementCategory)


    def SetElementVisibility(self, aElementCategory, aNewState):
        """SetElementVisibility(BOARD_DESIGN_SETTINGS self, int aElementCategory, bool aNewState)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetElementVisibility(self, aElementCategory, aNewState)


    def GetEnabledLayers(self):
        """GetEnabledLayers(BOARD_DESIGN_SETTINGS self) -> LSET"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetEnabledLayers(self)


    def SetEnabledLayers(self, aMask):
        """SetEnabledLayers(BOARD_DESIGN_SETTINGS self, LSET aMask)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetEnabledLayers(self, aMask)


    def IsLayerEnabled(self, aLayerId):
        """IsLayerEnabled(BOARD_DESIGN_SETTINGS self, LAYER_ID aLayerId) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_IsLayerEnabled(self, aLayerId)


    def GetCopperLayerCount(self):
        """GetCopperLayerCount(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCopperLayerCount(self)


    def SetCopperLayerCount(self, aNewLayerCount):
        """SetCopperLayerCount(BOARD_DESIGN_SETTINGS self, int aNewLayerCount)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCopperLayerCount(self, aNewLayerCount)


    def AppendConfigs(self, aResult):
        """AppendConfigs(BOARD_DESIGN_SETTINGS self, PARAM_CFG_ARRAY * aResult)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_AppendConfigs(self, aResult)


    def GetBoardThickness(self):
        """GetBoardThickness(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetBoardThickness(self)


    def SetBoardThickness(self, aThickness):
        """SetBoardThickness(BOARD_DESIGN_SETTINGS self, int aThickness)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetBoardThickness(self, aThickness)

    __swig_destroy__ = _pcbnew.delete_BOARD_DESIGN_SETTINGS
    __del__ = lambda self: None
BOARD_DESIGN_SETTINGS_swigregister = _pcbnew.BOARD_DESIGN_SETTINGS_swigregister
BOARD_DESIGN_SETTINGS_swigregister(BOARD_DESIGN_SETTINGS)


_pcbnew.LT_UNDEFINED_swigconstant(_pcbnew)
LT_UNDEFINED = _pcbnew.LT_UNDEFINED

_pcbnew.LT_SIGNAL_swigconstant(_pcbnew)
LT_SIGNAL = _pcbnew.LT_SIGNAL

_pcbnew.LT_POWER_swigconstant(_pcbnew)
LT_POWER = _pcbnew.LT_POWER

_pcbnew.LT_MIXED_swigconstant(_pcbnew)
LT_MIXED = _pcbnew.LT_MIXED

_pcbnew.LT_JUMPER_swigconstant(_pcbnew)
LT_JUMPER = _pcbnew.LT_JUMPER
class LAYER(_object):
    """Proxy of C++ LAYER class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LAYER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LAYER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(LAYER self) -> LAYER"""
        this = _pcbnew.new_LAYER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def clear(self):
        """clear(LAYER self)"""
        return _pcbnew.LAYER_clear(self)

    __swig_setmethods__["m_name"] = _pcbnew.LAYER_m_name_set
    __swig_getmethods__["m_name"] = _pcbnew.LAYER_m_name_get
    if _newclass:
        m_name = _swig_property(_pcbnew.LAYER_m_name_get, _pcbnew.LAYER_m_name_set)
    __swig_setmethods__["m_type"] = _pcbnew.LAYER_m_type_set
    __swig_getmethods__["m_type"] = _pcbnew.LAYER_m_type_get
    if _newclass:
        m_type = _swig_property(_pcbnew.LAYER_m_type_get, _pcbnew.LAYER_m_type_set)
    __swig_setmethods__["m_visible"] = _pcbnew.LAYER_m_visible_set
    __swig_getmethods__["m_visible"] = _pcbnew.LAYER_m_visible_get
    if _newclass:
        m_visible = _swig_property(_pcbnew.LAYER_m_visible_get, _pcbnew.LAYER_m_visible_set)
    __swig_setmethods__["m_number"] = _pcbnew.LAYER_m_number_set
    __swig_getmethods__["m_number"] = _pcbnew.LAYER_m_number_get
    if _newclass:
        m_number = _swig_property(_pcbnew.LAYER_m_number_get, _pcbnew.LAYER_m_number_set)

    def ShowType(aType):
        """ShowType(LAYER_T aType) -> char const *"""
        return _pcbnew.LAYER_ShowType(aType)

    if _newclass:
        ShowType = staticmethod(ShowType)
    __swig_getmethods__["ShowType"] = lambda x: ShowType

    def ParseType(aType):
        """ParseType(char const * aType) -> LAYER_T"""
        return _pcbnew.LAYER_ParseType(aType)

    if _newclass:
        ParseType = staticmethod(ParseType)
    __swig_getmethods__["ParseType"] = lambda x: ParseType
    __swig_destroy__ = _pcbnew.delete_LAYER
    __del__ = lambda self: None
LAYER_swigregister = _pcbnew.LAYER_swigregister
LAYER_swigregister(LAYER)

def LAYER_ShowType(aType):
    """LAYER_ShowType(LAYER_T aType) -> char const *"""
    return _pcbnew.LAYER_ShowType(aType)

def LAYER_ParseType(aType):
    """LAYER_ParseType(char const * aType) -> LAYER_T"""
    return _pcbnew.LAYER_ParseType(aType)

class HIGH_LIGHT_INFO(_object):
    """Proxy of C++ HIGH_LIGHT_INFO class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HIGH_LIGHT_INFO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HIGH_LIGHT_INFO, name)

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

class BOARD(BOARD_ITEM):
    """Proxy of C++ BOARD class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BOARD, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BOARD, name)
    __repr__ = _swig_repr

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def SetFileName(self, aFileName):
        """SetFileName(BOARD self, wxString const & aFileName)"""
        return _pcbnew.BOARD_SetFileName(self, aFileName)


    def GetFileName(self):
        """GetFileName(BOARD self) -> wxString const &"""
        return _pcbnew.BOARD_GetFileName(self)

    __swig_setmethods__["m_Status_Pcb"] = _pcbnew.BOARD_m_Status_Pcb_set
    __swig_getmethods__["m_Status_Pcb"] = _pcbnew.BOARD_m_Status_Pcb_get
    if _newclass:
        m_Status_Pcb = _swig_property(_pcbnew.BOARD_m_Status_Pcb_get, _pcbnew.BOARD_m_Status_Pcb_set)
    __swig_setmethods__["m_Drawings"] = _pcbnew.BOARD_m_Drawings_set
    __swig_getmethods__["m_Drawings"] = _pcbnew.BOARD_m_Drawings_get
    if _newclass:
        m_Drawings = _swig_property(_pcbnew.BOARD_m_Drawings_get, _pcbnew.BOARD_m_Drawings_set)
    __swig_setmethods__["m_Modules"] = _pcbnew.BOARD_m_Modules_set
    __swig_getmethods__["m_Modules"] = _pcbnew.BOARD_m_Modules_get
    if _newclass:
        m_Modules = _swig_property(_pcbnew.BOARD_m_Modules_get, _pcbnew.BOARD_m_Modules_set)
    __swig_setmethods__["m_Track"] = _pcbnew.BOARD_m_Track_set
    __swig_getmethods__["m_Track"] = _pcbnew.BOARD_m_Track_get
    if _newclass:
        m_Track = _swig_property(_pcbnew.BOARD_m_Track_get, _pcbnew.BOARD_m_Track_set)
    __swig_setmethods__["m_Zone"] = _pcbnew.BOARD_m_Zone_set
    __swig_getmethods__["m_Zone"] = _pcbnew.BOARD_m_Zone_get
    if _newclass:
        m_Zone = _swig_property(_pcbnew.BOARD_m_Zone_get, _pcbnew.BOARD_m_Zone_set)
    __swig_setmethods__["m_FullRatsnest"] = _pcbnew.BOARD_m_FullRatsnest_set
    __swig_getmethods__["m_FullRatsnest"] = _pcbnew.BOARD_m_FullRatsnest_get
    if _newclass:
        m_FullRatsnest = _swig_property(_pcbnew.BOARD_m_FullRatsnest_get, _pcbnew.BOARD_m_FullRatsnest_set)
    __swig_setmethods__["m_LocalRatsnest"] = _pcbnew.BOARD_m_LocalRatsnest_set
    __swig_getmethods__["m_LocalRatsnest"] = _pcbnew.BOARD_m_LocalRatsnest_get
    if _newclass:
        m_LocalRatsnest = _swig_property(_pcbnew.BOARD_m_LocalRatsnest_get, _pcbnew.BOARD_m_LocalRatsnest_set)
    __swig_setmethods__["m_CurrentZoneContour"] = _pcbnew.BOARD_m_CurrentZoneContour_set
    __swig_getmethods__["m_CurrentZoneContour"] = _pcbnew.BOARD_m_CurrentZoneContour_get
    if _newclass:
        m_CurrentZoneContour = _swig_property(_pcbnew.BOARD_m_CurrentZoneContour_get, _pcbnew.BOARD_m_CurrentZoneContour_set)

    def __init__(self):
        """__init__(BOARD self) -> BOARD"""
        this = _pcbnew.new_BOARD()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_BOARD
    __del__ = lambda self: None

    def GetPosition(self):
        """GetPosition(BOARD self) -> wxPoint"""
        return _pcbnew.BOARD_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(BOARD self, wxPoint aPos)"""
        return _pcbnew.BOARD_SetPosition(self, aPos)


    def IsEmpty(self):
        """IsEmpty(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsEmpty(self)


    def Move(self, aMoveVector):
        """Move(BOARD self, wxPoint aMoveVector)"""
        return _pcbnew.BOARD_Move(self, aMoveVector)


    def SetFileFormatVersionAtLoad(self, aVersion):
        """SetFileFormatVersionAtLoad(BOARD self, int aVersion)"""
        return _pcbnew.BOARD_SetFileFormatVersionAtLoad(self, aVersion)


    def GetFileFormatVersionAtLoad(self):
        """GetFileFormatVersionAtLoad(BOARD self) -> int"""
        return _pcbnew.BOARD_GetFileFormatVersionAtLoad(self)


    def AddNative(self, aBoardItem, aControl=0):
        """
        AddNative(BOARD self, BOARD_ITEM aBoardItem, int aControl=0)
        AddNative(BOARD self, BOARD_ITEM aBoardItem)
        """
        return _pcbnew.BOARD_AddNative(self, aBoardItem, aControl)


    def Delete(self, aBoardItem):
        """Delete(BOARD self, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_Delete(self, aBoardItem)


    def Remove(self, aBoardItem):
        """Remove(BOARD self, BOARD_ITEM aBoardItem) -> BOARD_ITEM"""
        return _pcbnew.BOARD_Remove(self, aBoardItem)


    def DuplicateAndAddItem(self, aItem, aIncrementReferences):
        """DuplicateAndAddItem(BOARD self, BOARD_ITEM aItem, bool aIncrementReferences) -> BOARD_ITEM"""
        return _pcbnew.BOARD_DuplicateAndAddItem(self, aItem, aIncrementReferences)


    def GetNextModuleReferenceWithPrefix(self, aPrefix, aFillSequenceGaps):
        """GetNextModuleReferenceWithPrefix(BOARD self, wxString const & aPrefix, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.BOARD_GetNextModuleReferenceWithPrefix(self, aPrefix, aFillSequenceGaps)


    def GetRatsnest(self):
        """GetRatsnest(BOARD self) -> RN_DATA *"""
        return _pcbnew.BOARD_GetRatsnest(self)


    def DeleteMARKERs(self):
        """DeleteMARKERs(BOARD self)"""
        return _pcbnew.BOARD_DeleteMARKERs(self)


    def DeleteZONEOutlines(self):
        """DeleteZONEOutlines(BOARD self)"""
        return _pcbnew.BOARD_DeleteZONEOutlines(self)


    def GetMARKER(self, index):
        """GetMARKER(BOARD self, int index) -> MARKER_PCB"""
        return _pcbnew.BOARD_GetMARKER(self, index)


    def GetMARKERCount(self):
        """GetMARKERCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetMARKERCount(self)


    def SetAuxOrigin(self, aPoint):
        """SetAuxOrigin(BOARD self, wxPoint aPoint)"""
        return _pcbnew.BOARD_SetAuxOrigin(self, aPoint)


    def GetAuxOrigin(self):
        """GetAuxOrigin(BOARD self) -> wxPoint"""
        return _pcbnew.BOARD_GetAuxOrigin(self)


    def SetGridOrigin(self, aPoint):
        """SetGridOrigin(BOARD self, wxPoint aPoint)"""
        return _pcbnew.BOARD_SetGridOrigin(self, aPoint)


    def GetGridOrigin(self):
        """GetGridOrigin(BOARD self) -> wxPoint"""
        return _pcbnew.BOARD_GetGridOrigin(self)


    def ResetHighLight(self):
        """ResetHighLight(BOARD self)"""
        return _pcbnew.BOARD_ResetHighLight(self)


    def GetHighLightNetCode(self):
        """GetHighLightNetCode(BOARD self) -> int"""
        return _pcbnew.BOARD_GetHighLightNetCode(self)


    def SetHighLightNet(self, aNetCode):
        """SetHighLightNet(BOARD self, int aNetCode)"""
        return _pcbnew.BOARD_SetHighLightNet(self, aNetCode)


    def IsHighLightNetON(self):
        """IsHighLightNetON(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsHighLightNetON(self)


    def HighLightOFF(self):
        """HighLightOFF(BOARD self)"""
        return _pcbnew.BOARD_HighLightOFF(self)


    def HighLightON(self):
        """HighLightON(BOARD self)"""
        return _pcbnew.BOARD_HighLightON(self)


    def PushHighLight(self):
        """PushHighLight(BOARD self)"""
        return _pcbnew.BOARD_PushHighLight(self)


    def PopHighLight(self):
        """PopHighLight(BOARD self)"""
        return _pcbnew.BOARD_PopHighLight(self)


    def GetCopperLayerCount(self):
        """GetCopperLayerCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetCopperLayerCount(self)


    def SetCopperLayerCount(self, aCount):
        """SetCopperLayerCount(BOARD self, int aCount)"""
        return _pcbnew.BOARD_SetCopperLayerCount(self, aCount)


    def GetEnabledLayers(self):
        """GetEnabledLayers(BOARD self) -> LSET"""
        return _pcbnew.BOARD_GetEnabledLayers(self)


    def SetEnabledLayers(self, aLayerMask):
        """SetEnabledLayers(BOARD self, LSET aLayerMask)"""
        return _pcbnew.BOARD_SetEnabledLayers(self, aLayerMask)


    def IsLayerEnabled(self, aLayer):
        """IsLayerEnabled(BOARD self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsLayerEnabled(self, aLayer)


    def IsLayerVisible(self, aLayer):
        """IsLayerVisible(BOARD self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsLayerVisible(self, aLayer)


    def GetVisibleLayers(self):
        """GetVisibleLayers(BOARD self) -> LSET"""
        return _pcbnew.BOARD_GetVisibleLayers(self)


    def SetVisibleLayers(self, aLayerMask):
        """SetVisibleLayers(BOARD self, LSET aLayerMask)"""
        return _pcbnew.BOARD_SetVisibleLayers(self, aLayerMask)


    def GetVisibleElements(self):
        """GetVisibleElements(BOARD self) -> int"""
        return _pcbnew.BOARD_GetVisibleElements(self)


    def SetVisibleElements(self, aMask):
        """SetVisibleElements(BOARD self, int aMask)"""
        return _pcbnew.BOARD_SetVisibleElements(self, aMask)


    def SetVisibleAlls(self):
        """SetVisibleAlls(BOARD self)"""
        return _pcbnew.BOARD_SetVisibleAlls(self)


    def IsElementVisible(self, aPCB_VISIBLE):
        """IsElementVisible(BOARD self, int aPCB_VISIBLE) -> bool"""
        return _pcbnew.BOARD_IsElementVisible(self, aPCB_VISIBLE)


    def SetElementVisibility(self, aPCB_VISIBLE, aNewState):
        """SetElementVisibility(BOARD self, int aPCB_VISIBLE, bool aNewState)"""
        return _pcbnew.BOARD_SetElementVisibility(self, aPCB_VISIBLE, aNewState)


    def IsModuleLayerVisible(self, layer):
        """IsModuleLayerVisible(BOARD self, LAYER_ID layer) -> bool"""
        return _pcbnew.BOARD_IsModuleLayerVisible(self, layer)


    def GetVisibleElementColor(self, aPCB_VISIBLE):
        """GetVisibleElementColor(BOARD self, int aPCB_VISIBLE) -> EDA_COLOR_T"""
        return _pcbnew.BOARD_GetVisibleElementColor(self, aPCB_VISIBLE)


    def SetVisibleElementColor(self, aPCB_VISIBLE, aColor):
        """SetVisibleElementColor(BOARD self, int aPCB_VISIBLE, EDA_COLOR_T aColor)"""
        return _pcbnew.BOARD_SetVisibleElementColor(self, aPCB_VISIBLE, aColor)


    def GetDesignSettings(self):
        """GetDesignSettings(BOARD self) -> BOARD_DESIGN_SETTINGS"""
        return _pcbnew.BOARD_GetDesignSettings(self)


    def SetDesignSettings(self, aDesignSettings):
        """SetDesignSettings(BOARD self, BOARD_DESIGN_SETTINGS aDesignSettings)"""
        return _pcbnew.BOARD_SetDesignSettings(self, aDesignSettings)


    def GetPageSettings(self):
        """GetPageSettings(BOARD self) -> PAGE_INFO const &"""
        return _pcbnew.BOARD_GetPageSettings(self)


    def SetPageSettings(self, aPageSettings):
        """SetPageSettings(BOARD self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.BOARD_SetPageSettings(self, aPageSettings)


    def GetPlotOptions(self):
        """GetPlotOptions(BOARD self) -> PCB_PLOT_PARAMS"""
        return _pcbnew.BOARD_GetPlotOptions(self)


    def SetPlotOptions(self, aOptions):
        """SetPlotOptions(BOARD self, PCB_PLOT_PARAMS aOptions)"""
        return _pcbnew.BOARD_SetPlotOptions(self, aOptions)


    def GetTitleBlock(self):
        """GetTitleBlock(BOARD self) -> TITLE_BLOCK"""
        return _pcbnew.BOARD_GetTitleBlock(self)


    def SetTitleBlock(self, aTitleBlock):
        """SetTitleBlock(BOARD self, TITLE_BLOCK aTitleBlock)"""
        return _pcbnew.BOARD_SetTitleBlock(self, aTitleBlock)


    def GetZoneSettings(self):
        """GetZoneSettings(BOARD self) -> ZONE_SETTINGS"""
        return _pcbnew.BOARD_GetZoneSettings(self)


    def SetZoneSettings(self, aSettings):
        """SetZoneSettings(BOARD self, ZONE_SETTINGS aSettings)"""
        return _pcbnew.BOARD_SetZoneSettings(self, aSettings)


    def GetColorsSettings(self):
        """GetColorsSettings(BOARD self) -> COLORS_DESIGN_SETTINGS"""
        return _pcbnew.BOARD_GetColorsSettings(self)


    def SetColorsSettings(self, aColorsSettings):
        """SetColorsSettings(BOARD self, COLORS_DESIGN_SETTINGS aColorsSettings)"""
        return _pcbnew.BOARD_SetColorsSettings(self, aColorsSettings)


    def GetBoardPolygonOutlines(self, aOutlines, aHoles, aErrorText=None):
        """
        GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET & aOutlines, SHAPE_POLY_SET & aHoles, wxString * aErrorText=None) -> bool
        GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET & aOutlines, SHAPE_POLY_SET & aHoles) -> bool
        """
        return _pcbnew.BOARD_GetBoardPolygonOutlines(self, aOutlines, aHoles, aErrorText)


    def ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines):
        """ConvertBrdLayerToPolygonalContours(BOARD self, LAYER_ID aLayer, SHAPE_POLY_SET & aOutlines)"""
        return _pcbnew.BOARD_ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines)


    def GetLayerID(self, aLayerName):
        """GetLayerID(BOARD self, wxString const & aLayerName) -> LAYER_ID const"""
        return _pcbnew.BOARD_GetLayerID(self, aLayerName)


    def GetLayerName(self, aLayer):
        """GetLayerName(BOARD self, LAYER_ID aLayer) -> wxString const"""
        return _pcbnew.BOARD_GetLayerName(self, aLayer)


    def SetLayerName(self, aLayer, aLayerName):
        """SetLayerName(BOARD self, LAYER_ID aLayer, wxString const & aLayerName) -> bool"""
        return _pcbnew.BOARD_SetLayerName(self, aLayer, aLayerName)


    def GetStandardLayerName(aLayerId):
        """GetStandardLayerName(LAYER_ID aLayerId) -> wxString const"""
        return _pcbnew.BOARD_GetStandardLayerName(aLayerId)

    if _newclass:
        GetStandardLayerName = staticmethod(GetStandardLayerName)
    __swig_getmethods__["GetStandardLayerName"] = lambda x: GetStandardLayerName

    def SetLayerDescr(self, aIndex, aLayer):
        """SetLayerDescr(BOARD self, LAYER_ID aIndex, LAYER aLayer) -> bool"""
        return _pcbnew.BOARD_SetLayerDescr(self, aIndex, aLayer)


    def GetLayerType(self, aLayer):
        """GetLayerType(BOARD self, LAYER_ID aLayer) -> LAYER_T"""
        return _pcbnew.BOARD_GetLayerType(self, aLayer)


    def SetLayerType(self, aLayer, aLayerType):
        """SetLayerType(BOARD self, LAYER_ID aLayer, LAYER_T aLayerType) -> bool"""
        return _pcbnew.BOARD_SetLayerType(self, aLayer, aLayerType)


    def SetLayerColor(self, aLayer, aColor):
        """SetLayerColor(BOARD self, LAYER_ID aLayer, EDA_COLOR_T aColor)"""
        return _pcbnew.BOARD_SetLayerColor(self, aLayer, aColor)


    def GetLayerColor(self, aLayer):
        """GetLayerColor(BOARD self, LAYER_ID aLayer) -> EDA_COLOR_T"""
        return _pcbnew.BOARD_GetLayerColor(self, aLayer)


    def GetNumSegmTrack(self):
        """GetNumSegmTrack(BOARD self) -> int"""
        return _pcbnew.BOARD_GetNumSegmTrack(self)


    def GetNumSegmZone(self):
        """GetNumSegmZone(BOARD self) -> int"""
        return _pcbnew.BOARD_GetNumSegmZone(self)


    def GetRatsnestsCount(self):
        """GetRatsnestsCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetRatsnestsCount(self)


    def GetNodesCount(self):
        """GetNodesCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetNodesCount(self)


    def SetNodeCount(self, aCount):
        """SetNodeCount(BOARD self, unsigned int aCount)"""
        return _pcbnew.BOARD_SetNodeCount(self, aCount)


    def GetUnconnectedNetCount(self):
        """GetUnconnectedNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetUnconnectedNetCount(self)


    def SetUnconnectedNetCount(self, aCount):
        """SetUnconnectedNetCount(BOARD self, unsigned int aCount)"""
        return _pcbnew.BOARD_SetUnconnectedNetCount(self, aCount)


    def GetPadCount(self):
        """GetPadCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetPadCount(self)


    def GetPads(self):
        """GetPads(BOARD self) -> std::vector< D_PAD *,std::allocator< D_PAD * > >"""
        return _pcbnew.BOARD_GetPads(self)


    def BuildListOfNets(self):
        """BuildListOfNets(BOARD self)"""
        return _pcbnew.BOARD_BuildListOfNets(self)


    def FindNet(self, *args):
        """
        FindNet(BOARD self, int aNetcode) -> NETINFO_ITEM
        FindNet(BOARD self, wxString const & aNetname) -> NETINFO_ITEM
        """
        return _pcbnew.BOARD_FindNet(self, *args)


    def AppendNet(self, aNewNet):
        """AppendNet(BOARD self, NETINFO_ITEM aNewNet)"""
        return _pcbnew.BOARD_AppendNet(self, aNewNet)


    def GetNetCount(self):
        """GetNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetNetCount(self)


    def ComputeBoundingBox(self, aBoardEdgesOnly=False):
        """
        ComputeBoundingBox(BOARD self, bool aBoardEdgesOnly=False) -> EDA_RECT
        ComputeBoundingBox(BOARD self) -> EDA_RECT
        """
        return _pcbnew.BOARD_ComputeBoundingBox(self, aBoardEdgesOnly)


    def GetBoundingBox(self):
        """GetBoundingBox(BOARD self) -> EDA_RECT"""
        return _pcbnew.BOARD_GetBoundingBox(self)


    def SetBoundingBox(self, aBox):
        """SetBoundingBox(BOARD self, EDA_RECT aBox)"""
        return _pcbnew.BOARD_SetBoundingBox(self, aBox)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(BOARD self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.BOARD_GetMsgPanelInfo(self, aList)


    def Draw(self, *args):
        """
        Draw(BOARD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(BOARD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.BOARD_Draw(self, *args)


    def DrawHighLight(self, aDrawPanel, aDC, aNetCode):
        """DrawHighLight(BOARD self, EDA_DRAW_PANEL * aDrawPanel, wxDC * aDC, int aNetCode)"""
        return _pcbnew.BOARD_DrawHighLight(self, aDrawPanel, aDC, aNetCode)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(BOARD self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.BOARD_Visit(self, inspector, testData, scanTypes)


    def FindModuleByReference(self, aReference):
        """FindModuleByReference(BOARD self, wxString const & aReference) -> MODULE"""
        return _pcbnew.BOARD_FindModuleByReference(self, aReference)


    def FindModule(self, aRefOrTimeStamp, aSearchByTimeStamp=False):
        """
        FindModule(BOARD self, wxString const & aRefOrTimeStamp, bool aSearchByTimeStamp=False) -> MODULE
        FindModule(BOARD self, wxString const & aRefOrTimeStamp) -> MODULE
        """
        return _pcbnew.BOARD_FindModule(self, aRefOrTimeStamp, aSearchByTimeStamp)


    def ReplaceNetlist(self, aNetlist, aDeleteSinglePadNets, aReporter=None):
        """
        ReplaceNetlist(BOARD self, NETLIST & aNetlist, bool aDeleteSinglePadNets, REPORTER * aReporter=None)
        ReplaceNetlist(BOARD self, NETLIST & aNetlist, bool aDeleteSinglePadNets)
        """
        return _pcbnew.BOARD_ReplaceNetlist(self, aNetlist, aDeleteSinglePadNets, aReporter)


    def SortedNetnamesList(self, aNames, aSortbyPadsCount):
        """SortedNetnamesList(BOARD self, wxArrayString & aNames, bool aSortbyPadsCount) -> int"""
        return _pcbnew.BOARD_SortedNetnamesList(self, aNames, aSortbyPadsCount)


    def SynchronizeNetsAndNetClasses(self):
        """SynchronizeNetsAndNetClasses(BOARD self)"""
        return _pcbnew.BOARD_SynchronizeNetsAndNetClasses(self)


    def GetClass(self):
        """GetClass(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetClass(self)


    def HitTestForAnyFilledArea(self, aRefPos, aStartLayer, aEndLayer, aNetCode):
        """HitTestForAnyFilledArea(BOARD self, wxPoint aRefPos, LAYER_ID aStartLayer, LAYER_ID aEndLayer, int aNetCode) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_HitTestForAnyFilledArea(self, aRefPos, aStartLayer, aEndLayer, aNetCode)


    def RedrawAreasOutlines(self, aPanel, aDC, aDrawMode, aLayer):
        """RedrawAreasOutlines(BOARD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, LAYER_ID aLayer)"""
        return _pcbnew.BOARD_RedrawAreasOutlines(self, aPanel, aDC, aDrawMode, aLayer)


    def RedrawFilledAreas(self, aPanel, aDC, aDrawMode, aLayer):
        """RedrawFilledAreas(BOARD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, LAYER_ID aLayer)"""
        return _pcbnew.BOARD_RedrawFilledAreas(self, aPanel, aDC, aDrawMode, aLayer)


    def SetAreasNetCodesFromNetNames(self):
        """SetAreasNetCodesFromNetNames(BOARD self) -> int"""
        return _pcbnew.BOARD_SetAreasNetCodesFromNetNames(self)


    def GetArea(self, index):
        """GetArea(BOARD self, int index) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_GetArea(self, index)


    def GetAreaIndex(self, aArea):
        """GetAreaIndex(BOARD self, ZONE_CONTAINER aArea) -> int"""
        return _pcbnew.BOARD_GetAreaIndex(self, aArea)


    def GetAreaCount(self):
        """GetAreaCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetAreaCount(self)


    def AddArea(self, aNewZonesList, aNetcode, aLayer, aStartPointPosition, aHatch):
        """AddArea(BOARD self, PICKED_ITEMS_LIST * aNewZonesList, int aNetcode, LAYER_ID aLayer, wxPoint aStartPointPosition, int aHatch) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_AddArea(self, aNewZonesList, aNetcode, aLayer, aStartPointPosition, aHatch)


    def InsertArea(self, netcode, iarea, layer, x, y, hatch):
        """InsertArea(BOARD self, int netcode, int iarea, LAYER_ID layer, int x, int y, int hatch) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_InsertArea(self, netcode, iarea, layer, x, y, hatch)


    def NormalizeAreaPolygon(self, aNewZonesList, aCurrArea):
        """NormalizeAreaPolygon(BOARD self, PICKED_ITEMS_LIST * aNewZonesList, ZONE_CONTAINER aCurrArea) -> bool"""
        return _pcbnew.BOARD_NormalizeAreaPolygon(self, aNewZonesList, aCurrArea)


    def OnAreaPolygonModified(self, aModifiedZonesList, modified_area):
        """OnAreaPolygonModified(BOARD self, PICKED_ITEMS_LIST * aModifiedZonesList, ZONE_CONTAINER modified_area) -> bool"""
        return _pcbnew.BOARD_OnAreaPolygonModified(self, aModifiedZonesList, modified_area)


    def CombineAllAreasInNet(self, aDeletedList, aNetCode, aUseLocalFlags):
        """CombineAllAreasInNet(BOARD self, PICKED_ITEMS_LIST * aDeletedList, int aNetCode, bool aUseLocalFlags) -> bool"""
        return _pcbnew.BOARD_CombineAllAreasInNet(self, aDeletedList, aNetCode, aUseLocalFlags)


    def RemoveArea(self, aDeletedList, area_to_remove):
        """RemoveArea(BOARD self, PICKED_ITEMS_LIST * aDeletedList, ZONE_CONTAINER area_to_remove)"""
        return _pcbnew.BOARD_RemoveArea(self, aDeletedList, area_to_remove)


    def TestAreaIntersections(self, area_to_test):
        """TestAreaIntersections(BOARD self, ZONE_CONTAINER area_to_test) -> bool"""
        return _pcbnew.BOARD_TestAreaIntersections(self, area_to_test)


    def TestAreaIntersection(self, area_ref, area_to_test):
        """TestAreaIntersection(BOARD self, ZONE_CONTAINER area_ref, ZONE_CONTAINER area_to_test) -> bool"""
        return _pcbnew.BOARD_TestAreaIntersection(self, area_ref, area_to_test)


    def CombineAreas(self, aDeletedList, area_ref, area_to_combine):
        """CombineAreas(BOARD self, PICKED_ITEMS_LIST * aDeletedList, ZONE_CONTAINER area_ref, ZONE_CONTAINER area_to_combine) -> bool"""
        return _pcbnew.BOARD_CombineAreas(self, aDeletedList, area_ref, area_to_combine)


    def Test_Drc_Areas_Outlines_To_Areas_Outlines(self, aArea_To_Examine, aCreate_Markers):
        """Test_Drc_Areas_Outlines_To_Areas_Outlines(BOARD self, ZONE_CONTAINER aArea_To_Examine, bool aCreate_Markers) -> int"""
        return _pcbnew.BOARD_Test_Drc_Areas_Outlines_To_Areas_Outlines(self, aArea_To_Examine, aCreate_Markers)


    def Test_Connections_To_Copper_Areas(self, aNetcode=-1):
        """
        Test_Connections_To_Copper_Areas(BOARD self, int aNetcode=-1)
        Test_Connections_To_Copper_Areas(BOARD self)
        """
        return _pcbnew.BOARD_Test_Connections_To_Copper_Areas(self, aNetcode)


    def GetViaByPosition(self, *args):
        """
        GetViaByPosition(BOARD self, wxPoint aPosition, LAYER_ID aLayer) -> VIA
        GetViaByPosition(BOARD self, wxPoint aPosition) -> VIA
        """
        return _pcbnew.BOARD_GetViaByPosition(self, *args)


    def GetPadFast(self, aPosition, aLayerMask):
        """GetPadFast(BOARD self, wxPoint aPosition, LSET aLayerMask) -> D_PAD"""
        return _pcbnew.BOARD_GetPadFast(self, aPosition, aLayerMask)


    def GetPad(self, *args):
        """
        GetPad(BOARD self, unsigned int aIndex) -> D_PAD
        GetPad(BOARD self, wxPoint aPosition, LSET aLayerMask) -> D_PAD
        GetPad(BOARD self, wxPoint aPosition) -> D_PAD
        GetPad(BOARD self, TRACK aTrace, ENDPOINT_T aEndPoint) -> D_PAD
        GetPad(BOARD self, std::vector< D_PAD *,std::allocator< D_PAD * > > & aPadList, wxPoint aPosition, LSET aLayerMask) -> D_PAD
        """
        return _pcbnew.BOARD_GetPad(self, *args)


    def GetSortedPadListByXthenYCoord(self, aVector, aNetCode=-1):
        """
        GetSortedPadListByXthenYCoord(BOARD self, std::vector< D_PAD *,std::allocator< D_PAD * > > & aVector, int aNetCode=-1)
        GetSortedPadListByXthenYCoord(BOARD self, std::vector< D_PAD *,std::allocator< D_PAD * > > & aVector)
        """
        return _pcbnew.BOARD_GetSortedPadListByXthenYCoord(self, aVector, aNetCode)


    def GetTrack(self, aTrace, aPosition, aLayerMask):
        """GetTrack(BOARD self, TRACK aTrace, wxPoint aPosition, LSET aLayerMask) -> TRACK"""
        return _pcbnew.BOARD_GetTrack(self, aTrace, aPosition, aLayerMask)


    def MarkTrace(self, aTrace, aCount, aTraceLength, aInPackageLength, aReorder):
        """MarkTrace(BOARD self, TRACK aTrace, int * aCount, double * aTraceLength, double * aInPackageLength, bool aReorder) -> TRACK"""
        return _pcbnew.BOARD_MarkTrace(self, aTrace, aCount, aTraceLength, aInPackageLength, aReorder)


    def GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked=False):
        """
        GetFootprint(BOARD self, wxPoint aPosition, LAYER_ID aActiveLayer, bool aVisibleOnly, bool aIgnoreLocked=False) -> MODULE
        GetFootprint(BOARD self, wxPoint aPosition, LAYER_ID aActiveLayer, bool aVisibleOnly) -> MODULE
        """
        return _pcbnew.BOARD_GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked)


    def GetLockPoint(self, aPosition, aLayerMask):
        """GetLockPoint(BOARD self, wxPoint aPosition, LSET aLayerMask) -> BOARD_CONNECTED_ITEM"""
        return _pcbnew.BOARD_GetLockPoint(self, aPosition, aLayerMask)


    def CreateLockPoint(self, aPosition, aSegment, aList):
        """CreateLockPoint(BOARD self, wxPoint aPosition, TRACK aSegment, PICKED_ITEMS_LIST * aList) -> TRACK"""
        return _pcbnew.BOARD_CreateLockPoint(self, aPosition, aSegment, aList)


    def GetModules(self):             return self.m_Modules
    def GetDrawings(self):            return self.m_Drawings
    def GetTracks(self):              return self.m_Track
    def GetFullRatsnest(self):        return self.m_FullRatsnest

    def Save(self,filename):
        return SaveBoard(filename,self,IO_MGR.KICAD)

    #
    # add function, clears the thisown to avoid python from deleting
    # the object in the garbage collector
    #

    def Add(self,item):
        item.thisown=0
        self.AddNative(item)


    def GetNetClasses(self):
        return self.GetDesignSettings().m_NetClasses

    def GetCurrentNetClassName(self):
        return self.GetDesignSettings().m_CurrentNetClassName

    def GetViasDimensionsList(self):
        return self.GetDesignSettings().m_ViasDimensionsList

    def GetTrackWidthList(self):
        return self.GetDesignSettings().m_TrackWidthList

BOARD_swigregister = _pcbnew.BOARD_swigregister
BOARD_swigregister(BOARD)

def BOARD_ClassOf(aItem):
    """BOARD_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.BOARD_ClassOf(aItem)

_pcbnew.ADD_APPEND_swigconstant(_pcbnew)
ADD_APPEND = _pcbnew.ADD_APPEND

def BOARD_GetStandardLayerName(aLayerId):
    """BOARD_GetStandardLayerName(LAYER_ID aLayerId) -> wxString const"""
    return _pcbnew.BOARD_GetStandardLayerName(aLayerId)


_pcbnew.DO_NOT_INCLUDE_NPTH_swigconstant(_pcbnew)
DO_NOT_INCLUDE_NPTH = _pcbnew.DO_NOT_INCLUDE_NPTH

_pcbnew.INCLUDE_NPTH_swigconstant(_pcbnew)
INCLUDE_NPTH = _pcbnew.INCLUDE_NPTH

_pcbnew.MOD_DEFAULT_swigconstant(_pcbnew)
MOD_DEFAULT = _pcbnew.MOD_DEFAULT

_pcbnew.MOD_CMS_swigconstant(_pcbnew)
MOD_CMS = _pcbnew.MOD_CMS

_pcbnew.MOD_VIRTUAL_swigconstant(_pcbnew)
MOD_VIRTUAL = _pcbnew.MOD_VIRTUAL
class MODULE(BOARD_ITEM):
    """Proxy of C++ MODULE class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MODULE, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MODULE, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MODULE self, BOARD parent) -> MODULE
        __init__(MODULE self, MODULE aModule) -> MODULE
        """
        this = _pcbnew.new_MODULE(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MODULE
    __del__ = lambda self: None

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.MODULE_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def Next(self):
        """Next(MODULE self) -> MODULE"""
        return _pcbnew.MODULE_Next(self)


    def Back(self):
        """Back(MODULE self) -> MODULE"""
        return _pcbnew.MODULE_Back(self)


    def Copy(self, Module):
        """Copy(MODULE self, MODULE Module)"""
        return _pcbnew.MODULE_Copy(self, Module)


    def AddChild(self, aBoardItem, doAppend=True):
        """
        AddChild(MODULE self, BOARD_ITEM aBoardItem, bool doAppend=True)
        AddChild(MODULE self, BOARD_ITEM aBoardItem)
        """
        return _pcbnew.MODULE_AddChild(self, aBoardItem, doAppend)


    def DeleteChild(self, aBoardItem):
        """DeleteChild(MODULE self, BOARD_ITEM aBoardItem)"""
        return _pcbnew.MODULE_DeleteChild(self, aBoardItem)


    def RemoveChild(self, aBoardItem):
        """RemoveChild(MODULE self, BOARD_ITEM aBoardItem) -> BOARD_ITEM"""
        return _pcbnew.MODULE_RemoveChild(self, aBoardItem)


    def ClearAllNets(self):
        """ClearAllNets(MODULE self)"""
        return _pcbnew.MODULE_ClearAllNets(self)


    def CalculateBoundingBox(self):
        """CalculateBoundingBox(MODULE self)"""
        return _pcbnew.MODULE_CalculateBoundingBox(self)


    def GetFootprintRect(self):
        """GetFootprintRect(MODULE self) -> EDA_RECT"""
        return _pcbnew.MODULE_GetFootprintRect(self)


    def GetBoundingBox(self):
        """GetBoundingBox(MODULE self) -> EDA_RECT"""
        return _pcbnew.MODULE_GetBoundingBox(self)


    def Pads(self, *args):
        """
        Pads(MODULE self) -> PAD_List
        Pads(MODULE self) -> PAD_List
        """
        return _pcbnew.MODULE_Pads(self, *args)


    def GraphicalItems(self, *args):
        """
        GraphicalItems(MODULE self) -> BOARD_ITEM_List
        GraphicalItems(MODULE self) -> BOARD_ITEM_List
        """
        return _pcbnew.MODULE_GraphicalItems(self, *args)


    def Models(self, *args):
        """
        Models(MODULE self) -> DLIST< S3D_MASTER >
        Models(MODULE self) -> DLIST< S3D_MASTER > const &
        """
        return _pcbnew.MODULE_Models(self, *args)


    def SetPosition(self, aPos):
        """SetPosition(MODULE self, wxPoint aPos)"""
        return _pcbnew.MODULE_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(MODULE self) -> wxPoint"""
        return _pcbnew.MODULE_GetPosition(self)


    def SetOrientation(self, newangle):
        """SetOrientation(MODULE self, double newangle)"""
        return _pcbnew.MODULE_SetOrientation(self, newangle)


    def GetOrientation(self):
        """GetOrientation(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientation(self)


    def GetFPID(self):
        """GetFPID(MODULE self) -> FPID"""
        return _pcbnew.MODULE_GetFPID(self)


    def SetFPID(self, aFPID):
        """SetFPID(MODULE self, FPID aFPID)"""
        return _pcbnew.MODULE_SetFPID(self, aFPID)


    def GetDescription(self):
        """GetDescription(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetDescription(self)


    def SetDescription(self, aDoc):
        """SetDescription(MODULE self, wxString const & aDoc)"""
        return _pcbnew.MODULE_SetDescription(self, aDoc)


    def GetKeywords(self):
        """GetKeywords(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetKeywords(self)


    def SetKeywords(self, aKeywords):
        """SetKeywords(MODULE self, wxString const & aKeywords)"""
        return _pcbnew.MODULE_SetKeywords(self, aKeywords)


    def GetPath(self):
        """GetPath(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetPath(self)


    def SetPath(self, aPath):
        """SetPath(MODULE self, wxString const & aPath)"""
        return _pcbnew.MODULE_SetPath(self, aPath)


    def GetLocalSolderMaskMargin(self):
        """GetLocalSolderMaskMargin(MODULE self) -> int"""
        return _pcbnew.MODULE_GetLocalSolderMaskMargin(self)


    def SetLocalSolderMaskMargin(self, aMargin):
        """SetLocalSolderMaskMargin(MODULE self, int aMargin)"""
        return _pcbnew.MODULE_SetLocalSolderMaskMargin(self, aMargin)


    def GetLocalClearance(self):
        """GetLocalClearance(MODULE self) -> int"""
        return _pcbnew.MODULE_GetLocalClearance(self)


    def SetLocalClearance(self, aClearance):
        """SetLocalClearance(MODULE self, int aClearance)"""
        return _pcbnew.MODULE_SetLocalClearance(self, aClearance)


    def GetLocalSolderPasteMargin(self):
        """GetLocalSolderPasteMargin(MODULE self) -> int"""
        return _pcbnew.MODULE_GetLocalSolderPasteMargin(self)


    def SetLocalSolderPasteMargin(self, aMargin):
        """SetLocalSolderPasteMargin(MODULE self, int aMargin)"""
        return _pcbnew.MODULE_SetLocalSolderPasteMargin(self, aMargin)


    def GetLocalSolderPasteMarginRatio(self):
        """GetLocalSolderPasteMarginRatio(MODULE self) -> double"""
        return _pcbnew.MODULE_GetLocalSolderPasteMarginRatio(self)


    def SetLocalSolderPasteMarginRatio(self, aRatio):
        """SetLocalSolderPasteMarginRatio(MODULE self, double aRatio)"""
        return _pcbnew.MODULE_SetLocalSolderPasteMarginRatio(self, aRatio)


    def SetZoneConnection(self, aType):
        """SetZoneConnection(MODULE self, ZoneConnection aType)"""
        return _pcbnew.MODULE_SetZoneConnection(self, aType)


    def GetZoneConnection(self):
        """GetZoneConnection(MODULE self) -> ZoneConnection"""
        return _pcbnew.MODULE_GetZoneConnection(self)


    def SetThermalWidth(self, aWidth):
        """SetThermalWidth(MODULE self, int aWidth)"""
        return _pcbnew.MODULE_SetThermalWidth(self, aWidth)


    def GetThermalWidth(self):
        """GetThermalWidth(MODULE self) -> int"""
        return _pcbnew.MODULE_GetThermalWidth(self)


    def SetThermalGap(self, aGap):
        """SetThermalGap(MODULE self, int aGap)"""
        return _pcbnew.MODULE_SetThermalGap(self, aGap)


    def GetThermalGap(self):
        """GetThermalGap(MODULE self) -> int"""
        return _pcbnew.MODULE_GetThermalGap(self)


    def GetAttributes(self):
        """GetAttributes(MODULE self) -> int"""
        return _pcbnew.MODULE_GetAttributes(self)


    def SetAttributes(self, aAttributes):
        """SetAttributes(MODULE self, int aAttributes)"""
        return _pcbnew.MODULE_SetAttributes(self, aAttributes)


    def SetFlag(self, aFlag):
        """SetFlag(MODULE self, int aFlag)"""
        return _pcbnew.MODULE_SetFlag(self, aFlag)


    def IncrementFlag(self):
        """IncrementFlag(MODULE self)"""
        return _pcbnew.MODULE_IncrementFlag(self)


    def GetFlag(self):
        """GetFlag(MODULE self) -> int"""
        return _pcbnew.MODULE_GetFlag(self)


    def Move(self, aMoveVector):
        """Move(MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(MODULE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MODULE_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(MODULE self, wxPoint aCentre)"""
        return _pcbnew.MODULE_Flip(self, aCentre)


    def MoveAnchorPosition(self, aMoveVector):
        """MoveAnchorPosition(MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_MoveAnchorPosition(self, aMoveVector)


    def IsFlipped(self):
        """IsFlipped(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsFlipped(self)


    def IsLocked(self):
        """IsLocked(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsLocked(self)


    def SetLocked(self, isLocked):
        """SetLocked(MODULE self, bool isLocked)"""
        return _pcbnew.MODULE_SetLocked(self, isLocked)


    def IsPlaced(self):
        """IsPlaced(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsPlaced(self)


    def SetIsPlaced(self, isPlaced):
        """SetIsPlaced(MODULE self, bool isPlaced)"""
        return _pcbnew.MODULE_SetIsPlaced(self, isPlaced)


    def NeedsPlaced(self):
        """NeedsPlaced(MODULE self) -> bool"""
        return _pcbnew.MODULE_NeedsPlaced(self)


    def SetNeedsPlaced(self, needsPlaced):
        """SetNeedsPlaced(MODULE self, bool needsPlaced)"""
        return _pcbnew.MODULE_SetNeedsPlaced(self, needsPlaced)


    def PadsLocked(self):
        """PadsLocked(MODULE self) -> bool"""
        return _pcbnew.MODULE_PadsLocked(self)


    def SetPadsLocked(self, aPadsLocked):
        """SetPadsLocked(MODULE self, bool aPadsLocked)"""
        return _pcbnew.MODULE_SetPadsLocked(self, aPadsLocked)


    def SetLastEditTime(self, *args):
        """
        SetLastEditTime(MODULE self, time_t aTime)
        SetLastEditTime(MODULE self)
        """
        return _pcbnew.MODULE_SetLastEditTime(self, *args)


    def GetLastEditTime(self):
        """GetLastEditTime(MODULE self) -> time_t"""
        return _pcbnew.MODULE_GetLastEditTime(self)


    def Draw(self, *args):
        """
        Draw(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.MODULE_Draw(self, *args)


    def DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector):
        """DrawOutlinesWhenMoving(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector)


    def TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper=False):
        """
        TransformPadsShapesWithClearanceToPolygon(MODULE self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)
        TransformPadsShapesWithClearanceToPolygon(MODULE self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper)


    def TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformGraphicShapesWithClearanceToPolygonSet(MODULE self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.MODULE_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor)


    def DrawEdgesOnly(self, panel, DC, offset, draw_mode):
        """DrawEdgesOnly(MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, wxPoint offset, GR_DRAWMODE draw_mode)"""
        return _pcbnew.MODULE_DrawEdgesOnly(self, panel, DC, offset, draw_mode)


    def DrawAncre(self, panel, DC, offset, dim_ancre, draw_mode):
        """DrawAncre(MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, wxPoint offset, int dim_ancre, GR_DRAWMODE draw_mode)"""
        return _pcbnew.MODULE_DrawAncre(self, panel, DC, offset, dim_ancre, draw_mode)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(MODULE self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MODULE_GetMsgPanelInfo(self, aList)


    def HitTest(self, *args):
        """
        HitTest(MODULE self, wxPoint aPosition) -> bool
        HitTest(MODULE self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(MODULE self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(MODULE self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.MODULE_HitTest(self, *args)


    def GetReference(self):
        """GetReference(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetReference(self)


    def SetReference(self, aReference):
        """SetReference(MODULE self, wxString const & aReference)"""
        return _pcbnew.MODULE_SetReference(self, aReference)


    def GetReferencePrefix(self):
        """GetReferencePrefix(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetReferencePrefix(self)


    def GetValue(self):
        """GetValue(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetValue(self)


    def SetValue(self, aValue):
        """SetValue(MODULE self, wxString const & aValue)"""
        return _pcbnew.MODULE_SetValue(self, aValue)


    def Value(self, *args):
        """
        Value(MODULE self) -> TEXTE_MODULE
        Value(MODULE self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_Value(self, *args)


    def Reference(self, *args):
        """
        Reference(MODULE self) -> TEXTE_MODULE
        Reference(MODULE self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_Reference(self, *args)


    def IncrementItemReference(self):
        """IncrementItemReference(MODULE self) -> bool"""
        return _pcbnew.MODULE_IncrementItemReference(self)


    def IncrementReference(self, aFillSequenceGaps):
        """IncrementReference(MODULE self, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.MODULE_IncrementReference(self, aFillSequenceGaps)


    def FindPadByName(self, aPadName):
        """FindPadByName(MODULE self, wxString const & aPadName) -> D_PAD"""
        return _pcbnew.MODULE_FindPadByName(self, aPadName)


    def GetPad(self, *args):
        """
        GetPad(MODULE self, wxPoint aPosition, LSET aLayerMask) -> D_PAD
        GetPad(MODULE self, wxPoint aPosition) -> D_PAD
        """
        return _pcbnew.MODULE_GetPad(self, *args)


    def GetPadCount(self, *args):
        """
        GetPadCount(MODULE self, INCLUDE_NPTH_T aIncludeNPTH) -> unsigned int
        GetPadCount(MODULE self) -> unsigned int
        """
        return _pcbnew.MODULE_GetPadCount(self, *args)


    def GetNextPadName(self, aFillSequenceGaps):
        """GetNextPadName(MODULE self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_GetNextPadName(self, aFillSequenceGaps)


    def GetArea(self):
        """GetArea(MODULE self) -> double"""
        return _pcbnew.MODULE_GetArea(self)


    def GetLink(self):
        """GetLink(MODULE self) -> time_t"""
        return _pcbnew.MODULE_GetLink(self)


    def SetLink(self, aLink):
        """SetLink(MODULE self, time_t aLink)"""
        return _pcbnew.MODULE_SetLink(self, aLink)


    def GetPlacementCost180(self):
        """GetPlacementCost180(MODULE self) -> int"""
        return _pcbnew.MODULE_GetPlacementCost180(self)


    def SetPlacementCost180(self, aCost):
        """SetPlacementCost180(MODULE self, int aCost)"""
        return _pcbnew.MODULE_SetPlacementCost180(self, aCost)


    def GetPlacementCost90(self):
        """GetPlacementCost90(MODULE self) -> int"""
        return _pcbnew.MODULE_GetPlacementCost90(self)


    def SetPlacementCost90(self, aCost):
        """SetPlacementCost90(MODULE self, int aCost)"""
        return _pcbnew.MODULE_SetPlacementCost90(self, aCost)


    def DuplicateAndAddItem(self, item, aIncrementPadNumbers):
        """DuplicateAndAddItem(MODULE self, BOARD_ITEM item, bool aIncrementPadNumbers) -> BOARD_ITEM"""
        return _pcbnew.MODULE_DuplicateAndAddItem(self, item, aIncrementPadNumbers)


    def Add3DModel(self, a3DModel):
        """Add3DModel(MODULE self, S3D_MASTER * a3DModel)"""
        return _pcbnew.MODULE_Add3DModel(self, a3DModel)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(MODULE self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.MODULE_Visit(self, inspector, testData, scanTypes)


    def GetClass(self):
        """GetClass(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(MODULE self) -> BITMAP_DEF"""
        return _pcbnew.MODULE_GetMenuImage(self)


    def Clone(self):
        """Clone(MODULE self) -> EDA_ITEM"""
        return _pcbnew.MODULE_Clone(self)


    def RunOnChildren(self, aFunction):
        """RunOnChildren(MODULE self, boost::function< void (BOARD_ITEM *) > aFunction)"""
        return _pcbnew.MODULE_RunOnChildren(self, aFunction)


    def ViewUpdate(self, *args):
        """
        ViewUpdate(MODULE self, int aUpdateFlags)
        ViewUpdate(MODULE self)
        """
        return _pcbnew.MODULE_ViewUpdate(self, *args)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(MODULE self, int [] aLayers, int & aCount)"""
        return _pcbnew.MODULE_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(MODULE self, int aLayer) -> unsigned int"""
        return _pcbnew.MODULE_ViewGetLOD(self, aLayer)


    def ViewBBox(self):
        """ViewBBox(MODULE self) -> BOX2I const"""
        return _pcbnew.MODULE_ViewBBox(self)


    def CopyNetlistSettings(self, aModule):
        """CopyNetlistSettings(MODULE self, MODULE aModule)"""
        return _pcbnew.MODULE_CopyNetlistSettings(self, aModule)


    def IsLibNameValid(aName):
        """IsLibNameValid(wxString const & aName) -> bool"""
        return _pcbnew.MODULE_IsLibNameValid(aName)

    if _newclass:
        IsLibNameValid = staticmethod(IsLibNameValid)
    __swig_getmethods__["IsLibNameValid"] = lambda x: IsLibNameValid

    def StringLibNameInvalidChars(aUserReadable):
        """StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
        return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)

    if _newclass:
        StringLibNameInvalidChars = staticmethod(StringLibNameInvalidChars)
    __swig_getmethods__["StringLibNameInvalidChars"] = lambda x: StringLibNameInvalidChars

    def SetInitialComments(self, aInitialComments):
        """SetInitialComments(MODULE self, wxArrayString * aInitialComments)"""
        return _pcbnew.MODULE_SetInitialComments(self, aInitialComments)


    def PadCoverageRatio(self):
        """PadCoverageRatio(MODULE self) -> double"""
        return _pcbnew.MODULE_PadCoverageRatio(self)


    def GetInitialComments(self):
        """GetInitialComments(MODULE self) -> wxArrayString const *"""
        return _pcbnew.MODULE_GetInitialComments(self)



        #def SaveToLibrary(self,filename):
        #  return SaveModuleToLibrary(filename,self)

        #
        # add function, clears the thisown to avoid python from deleting
        # the object in the garbage collector
        #

    def Add(self,item):

        itemC = item.Cast()

        if type(itemC) is D_PAD:
            item.thisown=0
            self.Pads().PushBack(itemC)
        elif type(itemC) in [ TEXTE_PCB, DIMENSION, TEXTE_MODULE, DRAWSEGMENT,EDGE_MODULE]:
            item.thisown = 0
            self.GraphicalItems().PushBack(item)

MODULE_swigregister = _pcbnew.MODULE_swigregister
MODULE_swigregister(MODULE)

def MODULE_ClassOf(aItem):
    """MODULE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.MODULE_ClassOf(aItem)

_pcbnew.MODULE_is_LOCKED_swigconstant(_pcbnew)
MODULE_is_LOCKED = _pcbnew.MODULE_is_LOCKED

_pcbnew.MODULE_is_PLACED_swigconstant(_pcbnew)
MODULE_is_PLACED = _pcbnew.MODULE_is_PLACED

_pcbnew.MODULE_to_PLACE_swigconstant(_pcbnew)
MODULE_to_PLACE = _pcbnew.MODULE_to_PLACE

_pcbnew.MODULE_PADS_LOCKED_swigconstant(_pcbnew)
MODULE_PADS_LOCKED = _pcbnew.MODULE_PADS_LOCKED

def MODULE_IsLibNameValid(aName):
    """MODULE_IsLibNameValid(wxString const & aName) -> bool"""
    return _pcbnew.MODULE_IsLibNameValid(aName)

def MODULE_StringLibNameInvalidChars(aUserReadable):
    """MODULE_StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
    return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)


_pcbnew.VIA_THROUGH_swigconstant(_pcbnew)
VIA_THROUGH = _pcbnew.VIA_THROUGH

_pcbnew.VIA_BLIND_BURIED_swigconstant(_pcbnew)
VIA_BLIND_BURIED = _pcbnew.VIA_BLIND_BURIED

_pcbnew.VIA_MICROVIA_swigconstant(_pcbnew)
VIA_MICROVIA = _pcbnew.VIA_MICROVIA

_pcbnew.VIA_NOT_DEFINED_swigconstant(_pcbnew)
VIA_NOT_DEFINED = _pcbnew.VIA_NOT_DEFINED

_pcbnew.UNDEFINED_DRILL_DIAMETER_swigconstant(_pcbnew)
UNDEFINED_DRILL_DIAMETER = _pcbnew.UNDEFINED_DRILL_DIAMETER

_pcbnew.MIN_VIA_DRAW_SIZE_swigconstant(_pcbnew)
MIN_VIA_DRAW_SIZE = _pcbnew.MIN_VIA_DRAW_SIZE

def GetTrack(aStartTrace, aEndTrace, aPosition, aLayerMask):
    """GetTrack(TRACK aStartTrace, TRACK aEndTrace, wxPoint aPosition, LSET aLayerMask) -> TRACK"""
    return _pcbnew.GetTrack(aStartTrace, aEndTrace, aPosition, aLayerMask)
class TRACK(BOARD_CONNECTED_ITEM):
    """Proxy of C++ TRACK class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TRACK, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TRACK, name)
    __repr__ = _swig_repr

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf
    __swig_setmethods__["start"] = _pcbnew.TRACK_start_set
    __swig_getmethods__["start"] = _pcbnew.TRACK_start_get
    if _newclass:
        start = _swig_property(_pcbnew.TRACK_start_get, _pcbnew.TRACK_start_set)
    __swig_setmethods__["end"] = _pcbnew.TRACK_end_set
    __swig_getmethods__["end"] = _pcbnew.TRACK_end_get
    if _newclass:
        end = _swig_property(_pcbnew.TRACK_end_get, _pcbnew.TRACK_end_set)
    __swig_setmethods__["m_Param"] = _pcbnew.TRACK_m_Param_set
    __swig_getmethods__["m_Param"] = _pcbnew.TRACK_m_Param_get
    if _newclass:
        m_Param = _swig_property(_pcbnew.TRACK_m_Param_get, _pcbnew.TRACK_m_Param_set)

    def __init__(self, *args):
        """
        __init__(TRACK self, BOARD_ITEM aParent, KICAD_T idtype) -> TRACK
        __init__(TRACK self, BOARD_ITEM aParent) -> TRACK
        """
        this = _pcbnew.new_TRACK(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Next(self):
        """Next(TRACK self) -> TRACK"""
        return _pcbnew.TRACK_Next(self)


    def Back(self):
        """Back(TRACK self) -> TRACK"""
        return _pcbnew.TRACK_Back(self)


    def Move(self, aMoveVector):
        """Move(TRACK self, wxPoint aMoveVector)"""
        return _pcbnew.TRACK_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(TRACK self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TRACK_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(TRACK self, wxPoint aCentre)"""
        return _pcbnew.TRACK_Flip(self, aCentre)


    def SetPosition(self, aPos):
        """SetPosition(TRACK self, wxPoint aPos)"""
        return _pcbnew.TRACK_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetPosition(self)


    def SetWidth(self, aWidth):
        """SetWidth(TRACK self, int aWidth)"""
        return _pcbnew.TRACK_SetWidth(self, aWidth)


    def GetWidth(self):
        """GetWidth(TRACK self) -> int"""
        return _pcbnew.TRACK_GetWidth(self)


    def SetEnd(self, aEnd):
        """SetEnd(TRACK self, wxPoint aEnd)"""
        return _pcbnew.TRACK_SetEnd(self, aEnd)


    def GetEnd(self):
        """GetEnd(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetEnd(self)


    def SetStart(self, aStart):
        """SetStart(TRACK self, wxPoint aStart)"""
        return _pcbnew.TRACK_SetStart(self, aStart)


    def GetStart(self):
        """GetStart(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetStart(self)


    def GetEndPoint(self, aEndPoint):
        """GetEndPoint(TRACK self, ENDPOINT_T aEndPoint) -> wxPoint"""
        return _pcbnew.TRACK_GetEndPoint(self, aEndPoint)


    def GetBoundingBox(self):
        """GetBoundingBox(TRACK self) -> EDA_RECT"""
        return _pcbnew.TRACK_GetBoundingBox(self)


    def GetBestInsertPoint(self, aPcb):
        """GetBestInsertPoint(TRACK self, BOARD aPcb) -> TRACK"""
        return _pcbnew.TRACK_GetBestInsertPoint(self, aPcb)


    def GetStartNetCode(self, NetCode):
        """GetStartNetCode(TRACK self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_GetStartNetCode(self, NetCode)


    def GetEndNetCode(self, NetCode):
        """GetEndNetCode(TRACK self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_GetEndNetCode(self, NetCode)


    def GetLength(self):
        """GetLength(TRACK self) -> double"""
        return _pcbnew.TRACK_GetLength(self)


    def Draw(self, *args):
        """
        Draw(TRACK self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(TRACK self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TRACK_Draw(self, *args)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygon(TRACK self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.TRACK_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def IsPointOnEnds(self, point, min_dist=0):
        """
        IsPointOnEnds(TRACK self, wxPoint point, int min_dist=0) -> STATUS_FLAGS
        IsPointOnEnds(TRACK self, wxPoint point) -> STATUS_FLAGS
        """
        return _pcbnew.TRACK_IsPointOnEnds(self, point, min_dist)


    def IsNull(self):
        """IsNull(TRACK self) -> bool"""
        return _pcbnew.TRACK_IsNull(self)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(TRACK self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TRACK_GetMsgPanelInfo(self, aList)


    def ShowWidth(self):
        """ShowWidth(TRACK self) -> wxString"""
        return _pcbnew.TRACK_ShowWidth(self)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(TRACK self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.TRACK_Visit(self, inspector, testData, scanTypes)


    def HitTest(self, *args):
        """
        HitTest(TRACK self, wxPoint aPosition) -> bool
        HitTest(TRACK self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(TRACK self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(TRACK self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.TRACK_HitTest(self, *args)


    def GetVia(self, *args):
        """
        GetVia(TRACK self, wxPoint aPosition, LAYER_ID aLayer) -> VIA
        GetVia(TRACK self, wxPoint aPosition) -> VIA
        GetVia(TRACK self, TRACK aEndTrace, wxPoint aPosition, LSET aLayerMask) -> VIA
        """
        return _pcbnew.TRACK_GetVia(self, *args)


    def GetTrack(self, aStartTrace, aEndTrace, aEndPoint, aSameNetOnly, aSequential):
        """GetTrack(TRACK self, TRACK aStartTrace, TRACK aEndTrace, ENDPOINT_T aEndPoint, bool aSameNetOnly, bool aSequential) -> TRACK"""
        return _pcbnew.TRACK_GetTrack(self, aStartTrace, aEndTrace, aEndPoint, aSameNetOnly, aSequential)


    def GetEndSegments(self, NbSegm, StartTrack, EndTrack):
        """GetEndSegments(TRACK self, int NbSegm, TRACK ** StartTrack, TRACK ** EndTrack) -> int"""
        return _pcbnew.TRACK_GetEndSegments(self, NbSegm, StartTrack, EndTrack)


    def GetClass(self):
        """GetClass(TRACK self) -> wxString"""
        return _pcbnew.TRACK_GetClass(self)


    def GetClearance(self, aItem=None):
        """
        GetClearance(TRACK self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(TRACK self) -> int
        """
        return _pcbnew.TRACK_GetClearance(self, aItem)


    def GetSelectMenuText(self):
        """GetSelectMenuText(TRACK self) -> wxString"""
        return _pcbnew.TRACK_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TRACK self) -> BITMAP_DEF"""
        return _pcbnew.TRACK_GetMenuImage(self)


    def Clone(self):
        """Clone(TRACK self) -> EDA_ITEM"""
        return _pcbnew.TRACK_Clone(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(TRACK self, int [] aLayers, int & aCount)"""
        return _pcbnew.TRACK_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(TRACK self, int aLayer) -> unsigned int"""
        return _pcbnew.TRACK_ViewGetLOD(self, aLayer)

    __swig_destroy__ = _pcbnew.delete_TRACK
    __del__ = lambda self: None
TRACK_swigregister = _pcbnew.TRACK_swigregister
TRACK_swigregister(TRACK)

def TRACK_ClassOf(aItem):
    """TRACK_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.TRACK_ClassOf(aItem)

class SEGZONE(TRACK):
    """Proxy of C++ SEGZONE class"""
    __swig_setmethods__ = {}
    for _s in [TRACK]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SEGZONE, name, value)
    __swig_getmethods__ = {}
    for _s in [TRACK]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SEGZONE, name)
    __repr__ = _swig_repr

    def __init__(self, aParent):
        """__init__(SEGZONE self, BOARD_ITEM aParent) -> SEGZONE"""
        this = _pcbnew.new_SEGZONE(aParent)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetClass(self):
        """GetClass(SEGZONE self) -> wxString"""
        return _pcbnew.SEGZONE_GetClass(self)


    def Next(self):
        """Next(SEGZONE self) -> SEGZONE"""
        return _pcbnew.SEGZONE_Next(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(SEGZONE self) -> wxString"""
        return _pcbnew.SEGZONE_GetSelectMenuText(self)


    def Draw(self, *args):
        """
        Draw(SEGZONE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(SEGZONE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.SEGZONE_Draw(self, *args)


    def GetMenuImage(self):
        """GetMenuImage(SEGZONE self) -> BITMAP_DEF"""
        return _pcbnew.SEGZONE_GetMenuImage(self)


    def Clone(self):
        """Clone(SEGZONE self) -> EDA_ITEM"""
        return _pcbnew.SEGZONE_Clone(self)

    __swig_destroy__ = _pcbnew.delete_SEGZONE
    __del__ = lambda self: None
SEGZONE_swigregister = _pcbnew.SEGZONE_swigregister
SEGZONE_swigregister(SEGZONE)

class VIA(TRACK):
    """Proxy of C++ VIA class"""
    __swig_setmethods__ = {}
    for _s in [TRACK]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VIA, name, value)
    __swig_getmethods__ = {}
    for _s in [TRACK]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VIA, name)
    __repr__ = _swig_repr

    def __init__(self, aParent):
        """__init__(VIA self, BOARD_ITEM aParent) -> VIA"""
        this = _pcbnew.new_VIA(aParent)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.VIA_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def Draw(self, *args):
        """
        Draw(VIA self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(VIA self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.VIA_Draw(self, *args)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(VIA self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.VIA_IsOnLayer(self, aLayer)


    def GetLayerSet(self):
        """GetLayerSet(VIA self) -> LSET"""
        return _pcbnew.VIA_GetLayerSet(self)


    def SetLayerPair(self, aTopLayer, aBottomLayer):
        """SetLayerPair(VIA self, LAYER_ID aTopLayer, LAYER_ID aBottomLayer)"""
        return _pcbnew.VIA_SetLayerPair(self, aTopLayer, aBottomLayer)


    def LayerPair(self, top_layer, bottom_layer):
        """LayerPair(VIA self, LAYER_ID * top_layer, LAYER_ID * bottom_layer)"""
        return _pcbnew.VIA_LayerPair(self, top_layer, bottom_layer)


    def GetPosition(self):
        """GetPosition(VIA self) -> wxPoint"""
        return _pcbnew.VIA_GetPosition(self)


    def SetPosition(self, aPoint):
        """SetPosition(VIA self, wxPoint aPoint)"""
        return _pcbnew.VIA_SetPosition(self, aPoint)


    def HitTest(self, *args):
        """
        HitTest(VIA self, wxPoint aPosition) -> bool
        HitTest(VIA self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(VIA self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(VIA self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.VIA_HitTest(self, *args)


    def GetClass(self):
        """GetClass(VIA self) -> wxString"""
        return _pcbnew.VIA_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(VIA self) -> wxString"""
        return _pcbnew.VIA_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(VIA self) -> BITMAP_DEF"""
        return _pcbnew.VIA_GetMenuImage(self)


    def Clone(self):
        """Clone(VIA self) -> EDA_ITEM"""
        return _pcbnew.VIA_Clone(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(VIA self, int [] aLayers, int & aCount)"""
        return _pcbnew.VIA_ViewGetLayers(self, aLayers, aCount)


    def Flip(self, aCentre):
        """Flip(VIA self, wxPoint aCentre)"""
        return _pcbnew.VIA_Flip(self, aCentre)


    def GetViaType(self):
        """GetViaType(VIA self) -> VIATYPE_T"""
        return _pcbnew.VIA_GetViaType(self)


    def SetViaType(self, aViaType):
        """SetViaType(VIA self, VIATYPE_T aViaType)"""
        return _pcbnew.VIA_SetViaType(self, aViaType)


    def SetDrill(self, aDrill):
        """SetDrill(VIA self, int aDrill)"""
        return _pcbnew.VIA_SetDrill(self, aDrill)


    def GetDrill(self):
        """GetDrill(VIA self) -> int"""
        return _pcbnew.VIA_GetDrill(self)


    def GetDrillValue(self):
        """GetDrillValue(VIA self) -> int"""
        return _pcbnew.VIA_GetDrillValue(self)


    def SetDrillDefault(self):
        """SetDrillDefault(VIA self)"""
        return _pcbnew.VIA_SetDrillDefault(self)


    def IsDrillDefault(self):
        """IsDrillDefault(VIA self) -> bool"""
        return _pcbnew.VIA_IsDrillDefault(self)

    __swig_destroy__ = _pcbnew.delete_VIA
    __del__ = lambda self: None
VIA_swigregister = _pcbnew.VIA_swigregister
VIA_swigregister(VIA)

def VIA_ClassOf(aItem):
    """VIA_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.VIA_ClassOf(aItem)


def GetFirstVia(aTrk, aStopPoint=None):
    """
    GetFirstVia(TRACK aTrk, TRACK aStopPoint=None) -> VIA
    GetFirstVia(TRACK aTrk) -> VIA
    """
    return _pcbnew.GetFirstVia(aTrk, aStopPoint)
class SEGMENT(_object):
    """Proxy of C++ SEGMENT class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SEGMENT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SEGMENT, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Start"] = _pcbnew.SEGMENT_m_Start_set
    __swig_getmethods__["m_Start"] = _pcbnew.SEGMENT_m_Start_get
    if _newclass:
        m_Start = _swig_property(_pcbnew.SEGMENT_m_Start_get, _pcbnew.SEGMENT_m_Start_set)
    __swig_setmethods__["m_End"] = _pcbnew.SEGMENT_m_End_set
    __swig_getmethods__["m_End"] = _pcbnew.SEGMENT_m_End_get
    if _newclass:
        m_End = _swig_property(_pcbnew.SEGMENT_m_End_get, _pcbnew.SEGMENT_m_End_set)

    def __init__(self, *args):
        """
        __init__(SEGMENT self) -> SEGMENT
        __init__(SEGMENT self, wxPoint aStart, wxPoint aEnd) -> SEGMENT
        """
        this = _pcbnew.new_SEGMENT(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_SEGMENT
    __del__ = lambda self: None
SEGMENT_swigregister = _pcbnew.SEGMENT_swigregister
SEGMENT_swigregister(SEGMENT)

class ZONE_CONTAINER(BOARD_CONNECTED_ITEM):
    """Proxy of C++ ZONE_CONTAINER class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZONE_CONTAINER, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ZONE_CONTAINER, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ZONE_CONTAINER self, BOARD parent) -> ZONE_CONTAINER
        __init__(ZONE_CONTAINER self, ZONE_CONTAINER aZone) -> ZONE_CONTAINER
        """
        this = _pcbnew.new_ZONE_CONTAINER(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_ZONE_CONTAINER
    __del__ = lambda self: None

    def GetPosition(self):
        """GetPosition(ZONE_CONTAINER self) -> wxPoint"""
        return _pcbnew.ZONE_CONTAINER_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(ZONE_CONTAINER self, wxPoint aPos)"""
        return _pcbnew.ZONE_CONTAINER_SetPosition(self, aPos)


    def SetPriority(self, aPriority):
        """SetPriority(ZONE_CONTAINER self, unsigned int aPriority)"""
        return _pcbnew.ZONE_CONTAINER_SetPriority(self, aPriority)


    def GetPriority(self):
        """GetPriority(ZONE_CONTAINER self) -> unsigned int"""
        return _pcbnew.ZONE_CONTAINER_GetPriority(self)


    def Copy(self, src):
        """Copy(ZONE_CONTAINER self, ZONE_CONTAINER src)"""
        return _pcbnew.ZONE_CONTAINER_Copy(self, src)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(ZONE_CONTAINER self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.ZONE_CONTAINER_GetMsgPanelInfo(self, aList)


    def Draw(self, *args):
        """
        Draw(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.ZONE_CONTAINER_Draw(self, *args)


    def DrawFilledArea(self, *args):
        """
        DrawFilledArea(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        DrawFilledArea(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.ZONE_CONTAINER_DrawFilledArea(self, *args)


    def DrawWhileCreateOutline(self, *args):
        """
        DrawWhileCreateOutline(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE draw_mode)
        DrawWhileCreateOutline(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC)
        """
        return _pcbnew.ZONE_CONTAINER_DrawWhileCreateOutline(self, *args)


    def GetBoundingBox(self):
        """GetBoundingBox(ZONE_CONTAINER self) -> EDA_RECT"""
        return _pcbnew.ZONE_CONTAINER_GetBoundingBox(self)


    def GetClearance(self, aItem=None):
        """
        GetClearance(ZONE_CONTAINER self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(ZONE_CONTAINER self) -> int
        """
        return _pcbnew.ZONE_CONTAINER_GetClearance(self, aItem)


    def TestForCopperIslandAndRemoveInsulatedIslands(self, aPcb):
        """TestForCopperIslandAndRemoveInsulatedIslands(ZONE_CONTAINER self, BOARD aPcb)"""
        return _pcbnew.ZONE_CONTAINER_TestForCopperIslandAndRemoveInsulatedIslands(self, aPcb)


    def IsOnCopperLayer(self):
        """IsOnCopperLayer(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsOnCopperLayer(self)


    def SetFillMode(self, aFillMode):
        """SetFillMode(ZONE_CONTAINER self, int aFillMode)"""
        return _pcbnew.ZONE_CONTAINER_SetFillMode(self, aFillMode)


    def GetFillMode(self):
        """GetFillMode(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetFillMode(self)


    def SetThermalReliefGap(self, aThermalReliefGap):
        """SetThermalReliefGap(ZONE_CONTAINER self, int aThermalReliefGap)"""
        return _pcbnew.ZONE_CONTAINER_SetThermalReliefGap(self, aThermalReliefGap)


    def GetThermalReliefGap(self, aPad=None):
        """
        GetThermalReliefGap(ZONE_CONTAINER self, D_PAD aPad=None) -> int
        GetThermalReliefGap(ZONE_CONTAINER self) -> int
        """
        return _pcbnew.ZONE_CONTAINER_GetThermalReliefGap(self, aPad)


    def SetThermalReliefCopperBridge(self, aThermalReliefCopperBridge):
        """SetThermalReliefCopperBridge(ZONE_CONTAINER self, int aThermalReliefCopperBridge)"""
        return _pcbnew.ZONE_CONTAINER_SetThermalReliefCopperBridge(self, aThermalReliefCopperBridge)


    def GetThermalReliefCopperBridge(self, aPad=None):
        """
        GetThermalReliefCopperBridge(ZONE_CONTAINER self, D_PAD aPad=None) -> int
        GetThermalReliefCopperBridge(ZONE_CONTAINER self) -> int
        """
        return _pcbnew.ZONE_CONTAINER_GetThermalReliefCopperBridge(self, aPad)


    def SetArcSegmentCount(self, aArcSegCount):
        """SetArcSegmentCount(ZONE_CONTAINER self, int aArcSegCount)"""
        return _pcbnew.ZONE_CONTAINER_SetArcSegmentCount(self, aArcSegCount)


    def GetArcSegmentCount(self):
        """GetArcSegmentCount(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetArcSegmentCount(self)


    def IsFilled(self):
        """IsFilled(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsFilled(self)


    def SetIsFilled(self, isFilled):
        """SetIsFilled(ZONE_CONTAINER self, bool isFilled)"""
        return _pcbnew.ZONE_CONTAINER_SetIsFilled(self, isFilled)


    def GetZoneClearance(self):
        """GetZoneClearance(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetZoneClearance(self)


    def SetZoneClearance(self, aZoneClearance):
        """SetZoneClearance(ZONE_CONTAINER self, int aZoneClearance)"""
        return _pcbnew.ZONE_CONTAINER_SetZoneClearance(self, aZoneClearance)


    def GetPadConnection(self, aPad=None):
        """
        GetPadConnection(ZONE_CONTAINER self, D_PAD aPad=None) -> ZoneConnection
        GetPadConnection(ZONE_CONTAINER self) -> ZoneConnection
        """
        return _pcbnew.ZONE_CONTAINER_GetPadConnection(self, aPad)


    def SetPadConnection(self, aPadConnection):
        """SetPadConnection(ZONE_CONTAINER self, ZoneConnection aPadConnection)"""
        return _pcbnew.ZONE_CONTAINER_SetPadConnection(self, aPadConnection)


    def GetMinThickness(self):
        """GetMinThickness(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetMinThickness(self)


    def SetMinThickness(self, aMinThickness):
        """SetMinThickness(ZONE_CONTAINER self, int aMinThickness)"""
        return _pcbnew.ZONE_CONTAINER_SetMinThickness(self, aMinThickness)


    def GetSelectedCorner(self):
        """GetSelectedCorner(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetSelectedCorner(self)


    def SetSelectedCorner(self, *args):
        """
        SetSelectedCorner(ZONE_CONTAINER self, int aCorner)
        SetSelectedCorner(ZONE_CONTAINER self, wxPoint aPosition)
        """
        return _pcbnew.ZONE_CONTAINER_SetSelectedCorner(self, *args)


    def GetLocalFlags(self):
        """GetLocalFlags(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetLocalFlags(self)


    def SetLocalFlags(self, aFlags):
        """SetLocalFlags(ZONE_CONTAINER self, int aFlags)"""
        return _pcbnew.ZONE_CONTAINER_SetLocalFlags(self, aFlags)


    def FillSegments(self, *args):
        """
        FillSegments(ZONE_CONTAINER self) -> std::vector< SEGMENT,std::allocator< SEGMENT > >
        FillSegments(ZONE_CONTAINER self) -> std::vector< SEGMENT,std::allocator< SEGMENT > > const &
        """
        return _pcbnew.ZONE_CONTAINER_FillSegments(self, *args)


    def Outline(self, *args):
        """
        Outline(ZONE_CONTAINER self) -> CPolyLine
        Outline(ZONE_CONTAINER self) -> CPolyLine
        """
        return _pcbnew.ZONE_CONTAINER_Outline(self, *args)


    def SetOutline(self, aOutline):
        """SetOutline(ZONE_CONTAINER self, CPolyLine aOutline)"""
        return _pcbnew.ZONE_CONTAINER_SetOutline(self, aOutline)


    def HitTestInsideZone(self, aPosition):
        """HitTestInsideZone(ZONE_CONTAINER self, wxPoint aPosition) -> bool"""
        return _pcbnew.ZONE_CONTAINER_HitTestInsideZone(self, aPosition)


    def HitTestFilledArea(self, aRefPos):
        """HitTestFilledArea(ZONE_CONTAINER self, wxPoint aRefPos) -> bool"""
        return _pcbnew.ZONE_CONTAINER_HitTestFilledArea(self, aRefPos)


    def TransformSolidAreasShapesToPolygonSet(self, aCornerBuffer, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformSolidAreasShapesToPolygonSet(ZONE_CONTAINER self, SHAPE_POLY_SET & aCornerBuffer, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.ZONE_CONTAINER_TransformSolidAreasShapesToPolygonSet(self, aCornerBuffer, aCircleToSegmentsCount, aCorrectionFactor)


    def BuildFilledSolidAreasPolygons(self, aPcb, aOutlineBuffer=None):
        """
        BuildFilledSolidAreasPolygons(ZONE_CONTAINER self, BOARD aPcb, SHAPE_POLY_SET * aOutlineBuffer=None) -> bool
        BuildFilledSolidAreasPolygons(ZONE_CONTAINER self, BOARD aPcb) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_BuildFilledSolidAreasPolygons(self, aPcb, aOutlineBuffer)


    def AddClearanceAreasPolygonsToPolysList(self, aPcb):
        """AddClearanceAreasPolygonsToPolysList(ZONE_CONTAINER self, BOARD aPcb)"""
        return _pcbnew.ZONE_CONTAINER_AddClearanceAreasPolygonsToPolysList(self, aPcb)


    def AddClearanceAreasPolygonsToPolysList_NG(self, aPcb):
        """AddClearanceAreasPolygonsToPolysList_NG(ZONE_CONTAINER self, BOARD aPcb)"""
        return _pcbnew.ZONE_CONTAINER_AddClearanceAreasPolygonsToPolysList_NG(self, aPcb)


    def TransformOutlinesShapeWithClearanceToPolygon(self, aCornerBuffer, aMinClearanceValue, aUseNetClearance):
        """TransformOutlinesShapeWithClearanceToPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET & aCornerBuffer, int aMinClearanceValue, bool aUseNetClearance)"""
        return _pcbnew.ZONE_CONTAINER_TransformOutlinesShapeWithClearanceToPolygon(self, aCornerBuffer, aMinClearanceValue, aUseNetClearance)


    def HitTestForCorner(self, refPos):
        """HitTestForCorner(ZONE_CONTAINER self, wxPoint refPos) -> int"""
        return _pcbnew.ZONE_CONTAINER_HitTestForCorner(self, refPos)


    def HitTestForEdge(self, refPos):
        """HitTestForEdge(ZONE_CONTAINER self, wxPoint refPos) -> int"""
        return _pcbnew.ZONE_CONTAINER_HitTestForEdge(self, refPos)


    def HitTest(self, *args):
        """
        HitTest(ZONE_CONTAINER self, wxPoint aPosition) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_HitTest(self, *args)


    def FillZoneAreasWithSegments(self):
        """FillZoneAreasWithSegments(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_FillZoneAreasWithSegments(self)


    def UnFill(self):
        """UnFill(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_UnFill(self)


    def Move(self, offset):
        """Move(ZONE_CONTAINER self, wxPoint offset)"""
        return _pcbnew.ZONE_CONTAINER_Move(self, offset)


    def MoveEdge(self, offset, aEdge):
        """MoveEdge(ZONE_CONTAINER self, wxPoint offset, int aEdge)"""
        return _pcbnew.ZONE_CONTAINER_MoveEdge(self, offset, aEdge)


    def Rotate(self, centre, angle):
        """Rotate(ZONE_CONTAINER self, wxPoint centre, double angle)"""
        return _pcbnew.ZONE_CONTAINER_Rotate(self, centre, angle)


    def Flip(self, aCentre):
        """Flip(ZONE_CONTAINER self, wxPoint aCentre)"""
        return _pcbnew.ZONE_CONTAINER_Flip(self, aCentre)


    def Mirror(self, mirror_ref):
        """Mirror(ZONE_CONTAINER self, wxPoint mirror_ref)"""
        return _pcbnew.ZONE_CONTAINER_Mirror(self, mirror_ref)


    def GetClass(self):
        """GetClass(ZONE_CONTAINER self) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetClass(self)


    def GetNumCorners(self):
        """GetNumCorners(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetNumCorners(self)


    def RemoveAllContours(self):
        """RemoveAllContours(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_RemoveAllContours(self)


    def GetCornerPosition(self, aCornerIndex):
        """GetCornerPosition(ZONE_CONTAINER self, int aCornerIndex) -> wxPoint"""
        return _pcbnew.ZONE_CONTAINER_GetCornerPosition(self, aCornerIndex)


    def SetCornerPosition(self, aCornerIndex, new_pos):
        """SetCornerPosition(ZONE_CONTAINER self, int aCornerIndex, wxPoint new_pos)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerPosition(self, aCornerIndex, new_pos)


    def AppendCorner(self, position):
        """AppendCorner(ZONE_CONTAINER self, wxPoint position)"""
        return _pcbnew.ZONE_CONTAINER_AppendCorner(self, position)


    def GetHatchStyle(self):
        """GetHatchStyle(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetHatchStyle(self)


    def SetHatchStyle(self, aStyle):
        """SetHatchStyle(ZONE_CONTAINER self, CPolyLine::HATCH_STYLE aStyle)"""
        return _pcbnew.ZONE_CONTAINER_SetHatchStyle(self, aStyle)


    def IsSame(self, aZoneToCompare):
        """IsSame(ZONE_CONTAINER self, ZONE_CONTAINER aZoneToCompare) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsSame(self, aZoneToCompare)


    def ClearFilledPolysList(self):
        """ClearFilledPolysList(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_ClearFilledPolysList(self)


    def GetFilledPolysList(self):
        """GetFilledPolysList(ZONE_CONTAINER self) -> SHAPE_POLY_SET const &"""
        return _pcbnew.ZONE_CONTAINER_GetFilledPolysList(self)


    def AddFilledPolysList(self, aPolysList):
        """AddFilledPolysList(ZONE_CONTAINER self, SHAPE_POLY_SET & aPolysList)"""
        return _pcbnew.ZONE_CONTAINER_AddFilledPolysList(self, aPolysList)


    def GetSmoothedPoly(self):
        """GetSmoothedPoly(ZONE_CONTAINER self) -> CPolyLine"""
        return _pcbnew.ZONE_CONTAINER_GetSmoothedPoly(self)


    def SetCornerSmoothingType(self, aType):
        """SetCornerSmoothingType(ZONE_CONTAINER self, int aType)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerSmoothingType(self, aType)


    def GetCornerSmoothingType(self):
        """GetCornerSmoothingType(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetCornerSmoothingType(self)


    def SetCornerRadius(self, aRadius):
        """SetCornerRadius(ZONE_CONTAINER self, unsigned int aRadius)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerRadius(self, aRadius)


    def GetCornerRadius(self):
        """GetCornerRadius(ZONE_CONTAINER self) -> unsigned int"""
        return _pcbnew.ZONE_CONTAINER_GetCornerRadius(self)


    def AddPolygon(self, aPolygon):
        """AddPolygon(ZONE_CONTAINER self, wxPoint_Vector aPolygon)"""
        return _pcbnew.ZONE_CONTAINER_AddPolygon(self, aPolygon)


    def AddFilledPolygon(self, aPolygon):
        """AddFilledPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET & aPolygon)"""
        return _pcbnew.ZONE_CONTAINER_AddFilledPolygon(self, aPolygon)


    def AddFillSegments(self, aSegments):
        """AddFillSegments(ZONE_CONTAINER self, std::vector< SEGMENT,std::allocator< SEGMENT > > & aSegments)"""
        return _pcbnew.ZONE_CONTAINER_AddFillSegments(self, aSegments)


    def GetSelectMenuText(self):
        """GetSelectMenuText(ZONE_CONTAINER self) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(ZONE_CONTAINER self) -> BITMAP_DEF"""
        return _pcbnew.ZONE_CONTAINER_GetMenuImage(self)


    def Clone(self):
        """Clone(ZONE_CONTAINER self) -> EDA_ITEM"""
        return _pcbnew.ZONE_CONTAINER_Clone(self)


    def GetIsKeepout(self):
        """GetIsKeepout(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetIsKeepout(self)


    def GetDoNotAllowCopperPour(self):
        """GetDoNotAllowCopperPour(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowCopperPour(self)


    def GetDoNotAllowVias(self):
        """GetDoNotAllowVias(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowVias(self)


    def GetDoNotAllowTracks(self):
        """GetDoNotAllowTracks(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowTracks(self)


    def SetIsKeepout(self, aEnable):
        """SetIsKeepout(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetIsKeepout(self, aEnable)


    def SetDoNotAllowCopperPour(self, aEnable):
        """SetDoNotAllowCopperPour(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowCopperPour(self, aEnable)


    def SetDoNotAllowVias(self, aEnable):
        """SetDoNotAllowVias(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowVias(self, aEnable)


    def SetDoNotAllowTracks(self, aEnable):
        """SetDoNotAllowTracks(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowTracks(self, aEnable)

ZONE_CONTAINER_swigregister = _pcbnew.ZONE_CONTAINER_swigregister
ZONE_CONTAINER_swigregister(ZONE_CONTAINER)


_pcbnew.F_Cu_swigconstant(_pcbnew)
F_Cu = _pcbnew.F_Cu

_pcbnew.In1_Cu_swigconstant(_pcbnew)
In1_Cu = _pcbnew.In1_Cu

_pcbnew.In2_Cu_swigconstant(_pcbnew)
In2_Cu = _pcbnew.In2_Cu

_pcbnew.In3_Cu_swigconstant(_pcbnew)
In3_Cu = _pcbnew.In3_Cu

_pcbnew.In4_Cu_swigconstant(_pcbnew)
In4_Cu = _pcbnew.In4_Cu

_pcbnew.In5_Cu_swigconstant(_pcbnew)
In5_Cu = _pcbnew.In5_Cu

_pcbnew.In6_Cu_swigconstant(_pcbnew)
In6_Cu = _pcbnew.In6_Cu

_pcbnew.In7_Cu_swigconstant(_pcbnew)
In7_Cu = _pcbnew.In7_Cu

_pcbnew.In8_Cu_swigconstant(_pcbnew)
In8_Cu = _pcbnew.In8_Cu

_pcbnew.In9_Cu_swigconstant(_pcbnew)
In9_Cu = _pcbnew.In9_Cu

_pcbnew.In10_Cu_swigconstant(_pcbnew)
In10_Cu = _pcbnew.In10_Cu

_pcbnew.In11_Cu_swigconstant(_pcbnew)
In11_Cu = _pcbnew.In11_Cu

_pcbnew.In12_Cu_swigconstant(_pcbnew)
In12_Cu = _pcbnew.In12_Cu

_pcbnew.In13_Cu_swigconstant(_pcbnew)
In13_Cu = _pcbnew.In13_Cu

_pcbnew.In14_Cu_swigconstant(_pcbnew)
In14_Cu = _pcbnew.In14_Cu

_pcbnew.In15_Cu_swigconstant(_pcbnew)
In15_Cu = _pcbnew.In15_Cu

_pcbnew.In16_Cu_swigconstant(_pcbnew)
In16_Cu = _pcbnew.In16_Cu

_pcbnew.In17_Cu_swigconstant(_pcbnew)
In17_Cu = _pcbnew.In17_Cu

_pcbnew.In18_Cu_swigconstant(_pcbnew)
In18_Cu = _pcbnew.In18_Cu

_pcbnew.In19_Cu_swigconstant(_pcbnew)
In19_Cu = _pcbnew.In19_Cu

_pcbnew.In20_Cu_swigconstant(_pcbnew)
In20_Cu = _pcbnew.In20_Cu

_pcbnew.In21_Cu_swigconstant(_pcbnew)
In21_Cu = _pcbnew.In21_Cu

_pcbnew.In22_Cu_swigconstant(_pcbnew)
In22_Cu = _pcbnew.In22_Cu

_pcbnew.In23_Cu_swigconstant(_pcbnew)
In23_Cu = _pcbnew.In23_Cu

_pcbnew.In24_Cu_swigconstant(_pcbnew)
In24_Cu = _pcbnew.In24_Cu

_pcbnew.In25_Cu_swigconstant(_pcbnew)
In25_Cu = _pcbnew.In25_Cu

_pcbnew.In26_Cu_swigconstant(_pcbnew)
In26_Cu = _pcbnew.In26_Cu

_pcbnew.In27_Cu_swigconstant(_pcbnew)
In27_Cu = _pcbnew.In27_Cu

_pcbnew.In28_Cu_swigconstant(_pcbnew)
In28_Cu = _pcbnew.In28_Cu

_pcbnew.In29_Cu_swigconstant(_pcbnew)
In29_Cu = _pcbnew.In29_Cu

_pcbnew.In30_Cu_swigconstant(_pcbnew)
In30_Cu = _pcbnew.In30_Cu

_pcbnew.B_Cu_swigconstant(_pcbnew)
B_Cu = _pcbnew.B_Cu

_pcbnew.B_Adhes_swigconstant(_pcbnew)
B_Adhes = _pcbnew.B_Adhes

_pcbnew.F_Adhes_swigconstant(_pcbnew)
F_Adhes = _pcbnew.F_Adhes

_pcbnew.B_Paste_swigconstant(_pcbnew)
B_Paste = _pcbnew.B_Paste

_pcbnew.F_Paste_swigconstant(_pcbnew)
F_Paste = _pcbnew.F_Paste

_pcbnew.B_SilkS_swigconstant(_pcbnew)
B_SilkS = _pcbnew.B_SilkS

_pcbnew.F_SilkS_swigconstant(_pcbnew)
F_SilkS = _pcbnew.F_SilkS

_pcbnew.B_Mask_swigconstant(_pcbnew)
B_Mask = _pcbnew.B_Mask

_pcbnew.F_Mask_swigconstant(_pcbnew)
F_Mask = _pcbnew.F_Mask

_pcbnew.Dwgs_User_swigconstant(_pcbnew)
Dwgs_User = _pcbnew.Dwgs_User

_pcbnew.Cmts_User_swigconstant(_pcbnew)
Cmts_User = _pcbnew.Cmts_User

_pcbnew.Eco1_User_swigconstant(_pcbnew)
Eco1_User = _pcbnew.Eco1_User

_pcbnew.Eco2_User_swigconstant(_pcbnew)
Eco2_User = _pcbnew.Eco2_User

_pcbnew.Edge_Cuts_swigconstant(_pcbnew)
Edge_Cuts = _pcbnew.Edge_Cuts

_pcbnew.Margin_swigconstant(_pcbnew)
Margin = _pcbnew.Margin

_pcbnew.B_CrtYd_swigconstant(_pcbnew)
B_CrtYd = _pcbnew.B_CrtYd

_pcbnew.F_CrtYd_swigconstant(_pcbnew)
F_CrtYd = _pcbnew.F_CrtYd

_pcbnew.B_Fab_swigconstant(_pcbnew)
B_Fab = _pcbnew.B_Fab

_pcbnew.F_Fab_swigconstant(_pcbnew)
F_Fab = _pcbnew.F_Fab

_pcbnew.LAYER_ID_COUNT_swigconstant(_pcbnew)
LAYER_ID_COUNT = _pcbnew.LAYER_ID_COUNT
class LSEQ(base_seqVect):
    """Proxy of C++ LSEQ class"""
    __swig_setmethods__ = {}
    for _s in [base_seqVect]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LSEQ, name, value)
    __swig_getmethods__ = {}
    for _s in [base_seqVect]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LSEQ, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(LSEQ self) -> LSEQ"""
        this = _pcbnew.new_LSEQ()
        try:
            self.this.append(this)
        except:
            self.this = this

    def Rewind(self):
        """Rewind(LSEQ self)"""
        return _pcbnew.LSEQ_Rewind(self)


    def __nonzero__(self):
        return _pcbnew.LSEQ___nonzero__(self)
    __bool__ = __nonzero__



    def __ref__(self):
        """__ref__(LSEQ self) -> LAYER_ID"""
        return _pcbnew.LSEQ___ref__(self)

    __swig_destroy__ = _pcbnew.delete_LSEQ
    __del__ = lambda self: None
LSEQ_swigregister = _pcbnew.LSEQ_swigregister
LSEQ_swigregister(LSEQ)

class LSET(_object):
    """Proxy of C++ LSET class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LSET, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LSET, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LSET self) -> LSET
        __init__(LSET self, BASE_SET const & aOther) -> LSET
        __init__(LSET self, LAYER_ID aLayer) -> LSET
        __init__(LSET self, LAYER_ID const * aArray, unsigned int aCount) -> LSET
        __init__(LSET self, unsigned int aIdCount, LAYER_ID aFirst) -> LSET
        """
        this = _pcbnew.new_LSET(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Name(aLayerId):
        """Name(LAYER_ID aLayerId) -> wxChar const *"""
        return _pcbnew.LSET_Name(aLayerId)

    if _newclass:
        Name = staticmethod(Name)
    __swig_getmethods__["Name"] = lambda x: Name

    def InternalCuMask():
        """InternalCuMask() -> LSET"""
        return _pcbnew.LSET_InternalCuMask()

    if _newclass:
        InternalCuMask = staticmethod(InternalCuMask)
    __swig_getmethods__["InternalCuMask"] = lambda x: InternalCuMask

    def AllCuMask(*args):
        """
        AllCuMask(int aCuLayerCount) -> LSET
        AllCuMask() -> LSET
        """
        return _pcbnew.LSET_AllCuMask(*args)

    if _newclass:
        AllCuMask = staticmethod(AllCuMask)
    __swig_getmethods__["AllCuMask"] = lambda x: AllCuMask

    def AllNonCuMask():
        """AllNonCuMask() -> LSET"""
        return _pcbnew.LSET_AllNonCuMask()

    if _newclass:
        AllNonCuMask = staticmethod(AllNonCuMask)
    __swig_getmethods__["AllNonCuMask"] = lambda x: AllNonCuMask

    def AllLayersMask():
        """AllLayersMask() -> LSET"""
        return _pcbnew.LSET_AllLayersMask()

    if _newclass:
        AllLayersMask = staticmethod(AllLayersMask)
    __swig_getmethods__["AllLayersMask"] = lambda x: AllLayersMask

    def FrontTechMask():
        """FrontTechMask() -> LSET"""
        return _pcbnew.LSET_FrontTechMask()

    if _newclass:
        FrontTechMask = staticmethod(FrontTechMask)
    __swig_getmethods__["FrontTechMask"] = lambda x: FrontTechMask

    def BackTechMask():
        """BackTechMask() -> LSET"""
        return _pcbnew.LSET_BackTechMask()

    if _newclass:
        BackTechMask = staticmethod(BackTechMask)
    __swig_getmethods__["BackTechMask"] = lambda x: BackTechMask

    def AllTechMask():
        """AllTechMask() -> LSET"""
        return _pcbnew.LSET_AllTechMask()

    if _newclass:
        AllTechMask = staticmethod(AllTechMask)
    __swig_getmethods__["AllTechMask"] = lambda x: AllTechMask

    def FrontMask():
        """FrontMask() -> LSET"""
        return _pcbnew.LSET_FrontMask()

    if _newclass:
        FrontMask = staticmethod(FrontMask)
    __swig_getmethods__["FrontMask"] = lambda x: FrontMask

    def BackMask():
        """BackMask() -> LSET"""
        return _pcbnew.LSET_BackMask()

    if _newclass:
        BackMask = staticmethod(BackMask)
    __swig_getmethods__["BackMask"] = lambda x: BackMask

    def UserMask():
        """UserMask() -> LSET"""
        return _pcbnew.LSET_UserMask()

    if _newclass:
        UserMask = staticmethod(UserMask)
    __swig_getmethods__["UserMask"] = lambda x: UserMask

    def CuStack(self):
        """CuStack(LSET self) -> LSEQ"""
        return _pcbnew.LSET_CuStack(self)


    def Technicals(self, *args):
        """
        Technicals(LSET self, LSET aSubToOmit) -> LSEQ
        Technicals(LSET self) -> LSEQ
        """
        return _pcbnew.LSET_Technicals(self, *args)


    def Users(self):
        """Users(LSET self) -> LSEQ"""
        return _pcbnew.LSET_Users(self)


    def UIOrder(self):
        """UIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_UIOrder(self)


    def Seq(self, *args):
        """
        Seq(LSET self, LAYER_ID const * aWishListSequence, unsigned int aCount) -> LSEQ
        Seq(LSET self) -> LSEQ
        """
        return _pcbnew.LSET_Seq(self, *args)


    def SeqStackupBottom2Top(self):
        """SeqStackupBottom2Top(LSET self) -> LSEQ"""
        return _pcbnew.LSET_SeqStackupBottom2Top(self)


    def FmtHex(self):
        """FmtHex(LSET self) -> string"""
        return _pcbnew.LSET_FmtHex(self)


    def ParseHex(self, aStart, aCount):
        """ParseHex(LSET self, char const * aStart, int aCount) -> int"""
        return _pcbnew.LSET_ParseHex(self, aStart, aCount)


    def FmtBin(self):
        """FmtBin(LSET self) -> string"""
        return _pcbnew.LSET_FmtBin(self)


    def ExtractLayer(self):
        """ExtractLayer(LSET self) -> LAYER_ID"""
        return _pcbnew.LSET_ExtractLayer(self)

    __swig_destroy__ = _pcbnew.delete_LSET
    __del__ = lambda self: None
LSET_swigregister = _pcbnew.LSET_swigregister
LSET_swigregister(LSET)

def LSET_Name(aLayerId):
    """LSET_Name(LAYER_ID aLayerId) -> wxChar const *"""
    return _pcbnew.LSET_Name(aLayerId)

def LSET_InternalCuMask():
    """LSET_InternalCuMask() -> LSET"""
    return _pcbnew.LSET_InternalCuMask()

def LSET_AllCuMask(*args):
    """
    AllCuMask(int aCuLayerCount) -> LSET
    LSET_AllCuMask() -> LSET
    """
    return _pcbnew.LSET_AllCuMask(*args)

def LSET_AllNonCuMask():
    """LSET_AllNonCuMask() -> LSET"""
    return _pcbnew.LSET_AllNonCuMask()

def LSET_AllLayersMask():
    """LSET_AllLayersMask() -> LSET"""
    return _pcbnew.LSET_AllLayersMask()

def LSET_FrontTechMask():
    """LSET_FrontTechMask() -> LSET"""
    return _pcbnew.LSET_FrontTechMask()

def LSET_BackTechMask():
    """LSET_BackTechMask() -> LSET"""
    return _pcbnew.LSET_BackTechMask()

def LSET_AllTechMask():
    """LSET_AllTechMask() -> LSET"""
    return _pcbnew.LSET_AllTechMask()

def LSET_FrontMask():
    """LSET_FrontMask() -> LSET"""
    return _pcbnew.LSET_FrontMask()

def LSET_BackMask():
    """LSET_BackMask() -> LSET"""
    return _pcbnew.LSET_BackMask()

def LSET_UserMask():
    """LSET_UserMask() -> LSET"""
    return _pcbnew.LSET_UserMask()


_pcbnew.VIAS_VISIBLE_swigconstant(_pcbnew)
VIAS_VISIBLE = _pcbnew.VIAS_VISIBLE

_pcbnew.VIA_MICROVIA_VISIBLE_swigconstant(_pcbnew)
VIA_MICROVIA_VISIBLE = _pcbnew.VIA_MICROVIA_VISIBLE

_pcbnew.VIA_BBLIND_VISIBLE_swigconstant(_pcbnew)
VIA_BBLIND_VISIBLE = _pcbnew.VIA_BBLIND_VISIBLE

_pcbnew.VIA_THROUGH_VISIBLE_swigconstant(_pcbnew)
VIA_THROUGH_VISIBLE = _pcbnew.VIA_THROUGH_VISIBLE

_pcbnew.NON_PLATED_VISIBLE_swigconstant(_pcbnew)
NON_PLATED_VISIBLE = _pcbnew.NON_PLATED_VISIBLE

_pcbnew.MOD_TEXT_FR_VISIBLE_swigconstant(_pcbnew)
MOD_TEXT_FR_VISIBLE = _pcbnew.MOD_TEXT_FR_VISIBLE

_pcbnew.MOD_TEXT_BK_VISIBLE_swigconstant(_pcbnew)
MOD_TEXT_BK_VISIBLE = _pcbnew.MOD_TEXT_BK_VISIBLE

_pcbnew.MOD_TEXT_INVISIBLE_swigconstant(_pcbnew)
MOD_TEXT_INVISIBLE = _pcbnew.MOD_TEXT_INVISIBLE

_pcbnew.ANCHOR_VISIBLE_swigconstant(_pcbnew)
ANCHOR_VISIBLE = _pcbnew.ANCHOR_VISIBLE

_pcbnew.PAD_FR_VISIBLE_swigconstant(_pcbnew)
PAD_FR_VISIBLE = _pcbnew.PAD_FR_VISIBLE

_pcbnew.PAD_BK_VISIBLE_swigconstant(_pcbnew)
PAD_BK_VISIBLE = _pcbnew.PAD_BK_VISIBLE

_pcbnew.RATSNEST_VISIBLE_swigconstant(_pcbnew)
RATSNEST_VISIBLE = _pcbnew.RATSNEST_VISIBLE

_pcbnew.GRID_VISIBLE_swigconstant(_pcbnew)
GRID_VISIBLE = _pcbnew.GRID_VISIBLE

_pcbnew.NO_CONNECTS_VISIBLE_swigconstant(_pcbnew)
NO_CONNECTS_VISIBLE = _pcbnew.NO_CONNECTS_VISIBLE

_pcbnew.MOD_FR_VISIBLE_swigconstant(_pcbnew)
MOD_FR_VISIBLE = _pcbnew.MOD_FR_VISIBLE

_pcbnew.MOD_BK_VISIBLE_swigconstant(_pcbnew)
MOD_BK_VISIBLE = _pcbnew.MOD_BK_VISIBLE

_pcbnew.MOD_VALUES_VISIBLE_swigconstant(_pcbnew)
MOD_VALUES_VISIBLE = _pcbnew.MOD_VALUES_VISIBLE

_pcbnew.MOD_REFERENCES_VISIBLE_swigconstant(_pcbnew)
MOD_REFERENCES_VISIBLE = _pcbnew.MOD_REFERENCES_VISIBLE

_pcbnew.TRACKS_VISIBLE_swigconstant(_pcbnew)
TRACKS_VISIBLE = _pcbnew.TRACKS_VISIBLE

_pcbnew.PADS_VISIBLE_swigconstant(_pcbnew)
PADS_VISIBLE = _pcbnew.PADS_VISIBLE

_pcbnew.PADS_HOLES_VISIBLE_swigconstant(_pcbnew)
PADS_HOLES_VISIBLE = _pcbnew.PADS_HOLES_VISIBLE

_pcbnew.VIAS_HOLES_VISIBLE_swigconstant(_pcbnew)
VIAS_HOLES_VISIBLE = _pcbnew.VIAS_HOLES_VISIBLE

_pcbnew.DRC_VISIBLE_swigconstant(_pcbnew)
DRC_VISIBLE = _pcbnew.DRC_VISIBLE

_pcbnew.WORKSHEET_swigconstant(_pcbnew)
WORKSHEET = _pcbnew.WORKSHEET

_pcbnew.GP_OVERLAY_swigconstant(_pcbnew)
GP_OVERLAY = _pcbnew.GP_OVERLAY

_pcbnew.END_PCB_VISIBLE_LIST_swigconstant(_pcbnew)
END_PCB_VISIBLE_LIST = _pcbnew.END_PCB_VISIBLE_LIST

_pcbnew.PAD_FR_NETNAMES_VISIBLE_swigconstant(_pcbnew)
PAD_FR_NETNAMES_VISIBLE = _pcbnew.PAD_FR_NETNAMES_VISIBLE

_pcbnew.PAD_BK_NETNAMES_VISIBLE_swigconstant(_pcbnew)
PAD_BK_NETNAMES_VISIBLE = _pcbnew.PAD_BK_NETNAMES_VISIBLE

_pcbnew.PADS_NETNAMES_VISIBLE_swigconstant(_pcbnew)
PADS_NETNAMES_VISIBLE = _pcbnew.PADS_NETNAMES_VISIBLE

_pcbnew.END_NETNAMES_VISIBLE_LIST_swigconstant(_pcbnew)
END_NETNAMES_VISIBLE_LIST = _pcbnew.END_NETNAMES_VISIBLE_LIST

def IsValidLayer(aLayerId):
    """IsValidLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsValidLayer(aLayerId)

def IsPcbLayer(aLayer):
    """IsPcbLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsPcbLayer(aLayer)

def IsCopperLayer(aLayerId):
    """IsCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsCopperLayer(aLayerId)

def IsNonCopperLayer(aLayerId):
    """IsNonCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsNonCopperLayer(aLayerId)

def IsUserLayer(aLayerId):
    """IsUserLayer(LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsUserLayer(aLayerId)

def IsFrontLayer(aLayerId):
    """IsFrontLayer(LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsFrontLayer(aLayerId)

def IsBackLayer(aLayerId):
    """IsBackLayer(LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsBackLayer(aLayerId)

def FlipLayer(oldlayer):
    """FlipLayer(LAYER_ID oldlayer) -> LAYER_ID"""
    return _pcbnew.FlipLayer(oldlayer)

def FlipLayerMask(aMask):
    """FlipLayerMask(LSET aMask) -> LSET"""
    return _pcbnew.FlipLayerMask(aMask)

def LayerMaskDescribe(aBoard, aMask):
    """LayerMaskDescribe(BOARD aBoard, LSET aMask) -> wxString"""
    return _pcbnew.LayerMaskDescribe(aBoard, aMask)

def GetNetnameLayer(aLayer):
    """GetNetnameLayer(int aLayer) -> int"""
    return _pcbnew.GetNetnameLayer(aLayer)

def IsNetnameLayer(aLayer):
    """IsNetnameLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsNetnameLayer(aLayer)

def ToLAYER_ID(aLayer):
    """ToLAYER_ID(int aLayer) -> LAYER_ID"""
    return _pcbnew.ToLAYER_ID(aLayer)
class PAD_DRAWINFO(_object):
    """Proxy of C++ PAD_DRAWINFO class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PAD_DRAWINFO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PAD_DRAWINFO, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_DrawPanel"] = _pcbnew.PAD_DRAWINFO_m_DrawPanel_set
    __swig_getmethods__["m_DrawPanel"] = _pcbnew.PAD_DRAWINFO_m_DrawPanel_get
    if _newclass:
        m_DrawPanel = _swig_property(_pcbnew.PAD_DRAWINFO_m_DrawPanel_get, _pcbnew.PAD_DRAWINFO_m_DrawPanel_set)
    __swig_setmethods__["m_DrawMode"] = _pcbnew.PAD_DRAWINFO_m_DrawMode_set
    __swig_getmethods__["m_DrawMode"] = _pcbnew.PAD_DRAWINFO_m_DrawMode_get
    if _newclass:
        m_DrawMode = _swig_property(_pcbnew.PAD_DRAWINFO_m_DrawMode_get, _pcbnew.PAD_DRAWINFO_m_DrawMode_set)
    __swig_setmethods__["m_Color"] = _pcbnew.PAD_DRAWINFO_m_Color_set
    __swig_getmethods__["m_Color"] = _pcbnew.PAD_DRAWINFO_m_Color_get
    if _newclass:
        m_Color = _swig_property(_pcbnew.PAD_DRAWINFO_m_Color_get, _pcbnew.PAD_DRAWINFO_m_Color_set)
    __swig_setmethods__["m_HoleColor"] = _pcbnew.PAD_DRAWINFO_m_HoleColor_set
    __swig_getmethods__["m_HoleColor"] = _pcbnew.PAD_DRAWINFO_m_HoleColor_get
    if _newclass:
        m_HoleColor = _swig_property(_pcbnew.PAD_DRAWINFO_m_HoleColor_get, _pcbnew.PAD_DRAWINFO_m_HoleColor_set)
    __swig_setmethods__["m_NPHoleColor"] = _pcbnew.PAD_DRAWINFO_m_NPHoleColor_set
    __swig_getmethods__["m_NPHoleColor"] = _pcbnew.PAD_DRAWINFO_m_NPHoleColor_get
    if _newclass:
        m_NPHoleColor = _swig_property(_pcbnew.PAD_DRAWINFO_m_NPHoleColor_get, _pcbnew.PAD_DRAWINFO_m_NPHoleColor_set)
    __swig_setmethods__["m_PadClearance"] = _pcbnew.PAD_DRAWINFO_m_PadClearance_set
    __swig_getmethods__["m_PadClearance"] = _pcbnew.PAD_DRAWINFO_m_PadClearance_get
    if _newclass:
        m_PadClearance = _swig_property(_pcbnew.PAD_DRAWINFO_m_PadClearance_get, _pcbnew.PAD_DRAWINFO_m_PadClearance_set)
    __swig_setmethods__["m_Mask_margin"] = _pcbnew.PAD_DRAWINFO_m_Mask_margin_set
    __swig_getmethods__["m_Mask_margin"] = _pcbnew.PAD_DRAWINFO_m_Mask_margin_get
    if _newclass:
        m_Mask_margin = _swig_property(_pcbnew.PAD_DRAWINFO_m_Mask_margin_get, _pcbnew.PAD_DRAWINFO_m_Mask_margin_set)
    __swig_setmethods__["m_Display_padnum"] = _pcbnew.PAD_DRAWINFO_m_Display_padnum_set
    __swig_getmethods__["m_Display_padnum"] = _pcbnew.PAD_DRAWINFO_m_Display_padnum_get
    if _newclass:
        m_Display_padnum = _swig_property(_pcbnew.PAD_DRAWINFO_m_Display_padnum_get, _pcbnew.PAD_DRAWINFO_m_Display_padnum_set)
    __swig_setmethods__["m_Display_netname"] = _pcbnew.PAD_DRAWINFO_m_Display_netname_set
    __swig_getmethods__["m_Display_netname"] = _pcbnew.PAD_DRAWINFO_m_Display_netname_get
    if _newclass:
        m_Display_netname = _swig_property(_pcbnew.PAD_DRAWINFO_m_Display_netname_get, _pcbnew.PAD_DRAWINFO_m_Display_netname_set)
    __swig_setmethods__["m_ShowPadFilled"] = _pcbnew.PAD_DRAWINFO_m_ShowPadFilled_set
    __swig_getmethods__["m_ShowPadFilled"] = _pcbnew.PAD_DRAWINFO_m_ShowPadFilled_get
    if _newclass:
        m_ShowPadFilled = _swig_property(_pcbnew.PAD_DRAWINFO_m_ShowPadFilled_get, _pcbnew.PAD_DRAWINFO_m_ShowPadFilled_set)
    __swig_setmethods__["m_ShowNCMark"] = _pcbnew.PAD_DRAWINFO_m_ShowNCMark_set
    __swig_getmethods__["m_ShowNCMark"] = _pcbnew.PAD_DRAWINFO_m_ShowNCMark_get
    if _newclass:
        m_ShowNCMark = _swig_property(_pcbnew.PAD_DRAWINFO_m_ShowNCMark_get, _pcbnew.PAD_DRAWINFO_m_ShowNCMark_set)
    __swig_setmethods__["m_ShowNotPlatedHole"] = _pcbnew.PAD_DRAWINFO_m_ShowNotPlatedHole_set
    __swig_getmethods__["m_ShowNotPlatedHole"] = _pcbnew.PAD_DRAWINFO_m_ShowNotPlatedHole_get
    if _newclass:
        m_ShowNotPlatedHole = _swig_property(_pcbnew.PAD_DRAWINFO_m_ShowNotPlatedHole_get, _pcbnew.PAD_DRAWINFO_m_ShowNotPlatedHole_set)
    __swig_setmethods__["m_IsPrinting"] = _pcbnew.PAD_DRAWINFO_m_IsPrinting_set
    __swig_getmethods__["m_IsPrinting"] = _pcbnew.PAD_DRAWINFO_m_IsPrinting_get
    if _newclass:
        m_IsPrinting = _swig_property(_pcbnew.PAD_DRAWINFO_m_IsPrinting_get, _pcbnew.PAD_DRAWINFO_m_IsPrinting_set)
    __swig_setmethods__["m_Offset"] = _pcbnew.PAD_DRAWINFO_m_Offset_set
    __swig_getmethods__["m_Offset"] = _pcbnew.PAD_DRAWINFO_m_Offset_get
    if _newclass:
        m_Offset = _swig_property(_pcbnew.PAD_DRAWINFO_m_Offset_get, _pcbnew.PAD_DRAWINFO_m_Offset_set)

    def __init__(self):
        """__init__(PAD_DRAWINFO self) -> PAD_DRAWINFO"""
        this = _pcbnew.new_PAD_DRAWINFO()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PAD_DRAWINFO
    __del__ = lambda self: None
PAD_DRAWINFO_swigregister = _pcbnew.PAD_DRAWINFO_swigregister
PAD_DRAWINFO_swigregister(PAD_DRAWINFO)

class D_PAD(BOARD_CONNECTED_ITEM):
    """Proxy of C++ D_PAD class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, D_PAD, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, D_PAD, name)
    __repr__ = _swig_repr

    def __init__(self, parent):
        """__init__(D_PAD self, MODULE parent) -> D_PAD"""
        this = _pcbnew.new_D_PAD(parent)
        try:
            self.this.append(this)
        except:
            self.this = this

    def StandardMask():
        """StandardMask() -> LSET"""
        return _pcbnew.D_PAD_StandardMask()

    if _newclass:
        StandardMask = staticmethod(StandardMask)
    __swig_getmethods__["StandardMask"] = lambda x: StandardMask

    def SMDMask():
        """SMDMask() -> LSET"""
        return _pcbnew.D_PAD_SMDMask()

    if _newclass:
        SMDMask = staticmethod(SMDMask)
    __swig_getmethods__["SMDMask"] = lambda x: SMDMask

    def ConnSMDMask():
        """ConnSMDMask() -> LSET"""
        return _pcbnew.D_PAD_ConnSMDMask()

    if _newclass:
        ConnSMDMask = staticmethod(ConnSMDMask)
    __swig_getmethods__["ConnSMDMask"] = lambda x: ConnSMDMask

    def UnplatedHoleMask():
        """UnplatedHoleMask() -> LSET"""
        return _pcbnew.D_PAD_UnplatedHoleMask()

    if _newclass:
        UnplatedHoleMask = staticmethod(UnplatedHoleMask)
    __swig_getmethods__["UnplatedHoleMask"] = lambda x: UnplatedHoleMask

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.D_PAD_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def Copy(self, source):
        """Copy(D_PAD self, D_PAD source)"""
        return _pcbnew.D_PAD_Copy(self, source)


    def Next(self):
        """Next(D_PAD self) -> D_PAD"""
        return _pcbnew.D_PAD_Next(self)


    def GetParent(self):
        """GetParent(D_PAD self) -> MODULE"""
        return _pcbnew.D_PAD_GetParent(self)


    def SetPadName(self, name):
        """SetPadName(D_PAD self, wxString const & name)"""
        return _pcbnew.D_PAD_SetPadName(self, name)


    def GetPadName(self):
        """GetPadName(D_PAD self) -> wxString const"""
        return _pcbnew.D_PAD_GetPadName(self)


    def IncrementItemReference(self):
        """IncrementItemReference(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_IncrementItemReference(self)


    def IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps):
        """IncrementPadName(D_PAD self, bool aSkipUnconnectable, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.D_PAD_IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps)


    def PadNameEqual(self, other):
        """PadNameEqual(D_PAD self, D_PAD other) -> bool"""
        return _pcbnew.D_PAD_PadNameEqual(self, other)


    def GetShape(self):
        """GetShape(D_PAD self) -> PAD_SHAPE_T"""
        return _pcbnew.D_PAD_GetShape(self)


    def SetShape(self, aShape):
        """SetShape(D_PAD self, PAD_SHAPE_T aShape)"""
        return _pcbnew.D_PAD_SetShape(self, aShape)


    def SetPosition(self, aPos):
        """SetPosition(D_PAD self, wxPoint aPos)"""
        return _pcbnew.D_PAD_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_GetPosition(self)


    def SetY(self, y):
        """SetY(D_PAD self, int y)"""
        return _pcbnew.D_PAD_SetY(self, y)


    def SetX(self, x):
        """SetX(D_PAD self, int x)"""
        return _pcbnew.D_PAD_SetX(self, x)


    def SetPos0(self, aPos):
        """SetPos0(D_PAD self, wxPoint aPos)"""
        return _pcbnew.D_PAD_SetPos0(self, aPos)


    def GetPos0(self):
        """GetPos0(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_GetPos0(self)


    def SetY0(self, y):
        """SetY0(D_PAD self, int y)"""
        return _pcbnew.D_PAD_SetY0(self, y)


    def SetX0(self, x):
        """SetX0(D_PAD self, int x)"""
        return _pcbnew.D_PAD_SetX0(self, x)


    def SetSize(self, aSize):
        """SetSize(D_PAD self, wxSize aSize)"""
        return _pcbnew.D_PAD_SetSize(self, aSize)


    def GetSize(self):
        """GetSize(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetSize(self)


    def SetDelta(self, aSize):
        """SetDelta(D_PAD self, wxSize aSize)"""
        return _pcbnew.D_PAD_SetDelta(self, aSize)


    def GetDelta(self):
        """GetDelta(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetDelta(self)


    def SetDrillSize(self, aSize):
        """SetDrillSize(D_PAD self, wxSize aSize)"""
        return _pcbnew.D_PAD_SetDrillSize(self, aSize)


    def GetDrillSize(self):
        """GetDrillSize(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetDrillSize(self)


    def SetOffset(self, aOffset):
        """SetOffset(D_PAD self, wxPoint aOffset)"""
        return _pcbnew.D_PAD_SetOffset(self, aOffset)


    def GetOffset(self):
        """GetOffset(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_GetOffset(self)


    def Flip(self, aCentre):
        """Flip(D_PAD self, wxPoint aCentre)"""
        return _pcbnew.D_PAD_Flip(self, aCentre)


    def SetOrientation(self, aAngle):
        """SetOrientation(D_PAD self, double aAngle)"""
        return _pcbnew.D_PAD_SetOrientation(self, aAngle)


    def GetOrientation(self):
        """GetOrientation(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientation(self)


    def SetDrillShape(self, aDrillShape):
        """SetDrillShape(D_PAD self, PAD_DRILL_SHAPE_T aDrillShape)"""
        return _pcbnew.D_PAD_SetDrillShape(self, aDrillShape)


    def GetDrillShape(self):
        """GetDrillShape(D_PAD self) -> PAD_DRILL_SHAPE_T"""
        return _pcbnew.D_PAD_GetDrillShape(self)


    def GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth):
        """GetOblongDrillGeometry(D_PAD self, wxPoint aStartPoint, wxPoint aEndPoint, int & aWidth)"""
        return _pcbnew.D_PAD_GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth)


    def SetLayerSet(self, aLayerMask):
        """SetLayerSet(D_PAD self, LSET aLayerMask)"""
        return _pcbnew.D_PAD_SetLayerSet(self, aLayerMask)


    def GetLayerSet(self):
        """GetLayerSet(D_PAD self) -> LSET"""
        return _pcbnew.D_PAD_GetLayerSet(self)


    def SetAttribute(self, aAttribute):
        """SetAttribute(D_PAD self, PAD_ATTR_T aAttribute)"""
        return _pcbnew.D_PAD_SetAttribute(self, aAttribute)


    def GetAttribute(self):
        """GetAttribute(D_PAD self) -> PAD_ATTR_T"""
        return _pcbnew.D_PAD_GetAttribute(self)


    def SetPadToDieLength(self, aLength):
        """SetPadToDieLength(D_PAD self, int aLength)"""
        return _pcbnew.D_PAD_SetPadToDieLength(self, aLength)


    def GetPadToDieLength(self):
        """GetPadToDieLength(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetPadToDieLength(self)


    def GetLocalSolderMaskMargin(self):
        """GetLocalSolderMaskMargin(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetLocalSolderMaskMargin(self)


    def SetLocalSolderMaskMargin(self, aMargin):
        """SetLocalSolderMaskMargin(D_PAD self, int aMargin)"""
        return _pcbnew.D_PAD_SetLocalSolderMaskMargin(self, aMargin)


    def GetLocalClearance(self):
        """GetLocalClearance(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetLocalClearance(self)


    def SetLocalClearance(self, aClearance):
        """SetLocalClearance(D_PAD self, int aClearance)"""
        return _pcbnew.D_PAD_SetLocalClearance(self, aClearance)


    def GetLocalSolderPasteMargin(self):
        """GetLocalSolderPasteMargin(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetLocalSolderPasteMargin(self)


    def SetLocalSolderPasteMargin(self, aMargin):
        """SetLocalSolderPasteMargin(D_PAD self, int aMargin)"""
        return _pcbnew.D_PAD_SetLocalSolderPasteMargin(self, aMargin)


    def GetLocalSolderPasteMarginRatio(self):
        """GetLocalSolderPasteMarginRatio(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetLocalSolderPasteMarginRatio(self)


    def SetLocalSolderPasteMarginRatio(self, aRatio):
        """SetLocalSolderPasteMarginRatio(D_PAD self, double aRatio)"""
        return _pcbnew.D_PAD_SetLocalSolderPasteMarginRatio(self, aRatio)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygon(D_PAD self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.D_PAD_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def GetClearance(self, aItem=None):
        """
        GetClearance(D_PAD self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(D_PAD self) -> int
        """
        return _pcbnew.D_PAD_GetClearance(self, aItem)


    def GetSolderMaskMargin(self):
        """GetSolderMaskMargin(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetSolderMaskMargin(self)


    def GetSolderPasteMargin(self):
        """GetSolderPasteMargin(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetSolderPasteMargin(self)


    def SetZoneConnection(self, aType):
        """SetZoneConnection(D_PAD self, ZoneConnection aType)"""
        return _pcbnew.D_PAD_SetZoneConnection(self, aType)


    def GetZoneConnection(self):
        """GetZoneConnection(D_PAD self) -> ZoneConnection"""
        return _pcbnew.D_PAD_GetZoneConnection(self)


    def SetThermalWidth(self, aWidth):
        """SetThermalWidth(D_PAD self, int aWidth)"""
        return _pcbnew.D_PAD_SetThermalWidth(self, aWidth)


    def GetThermalWidth(self):
        """GetThermalWidth(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetThermalWidth(self)


    def SetThermalGap(self, aGap):
        """SetThermalGap(D_PAD self, int aGap)"""
        return _pcbnew.D_PAD_SetThermalGap(self, aGap)


    def GetThermalGap(self):
        """GetThermalGap(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetThermalGap(self)


    def Draw(self, *args):
        """
        Draw(D_PAD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(D_PAD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.D_PAD_Draw(self, *args)


    def DrawShape(self, aClipBox, aDC, aDrawInfo):
        """DrawShape(D_PAD self, EDA_RECT aClipBox, wxDC * aDC, PAD_DRAWINFO aDrawInfo)"""
        return _pcbnew.D_PAD_DrawShape(self, aClipBox, aDC, aDrawInfo)


    def BuildPadPolygon(self, aCoord, aInflateValue, aRotation):
        """BuildPadPolygon(D_PAD self, wxPoint aCoord, wxSize aInflateValue, double aRotation)"""
        return _pcbnew.D_PAD_BuildPadPolygon(self, aCoord, aInflateValue, aRotation)


    def BuildPadShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle, aCorrectionFactor):
        """BuildPadShapePolygon(D_PAD self, SHAPE_POLY_SET & aCornerBuffer, wxSize aInflateValue, int aSegmentsPerCircle, double aCorrectionFactor)"""
        return _pcbnew.D_PAD_BuildPadShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle, aCorrectionFactor)


    def BuildPadDrillShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle):
        """BuildPadDrillShapePolygon(D_PAD self, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aSegmentsPerCircle) -> bool"""
        return _pcbnew.D_PAD_BuildPadDrillShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle)


    def BuildSegmentFromOvalShape(self, aSegStart, aSegEnd, aRotation, aMargin):
        """BuildSegmentFromOvalShape(D_PAD self, wxPoint aSegStart, wxPoint aSegEnd, double aRotation, wxSize aMargin) -> int"""
        return _pcbnew.D_PAD_BuildSegmentFromOvalShape(self, aSegStart, aSegEnd, aRotation, aMargin)


    def StringPadName(self, text):
        """StringPadName(D_PAD self, wxString & text)"""
        return _pcbnew.D_PAD_StringPadName(self, text)


    def GetBoundingRadius(self):
        """GetBoundingRadius(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetBoundingRadius(self)


    def ShapePos(self):
        """ShapePos(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_ShapePos(self)


    def GetSubRatsnest(self):
        """GetSubRatsnest(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetSubRatsnest(self)


    def SetSubRatsnest(self, aSubRatsnest):
        """SetSubRatsnest(D_PAD self, int aSubRatsnest)"""
        return _pcbnew.D_PAD_SetSubRatsnest(self, aSubRatsnest)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(D_PAD self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.D_PAD_GetMsgPanelInfo(self, aList)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(D_PAD self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.D_PAD_IsOnLayer(self, aLayer)


    def HitTest(self, aPosition):
        """HitTest(D_PAD self, wxPoint aPosition) -> bool"""
        return _pcbnew.D_PAD_HitTest(self, aPosition)


    def GetClass(self):
        """GetClass(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_GetClass(self)


    def GetBoundingBox(self):
        """GetBoundingBox(D_PAD self) -> EDA_RECT"""
        return _pcbnew.D_PAD_GetBoundingBox(self)


    def SetDrawCoord(self):
        """SetDrawCoord(D_PAD self)"""
        return _pcbnew.D_PAD_SetDrawCoord(self)


    def SetLocalCoord(self):
        """SetLocalCoord(D_PAD self)"""
        return _pcbnew.D_PAD_SetLocalCoord(self)


    def Compare(padref, padcmp):
        """Compare(D_PAD padref, D_PAD padcmp) -> int"""
        return _pcbnew.D_PAD_Compare(padref, padcmp)

    if _newclass:
        Compare = staticmethod(Compare)
    __swig_getmethods__["Compare"] = lambda x: Compare

    def Move(self, aMoveVector):
        """Move(D_PAD self, wxPoint aMoveVector)"""
        return _pcbnew.D_PAD_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(D_PAD self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.D_PAD_Rotate(self, aRotCentre, aAngle)


    def GetSelectMenuText(self):
        """GetSelectMenuText(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(D_PAD self) -> BITMAP_DEF"""
        return _pcbnew.D_PAD_GetMenuImage(self)


    def ShowPadShape(self):
        """ShowPadShape(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_ShowPadShape(self)


    def ShowPadAttr(self):
        """ShowPadAttr(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_ShowPadAttr(self)


    def AppendConfigs(self, aResult):
        """AppendConfigs(D_PAD self, PARAM_CFG_ARRAY * aResult)"""
        return _pcbnew.D_PAD_AppendConfigs(self, aResult)


    def Clone(self):
        """Clone(D_PAD self) -> EDA_ITEM"""
        return _pcbnew.D_PAD_Clone(self)


    def Duplicate(self):
        """Duplicate(D_PAD self) -> D_PAD"""
        return _pcbnew.D_PAD_Duplicate(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(D_PAD self, int [] aLayers, int & aCount)"""
        return _pcbnew.D_PAD_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(D_PAD self, int aLayer) -> unsigned int"""
        return _pcbnew.D_PAD_ViewGetLOD(self, aLayer)


    def ViewBBox(self):
        """ViewBBox(D_PAD self) -> BOX2I const"""
        return _pcbnew.D_PAD_ViewBBox(self)


    def CopyNetlistSettings(self, aPad):
        """CopyNetlistSettings(D_PAD self, D_PAD aPad)"""
        return _pcbnew.D_PAD_CopyNetlistSettings(self, aPad)

    __swig_destroy__ = _pcbnew.delete_D_PAD
    __del__ = lambda self: None
D_PAD_swigregister = _pcbnew.D_PAD_swigregister
D_PAD_swigregister(D_PAD)

def D_PAD_StandardMask():
    """D_PAD_StandardMask() -> LSET"""
    return _pcbnew.D_PAD_StandardMask()

def D_PAD_SMDMask():
    """D_PAD_SMDMask() -> LSET"""
    return _pcbnew.D_PAD_SMDMask()

def D_PAD_ConnSMDMask():
    """D_PAD_ConnSMDMask() -> LSET"""
    return _pcbnew.D_PAD_ConnSMDMask()

def D_PAD_UnplatedHoleMask():
    """D_PAD_UnplatedHoleMask() -> LSET"""
    return _pcbnew.D_PAD_UnplatedHoleMask()

def D_PAD_ClassOf(aItem):
    """D_PAD_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.D_PAD_ClassOf(aItem)

def D_PAD_Compare(padref, padcmp):
    """D_PAD_Compare(D_PAD padref, D_PAD padcmp) -> int"""
    return _pcbnew.D_PAD_Compare(padref, padcmp)


_pcbnew.PAD_CIRCLE_swigconstant(_pcbnew)
PAD_CIRCLE = _pcbnew.PAD_CIRCLE

_pcbnew.PAD_ROUND_swigconstant(_pcbnew)
PAD_ROUND = _pcbnew.PAD_ROUND

_pcbnew.PAD_SHAPE_CIRCLE_swigconstant(_pcbnew)
PAD_SHAPE_CIRCLE = _pcbnew.PAD_SHAPE_CIRCLE

_pcbnew.PAD_RECT_swigconstant(_pcbnew)
PAD_RECT = _pcbnew.PAD_RECT

_pcbnew.PAD_SHAPE_RECT_swigconstant(_pcbnew)
PAD_SHAPE_RECT = _pcbnew.PAD_SHAPE_RECT

_pcbnew.PAD_OVAL_swigconstant(_pcbnew)
PAD_OVAL = _pcbnew.PAD_OVAL

_pcbnew.PAD_SHAPE_OVAL_swigconstant(_pcbnew)
PAD_SHAPE_OVAL = _pcbnew.PAD_SHAPE_OVAL

_pcbnew.PAD_TRAPEZOID_swigconstant(_pcbnew)
PAD_TRAPEZOID = _pcbnew.PAD_TRAPEZOID

_pcbnew.PAD_SHAPE_TRAPEZOID_swigconstant(_pcbnew)
PAD_SHAPE_TRAPEZOID = _pcbnew.PAD_SHAPE_TRAPEZOID

_pcbnew.PAD_DRILL_CIRCLE_swigconstant(_pcbnew)
PAD_DRILL_CIRCLE = _pcbnew.PAD_DRILL_CIRCLE

_pcbnew.PAD_DRILL_SHAPE_CIRCLE_swigconstant(_pcbnew)
PAD_DRILL_SHAPE_CIRCLE = _pcbnew.PAD_DRILL_SHAPE_CIRCLE

_pcbnew.PAD_DRILL_OBLONG_swigconstant(_pcbnew)
PAD_DRILL_OBLONG = _pcbnew.PAD_DRILL_OBLONG

_pcbnew.PAD_DRILL_SHAPE_OBLONG_swigconstant(_pcbnew)
PAD_DRILL_SHAPE_OBLONG = _pcbnew.PAD_DRILL_SHAPE_OBLONG

_pcbnew.PAD_STANDARD_swigconstant(_pcbnew)
PAD_STANDARD = _pcbnew.PAD_STANDARD

_pcbnew.PAD_ATTRIB_STANDARD_swigconstant(_pcbnew)
PAD_ATTRIB_STANDARD = _pcbnew.PAD_ATTRIB_STANDARD

_pcbnew.PAD_SMD_swigconstant(_pcbnew)
PAD_SMD = _pcbnew.PAD_SMD

_pcbnew.PAD_ATTRIB_SMD_swigconstant(_pcbnew)
PAD_ATTRIB_SMD = _pcbnew.PAD_ATTRIB_SMD

_pcbnew.PAD_CONN_swigconstant(_pcbnew)
PAD_CONN = _pcbnew.PAD_CONN

_pcbnew.PAD_ATTRIB_CONN_swigconstant(_pcbnew)
PAD_ATTRIB_CONN = _pcbnew.PAD_ATTRIB_CONN

_pcbnew.PAD_HOLE_NOT_PLATED_swigconstant(_pcbnew)
PAD_HOLE_NOT_PLATED = _pcbnew.PAD_HOLE_NOT_PLATED

_pcbnew.PAD_ATTRIB_HOLE_NOT_PLATED_swigconstant(_pcbnew)
PAD_ATTRIB_HOLE_NOT_PLATED = _pcbnew.PAD_ATTRIB_HOLE_NOT_PLATED

_pcbnew.CH_VISIBLE_swigconstant(_pcbnew)
CH_VISIBLE = _pcbnew.CH_VISIBLE

_pcbnew.CH_UNROUTABLE_swigconstant(_pcbnew)
CH_UNROUTABLE = _pcbnew.CH_UNROUTABLE

_pcbnew.CH_ROUTE_REQ_swigconstant(_pcbnew)
CH_ROUTE_REQ = _pcbnew.CH_ROUTE_REQ

_pcbnew.CH_ACTIF_swigconstant(_pcbnew)
CH_ACTIF = _pcbnew.CH_ACTIF

_pcbnew.LOCAL_RATSNEST_ITEM_swigconstant(_pcbnew)
LOCAL_RATSNEST_ITEM = _pcbnew.LOCAL_RATSNEST_ITEM
class RATSNEST_ITEM(_object):
    """Proxy of C++ RATSNEST_ITEM class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RATSNEST_ITEM, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RATSNEST_ITEM, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Status"] = _pcbnew.RATSNEST_ITEM_m_Status_set
    __swig_getmethods__["m_Status"] = _pcbnew.RATSNEST_ITEM_m_Status_get
    if _newclass:
        m_Status = _swig_property(_pcbnew.RATSNEST_ITEM_m_Status_get, _pcbnew.RATSNEST_ITEM_m_Status_set)
    __swig_setmethods__["m_PadStart"] = _pcbnew.RATSNEST_ITEM_m_PadStart_set
    __swig_getmethods__["m_PadStart"] = _pcbnew.RATSNEST_ITEM_m_PadStart_get
    if _newclass:
        m_PadStart = _swig_property(_pcbnew.RATSNEST_ITEM_m_PadStart_get, _pcbnew.RATSNEST_ITEM_m_PadStart_set)
    __swig_setmethods__["m_PadEnd"] = _pcbnew.RATSNEST_ITEM_m_PadEnd_set
    __swig_getmethods__["m_PadEnd"] = _pcbnew.RATSNEST_ITEM_m_PadEnd_get
    if _newclass:
        m_PadEnd = _swig_property(_pcbnew.RATSNEST_ITEM_m_PadEnd_get, _pcbnew.RATSNEST_ITEM_m_PadEnd_set)
    __swig_setmethods__["m_Lenght"] = _pcbnew.RATSNEST_ITEM_m_Lenght_set
    __swig_getmethods__["m_Lenght"] = _pcbnew.RATSNEST_ITEM_m_Lenght_get
    if _newclass:
        m_Lenght = _swig_property(_pcbnew.RATSNEST_ITEM_m_Lenght_get, _pcbnew.RATSNEST_ITEM_m_Lenght_set)

    def __init__(self):
        """__init__(RATSNEST_ITEM self) -> RATSNEST_ITEM"""
        this = _pcbnew.new_RATSNEST_ITEM()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetNet(self):
        """GetNet(RATSNEST_ITEM self) -> int"""
        return _pcbnew.RATSNEST_ITEM_GetNet(self)


    def SetNet(self, aNetCode):
        """SetNet(RATSNEST_ITEM self, int aNetCode)"""
        return _pcbnew.RATSNEST_ITEM_SetNet(self, aNetCode)


    def IsVisible(self):
        """IsVisible(RATSNEST_ITEM self) -> bool"""
        return _pcbnew.RATSNEST_ITEM_IsVisible(self)


    def IsActive(self):
        """IsActive(RATSNEST_ITEM self) -> bool"""
        return _pcbnew.RATSNEST_ITEM_IsActive(self)


    def IsLocal(self):
        """IsLocal(RATSNEST_ITEM self) -> bool"""
        return _pcbnew.RATSNEST_ITEM_IsLocal(self)


    def Draw(self, panel, DC, aDrawMode, offset):
        """Draw(RATSNEST_ITEM self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)"""
        return _pcbnew.RATSNEST_ITEM_Draw(self, panel, DC, aDrawMode, offset)

    __swig_destroy__ = _pcbnew.delete_RATSNEST_ITEM
    __del__ = lambda self: None
RATSNEST_ITEM_swigregister = _pcbnew.RATSNEST_ITEM_swigregister
RATSNEST_ITEM_swigregister(RATSNEST_ITEM)

class NETINFO_MAPPING(_object):
    """Proxy of C++ NETINFO_MAPPING class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NETINFO_MAPPING, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NETINFO_MAPPING, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(NETINFO_MAPPING self) -> NETINFO_MAPPING"""
        this = _pcbnew.new_NETINFO_MAPPING()
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetBoard(self, aBoard):
        """SetBoard(NETINFO_MAPPING self, BOARD aBoard)"""
        return _pcbnew.NETINFO_MAPPING_SetBoard(self, aBoard)


    def Update(self):
        """Update(NETINFO_MAPPING self)"""
        return _pcbnew.NETINFO_MAPPING_Update(self)


    def Translate(self, aNetCode):
        """Translate(NETINFO_MAPPING self, int aNetCode) -> int"""
        return _pcbnew.NETINFO_MAPPING_Translate(self, aNetCode)


    def GetSize(self):
        """GetSize(NETINFO_MAPPING self) -> int"""
        return _pcbnew.NETINFO_MAPPING_GetSize(self)

    __swig_destroy__ = _pcbnew.delete_NETINFO_MAPPING
    __del__ = lambda self: None
NETINFO_MAPPING_swigregister = _pcbnew.NETINFO_MAPPING_swigregister
NETINFO_MAPPING_swigregister(NETINFO_MAPPING)

class NETINFO_LIST(_object):
    """Proxy of C++ NETINFO_LIST class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NETINFO_LIST, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NETINFO_LIST, name)
    __repr__ = _swig_repr

    def __init__(self, aParent):
        """__init__(NETINFO_LIST self, BOARD aParent) -> NETINFO_LIST"""
        this = _pcbnew.new_NETINFO_LIST(aParent)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETINFO_LIST
    __del__ = lambda self: None

    def GetNetItem(self, *args):
        """
        GetNetItem(NETINFO_LIST self, int aNetCode) -> NETINFO_ITEM
        GetNetItem(NETINFO_LIST self, wxString const & aNetName) -> NETINFO_ITEM
        """
        return _pcbnew.NETINFO_LIST_GetNetItem(self, *args)


    def GetNetCount(self):
        """GetNetCount(NETINFO_LIST self) -> unsigned int"""
        return _pcbnew.NETINFO_LIST_GetNetCount(self)


    def AppendNet(self, aNewElement):
        """AppendNet(NETINFO_LIST self, NETINFO_ITEM aNewElement)"""
        return _pcbnew.NETINFO_LIST_AppendNet(self, aNewElement)


    def GetPadCount(self):
        """GetPadCount(NETINFO_LIST self) -> unsigned int"""
        return _pcbnew.NETINFO_LIST_GetPadCount(self)


    def GetPad(self, aIdx):
        """GetPad(NETINFO_LIST self, unsigned int aIdx) -> D_PAD"""
        return _pcbnew.NETINFO_LIST_GetPad(self, aIdx)

    __swig_setmethods__["ORPHANED"] = _pcbnew.NETINFO_LIST_ORPHANED_set
    __swig_getmethods__["ORPHANED"] = _pcbnew.NETINFO_LIST_ORPHANED_get
    if _newclass:
        ORPHANED = _swig_property(_pcbnew.NETINFO_LIST_ORPHANED_get, _pcbnew.NETINFO_LIST_ORPHANED_set)
NETINFO_LIST_swigregister = _pcbnew.NETINFO_LIST_swigregister
NETINFO_LIST_swigregister(NETINFO_LIST)
NETINFO_LIST.UNCONNECTED = _pcbnew.cvar.NETINFO_LIST_UNCONNECTED
NETINFO_LIST.FORCE_ORPHANED = _pcbnew.cvar.NETINFO_LIST_FORCE_ORPHANED

class NETINFO_ITEM(_object):
    """Proxy of C++ NETINFO_ITEM class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NETINFO_ITEM, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NETINFO_ITEM, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_PadInNetList"] = _pcbnew.NETINFO_ITEM_m_PadInNetList_set
    __swig_getmethods__["m_PadInNetList"] = _pcbnew.NETINFO_ITEM_m_PadInNetList_get
    if _newclass:
        m_PadInNetList = _swig_property(_pcbnew.NETINFO_ITEM_m_PadInNetList_get, _pcbnew.NETINFO_ITEM_m_PadInNetList_set)
    __swig_setmethods__["m_RatsnestStartIdx"] = _pcbnew.NETINFO_ITEM_m_RatsnestStartIdx_set
    __swig_getmethods__["m_RatsnestStartIdx"] = _pcbnew.NETINFO_ITEM_m_RatsnestStartIdx_get
    if _newclass:
        m_RatsnestStartIdx = _swig_property(_pcbnew.NETINFO_ITEM_m_RatsnestStartIdx_get, _pcbnew.NETINFO_ITEM_m_RatsnestStartIdx_set)
    __swig_setmethods__["m_RatsnestEndIdx"] = _pcbnew.NETINFO_ITEM_m_RatsnestEndIdx_set
    __swig_getmethods__["m_RatsnestEndIdx"] = _pcbnew.NETINFO_ITEM_m_RatsnestEndIdx_get
    if _newclass:
        m_RatsnestEndIdx = _swig_property(_pcbnew.NETINFO_ITEM_m_RatsnestEndIdx_get, _pcbnew.NETINFO_ITEM_m_RatsnestEndIdx_set)

    def __init__(self, *args):
        """
        __init__(NETINFO_ITEM self, BOARD_ITEM aParent, wxString const & aNetName, int aNetCode=-1) -> NETINFO_ITEM
        __init__(NETINFO_ITEM self, BOARD_ITEM aParent, wxString const & aNetName) -> NETINFO_ITEM
        __init__(NETINFO_ITEM self, BOARD_ITEM aParent) -> NETINFO_ITEM
        """
        this = _pcbnew.new_NETINFO_ITEM(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETINFO_ITEM
    __del__ = lambda self: None

    def SetClass(self, aNetClass):
        """SetClass(NETINFO_ITEM self, NETCLASSPTR aNetClass)"""
        return _pcbnew.NETINFO_ITEM_SetClass(self, aNetClass)


    def GetNetClass(self):
        """GetNetClass(NETINFO_ITEM self) -> NETCLASSPTR"""
        return _pcbnew.NETINFO_ITEM_GetNetClass(self)


    def GetClassName(self):
        """GetClassName(NETINFO_ITEM self) -> wxString const &"""
        return _pcbnew.NETINFO_ITEM_GetClassName(self)


    def GetTrackWidth(self):
        """GetTrackWidth(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetTrackWidth(self)


    def GetViaSize(self):
        """GetViaSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetViaSize(self)


    def GetMicroViaSize(self):
        """GetMicroViaSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetMicroViaSize(self)


    def GetViaDrillSize(self):
        """GetViaDrillSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetViaDrillSize(self)


    def GetMicroViaDrillSize(self):
        """GetMicroViaDrillSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetMicroViaDrillSize(self)


    def GetClearance(self, aBoardItem):
        """GetClearance(NETINFO_ITEM self, BOARD_ITEM aBoardItem) -> int"""
        return _pcbnew.NETINFO_ITEM_GetClearance(self, aBoardItem)


    def Draw(self, panel, DC, aDrawMode, offset):
        """Draw(NETINFO_ITEM self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)"""
        return _pcbnew.NETINFO_ITEM_Draw(self, panel, DC, aDrawMode, offset)


    def GetNet(self):
        """GetNet(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetNet(self)


    def GetNodesCount(self):
        """GetNodesCount(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetNodesCount(self)


    def GetNetname(self):
        """GetNetname(NETINFO_ITEM self) -> wxString const &"""
        return _pcbnew.NETINFO_ITEM_GetNetname(self)


    def GetShortNetname(self):
        """GetShortNetname(NETINFO_ITEM self) -> wxString const &"""
        return _pcbnew.NETINFO_ITEM_GetShortNetname(self)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(NETINFO_ITEM self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.NETINFO_ITEM_GetMsgPanelInfo(self, aList)


    def Clear(self):
        """Clear(NETINFO_ITEM self)"""
        return _pcbnew.NETINFO_ITEM_Clear(self)

NETINFO_ITEM_swigregister = _pcbnew.NETINFO_ITEM_swigregister
NETINFO_ITEM_swigregister(NETINFO_ITEM)


_pcbnew.START_ON_PAD_swigconstant(_pcbnew)
START_ON_PAD = _pcbnew.START_ON_PAD

_pcbnew.END_ON_PAD_swigconstant(_pcbnew)
END_ON_PAD = _pcbnew.END_ON_PAD

_pcbnew.START_ON_TRACK_swigconstant(_pcbnew)
START_ON_TRACK = _pcbnew.START_ON_TRACK

_pcbnew.END_ON_TRACK_swigconstant(_pcbnew)
END_ON_TRACK = _pcbnew.END_ON_TRACK

_pcbnew.LISTE_PAD_OK_swigconstant(_pcbnew)
LISTE_PAD_OK = _pcbnew.LISTE_PAD_OK

_pcbnew.LISTE_RATSNEST_ITEM_OK_swigconstant(_pcbnew)
LISTE_RATSNEST_ITEM_OK = _pcbnew.LISTE_RATSNEST_ITEM_OK

_pcbnew.RATSNEST_ITEM_LOCAL_OK_swigconstant(_pcbnew)
RATSNEST_ITEM_LOCAL_OK = _pcbnew.RATSNEST_ITEM_LOCAL_OK

_pcbnew.CONNEXION_OK_swigconstant(_pcbnew)
CONNEXION_OK = _pcbnew.CONNEXION_OK

_pcbnew.NET_CODES_OK_swigconstant(_pcbnew)
NET_CODES_OK = _pcbnew.NET_CODES_OK

_pcbnew.DO_NOT_SHOW_GENERAL_RASTNEST_swigconstant(_pcbnew)
DO_NOT_SHOW_GENERAL_RASTNEST = _pcbnew.DO_NOT_SHOW_GENERAL_RASTNEST
class TEXTE_PCB(BOARD_ITEM, EDA_TEXT):
    """Proxy of C++ TEXTE_PCB class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM, EDA_TEXT]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TEXTE_PCB, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM, EDA_TEXT]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TEXTE_PCB, name)
    __repr__ = _swig_repr

    def __init__(self, parent):
        """__init__(TEXTE_PCB self, BOARD_ITEM parent) -> TEXTE_PCB"""
        this = _pcbnew.new_TEXTE_PCB(parent)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_TEXTE_PCB
    __del__ = lambda self: None

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TEXTE_PCB_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def GetPosition(self):
        """GetPosition(TEXTE_PCB self) -> wxPoint"""
        return _pcbnew.TEXTE_PCB_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(TEXTE_PCB self, wxPoint aPos)"""
        return _pcbnew.TEXTE_PCB_SetPosition(self, aPos)


    def Move(self, aMoveVector):
        """Move(TEXTE_PCB self, wxPoint aMoveVector)"""
        return _pcbnew.TEXTE_PCB_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(TEXTE_PCB self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TEXTE_PCB_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(TEXTE_PCB self, wxPoint aCentre)"""
        return _pcbnew.TEXTE_PCB_Flip(self, aCentre)


    def Copy(self, source):
        """Copy(TEXTE_PCB self, TEXTE_PCB source)"""
        return _pcbnew.TEXTE_PCB_Copy(self, source)


    def Draw(self, *args):
        """
        Draw(TEXTE_PCB self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(TEXTE_PCB self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TEXTE_PCB_Draw(self, *args)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(TEXTE_PCB self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TEXTE_PCB_GetMsgPanelInfo(self, aList)


    def HitTest(self, *args):
        """
        HitTest(TEXTE_PCB self, wxPoint aPosition) -> bool
        HitTest(TEXTE_PCB self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(TEXTE_PCB self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(TEXTE_PCB self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.TEXTE_PCB_HitTest(self, *args)


    def GetClass(self):
        """GetClass(TEXTE_PCB self) -> wxString"""
        return _pcbnew.TEXTE_PCB_GetClass(self)


    def TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue):
        """TransformBoundingBoxWithClearanceToPolygon(TEXTE_PCB self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue)"""
        return _pcbnew.TEXTE_PCB_TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue)


    def TransformShapeWithClearanceToPolygonSet(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygonSet(TEXTE_PCB self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.TEXTE_PCB_TransformShapeWithClearanceToPolygonSet(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def GetSelectMenuText(self):
        """GetSelectMenuText(TEXTE_PCB self) -> wxString"""
        return _pcbnew.TEXTE_PCB_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TEXTE_PCB self) -> BITMAP_DEF"""
        return _pcbnew.TEXTE_PCB_GetMenuImage(self)


    def GetBoundingBox(self):
        """GetBoundingBox(TEXTE_PCB self) -> EDA_RECT"""
        return _pcbnew.TEXTE_PCB_GetBoundingBox(self)


    def Clone(self):
        """Clone(TEXTE_PCB self) -> EDA_ITEM"""
        return _pcbnew.TEXTE_PCB_Clone(self)

TEXTE_PCB_swigregister = _pcbnew.TEXTE_PCB_swigregister
TEXTE_PCB_swigregister(TEXTE_PCB)

def TEXTE_PCB_ClassOf(aItem):
    """TEXTE_PCB_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.TEXTE_PCB_ClassOf(aItem)

class DIMENSION(BOARD_ITEM):
    """Proxy of C++ DIMENSION class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DIMENSION, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DIMENSION, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_crossBarO"] = _pcbnew.DIMENSION_m_crossBarO_set
    __swig_getmethods__["m_crossBarO"] = _pcbnew.DIMENSION_m_crossBarO_get
    if _newclass:
        m_crossBarO = _swig_property(_pcbnew.DIMENSION_m_crossBarO_get, _pcbnew.DIMENSION_m_crossBarO_set)
    __swig_setmethods__["m_crossBarF"] = _pcbnew.DIMENSION_m_crossBarF_set
    __swig_getmethods__["m_crossBarF"] = _pcbnew.DIMENSION_m_crossBarF_get
    if _newclass:
        m_crossBarF = _swig_property(_pcbnew.DIMENSION_m_crossBarF_get, _pcbnew.DIMENSION_m_crossBarF_set)
    __swig_setmethods__["m_featureLineGO"] = _pcbnew.DIMENSION_m_featureLineGO_set
    __swig_getmethods__["m_featureLineGO"] = _pcbnew.DIMENSION_m_featureLineGO_get
    if _newclass:
        m_featureLineGO = _swig_property(_pcbnew.DIMENSION_m_featureLineGO_get, _pcbnew.DIMENSION_m_featureLineGO_set)
    __swig_setmethods__["m_featureLineGF"] = _pcbnew.DIMENSION_m_featureLineGF_set
    __swig_getmethods__["m_featureLineGF"] = _pcbnew.DIMENSION_m_featureLineGF_get
    if _newclass:
        m_featureLineGF = _swig_property(_pcbnew.DIMENSION_m_featureLineGF_get, _pcbnew.DIMENSION_m_featureLineGF_set)
    __swig_setmethods__["m_featureLineDO"] = _pcbnew.DIMENSION_m_featureLineDO_set
    __swig_getmethods__["m_featureLineDO"] = _pcbnew.DIMENSION_m_featureLineDO_get
    if _newclass:
        m_featureLineDO = _swig_property(_pcbnew.DIMENSION_m_featureLineDO_get, _pcbnew.DIMENSION_m_featureLineDO_set)
    __swig_setmethods__["m_featureLineDF"] = _pcbnew.DIMENSION_m_featureLineDF_set
    __swig_getmethods__["m_featureLineDF"] = _pcbnew.DIMENSION_m_featureLineDF_get
    if _newclass:
        m_featureLineDF = _swig_property(_pcbnew.DIMENSION_m_featureLineDF_get, _pcbnew.DIMENSION_m_featureLineDF_set)
    __swig_setmethods__["m_arrowD1F"] = _pcbnew.DIMENSION_m_arrowD1F_set
    __swig_getmethods__["m_arrowD1F"] = _pcbnew.DIMENSION_m_arrowD1F_get
    if _newclass:
        m_arrowD1F = _swig_property(_pcbnew.DIMENSION_m_arrowD1F_get, _pcbnew.DIMENSION_m_arrowD1F_set)
    __swig_setmethods__["m_arrowD2F"] = _pcbnew.DIMENSION_m_arrowD2F_set
    __swig_getmethods__["m_arrowD2F"] = _pcbnew.DIMENSION_m_arrowD2F_get
    if _newclass:
        m_arrowD2F = _swig_property(_pcbnew.DIMENSION_m_arrowD2F_get, _pcbnew.DIMENSION_m_arrowD2F_set)
    __swig_setmethods__["m_arrowG1F"] = _pcbnew.DIMENSION_m_arrowG1F_set
    __swig_getmethods__["m_arrowG1F"] = _pcbnew.DIMENSION_m_arrowG1F_get
    if _newclass:
        m_arrowG1F = _swig_property(_pcbnew.DIMENSION_m_arrowG1F_get, _pcbnew.DIMENSION_m_arrowG1F_set)
    __swig_setmethods__["m_arrowG2F"] = _pcbnew.DIMENSION_m_arrowG2F_set
    __swig_getmethods__["m_arrowG2F"] = _pcbnew.DIMENSION_m_arrowG2F_get
    if _newclass:
        m_arrowG2F = _swig_property(_pcbnew.DIMENSION_m_arrowG2F_get, _pcbnew.DIMENSION_m_arrowG2F_set)

    def __init__(self, aParent):
        """__init__(DIMENSION self, BOARD_ITEM aParent) -> DIMENSION"""
        this = _pcbnew.new_DIMENSION(aParent)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_DIMENSION
    __del__ = lambda self: None

    def SetValue(self, aValue):
        """SetValue(DIMENSION self, int aValue)"""
        return _pcbnew.DIMENSION_SetValue(self, aValue)


    def GetValue(self):
        """GetValue(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetValue(self)


    def GetPosition(self):
        """GetPosition(DIMENSION self) -> wxPoint"""
        return _pcbnew.DIMENSION_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(DIMENSION self, wxPoint aPos)"""
        return _pcbnew.DIMENSION_SetPosition(self, aPos)


    def SetTextSize(self, aTextSize):
        """SetTextSize(DIMENSION self, wxSize aTextSize)"""
        return _pcbnew.DIMENSION_SetTextSize(self, aTextSize)


    def SetLayer(self, aLayer):
        """SetLayer(DIMENSION self, LAYER_ID aLayer)"""
        return _pcbnew.DIMENSION_SetLayer(self, aLayer)


    def SetShape(self, aShape):
        """SetShape(DIMENSION self, int aShape)"""
        return _pcbnew.DIMENSION_SetShape(self, aShape)


    def GetShape(self):
        """GetShape(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetShape(self)


    def GetWidth(self):
        """GetWidth(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetWidth(self)


    def SetWidth(self, aWidth):
        """SetWidth(DIMENSION self, int aWidth)"""
        return _pcbnew.DIMENSION_SetWidth(self, aWidth)


    def SetOrigin(self, aOrigin):
        """SetOrigin(DIMENSION self, wxPoint aOrigin)"""
        return _pcbnew.DIMENSION_SetOrigin(self, aOrigin)


    def GetOrigin(self):
        """GetOrigin(DIMENSION self) -> wxPoint"""
        return _pcbnew.DIMENSION_GetOrigin(self)


    def SetEnd(self, aEnd):
        """SetEnd(DIMENSION self, wxPoint aEnd)"""
        return _pcbnew.DIMENSION_SetEnd(self, aEnd)


    def GetEnd(self):
        """GetEnd(DIMENSION self) -> wxPoint"""
        return _pcbnew.DIMENSION_GetEnd(self)


    def SetHeight(self, aHeight):
        """SetHeight(DIMENSION self, int aHeight)"""
        return _pcbnew.DIMENSION_SetHeight(self, aHeight)


    def GetHeight(self):
        """GetHeight(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetHeight(self)


    def UpdateHeight(self):
        """UpdateHeight(DIMENSION self)"""
        return _pcbnew.DIMENSION_UpdateHeight(self)


    def GetAngle(self):
        """GetAngle(DIMENSION self) -> double"""
        return _pcbnew.DIMENSION_GetAngle(self)


    def AdjustDimensionDetails(self, aDoNotChangeText=False):
        """
        AdjustDimensionDetails(DIMENSION self, bool aDoNotChangeText=False)
        AdjustDimensionDetails(DIMENSION self)
        """
        return _pcbnew.DIMENSION_AdjustDimensionDetails(self, aDoNotChangeText)


    def SetText(self, NewText):
        """SetText(DIMENSION self, wxString const & NewText)"""
        return _pcbnew.DIMENSION_SetText(self, NewText)


    def GetText(self):
        """GetText(DIMENSION self) -> wxString const"""
        return _pcbnew.DIMENSION_GetText(self)


    def Text(self, *args):
        """
        Text(DIMENSION self) -> TEXTE_PCB
        Text(DIMENSION self) -> TEXTE_PCB
        """
        return _pcbnew.DIMENSION_Text(self, *args)


    def Copy(self, source):
        """Copy(DIMENSION self, DIMENSION source)"""
        return _pcbnew.DIMENSION_Copy(self, source)


    def Draw(self, *args):
        """
        Draw(DIMENSION self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aColorMode, wxPoint offset)
        Draw(DIMENSION self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aColorMode)
        """
        return _pcbnew.DIMENSION_Draw(self, *args)


    def Move(self, offset):
        """Move(DIMENSION self, wxPoint offset)"""
        return _pcbnew.DIMENSION_Move(self, offset)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(DIMENSION self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.DIMENSION_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(DIMENSION self, wxPoint aCentre)"""
        return _pcbnew.DIMENSION_Flip(self, aCentre)


    def Mirror(self, axis_pos):
        """Mirror(DIMENSION self, wxPoint axis_pos)"""
        return _pcbnew.DIMENSION_Mirror(self, axis_pos)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(DIMENSION self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.DIMENSION_GetMsgPanelInfo(self, aList)


    def HitTest(self, *args):
        """
        HitTest(DIMENSION self, wxPoint aPosition) -> bool
        HitTest(DIMENSION self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(DIMENSION self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(DIMENSION self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.DIMENSION_HitTest(self, *args)


    def GetClass(self):
        """GetClass(DIMENSION self) -> wxString"""
        return _pcbnew.DIMENSION_GetClass(self)


    def GetBoundingBox(self):
        """GetBoundingBox(DIMENSION self) -> EDA_RECT"""
        return _pcbnew.DIMENSION_GetBoundingBox(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(DIMENSION self) -> wxString"""
        return _pcbnew.DIMENSION_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(DIMENSION self) -> BITMAP_DEF"""
        return _pcbnew.DIMENSION_GetMenuImage(self)


    def Clone(self):
        """Clone(DIMENSION self) -> EDA_ITEM"""
        return _pcbnew.DIMENSION_Clone(self)


    def ViewBBox(self):
        """ViewBBox(DIMENSION self) -> BOX2I const"""
        return _pcbnew.DIMENSION_ViewBBox(self)

DIMENSION_swigregister = _pcbnew.DIMENSION_swigregister
DIMENSION_swigregister(DIMENSION)

class DRAWSEGMENT(BOARD_ITEM):
    """Proxy of C++ DRAWSEGMENT class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DRAWSEGMENT, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DRAWSEGMENT, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(DRAWSEGMENT self, BOARD_ITEM aParent=None, KICAD_T idtype) -> DRAWSEGMENT
        __init__(DRAWSEGMENT self, BOARD_ITEM aParent=None) -> DRAWSEGMENT
        __init__(DRAWSEGMENT self) -> DRAWSEGMENT
        """
        this = _pcbnew.new_DRAWSEGMENT(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_DRAWSEGMENT
    __del__ = lambda self: None

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.DRAWSEGMENT_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def SetWidth(self, aWidth):
        """SetWidth(DRAWSEGMENT self, int aWidth)"""
        return _pcbnew.DRAWSEGMENT_SetWidth(self, aWidth)


    def GetWidth(self):
        """GetWidth(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetWidth(self)


    def SetAngle(self, aAngle):
        """SetAngle(DRAWSEGMENT self, double aAngle)"""
        return _pcbnew.DRAWSEGMENT_SetAngle(self, aAngle)


    def GetAngle(self):
        """GetAngle(DRAWSEGMENT self) -> double"""
        return _pcbnew.DRAWSEGMENT_GetAngle(self)


    def SetType(self, aType):
        """SetType(DRAWSEGMENT self, int aType)"""
        return _pcbnew.DRAWSEGMENT_SetType(self, aType)


    def GetType(self):
        """GetType(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetType(self)


    def SetShape(self, aShape):
        """SetShape(DRAWSEGMENT self, STROKE_T aShape)"""
        return _pcbnew.DRAWSEGMENT_SetShape(self, aShape)


    def GetShape(self):
        """GetShape(DRAWSEGMENT self) -> STROKE_T"""
        return _pcbnew.DRAWSEGMENT_GetShape(self)


    def SetBezControl1(self, aPoint):
        """SetBezControl1(DRAWSEGMENT self, wxPoint aPoint)"""
        return _pcbnew.DRAWSEGMENT_SetBezControl1(self, aPoint)


    def GetBezControl1(self):
        """GetBezControl1(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetBezControl1(self)


    def SetBezControl2(self, aPoint):
        """SetBezControl2(DRAWSEGMENT self, wxPoint aPoint)"""
        return _pcbnew.DRAWSEGMENT_SetBezControl2(self, aPoint)


    def GetBezControl2(self):
        """GetBezControl2(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetBezControl2(self)


    def SetPosition(self, aPos):
        """SetPosition(DRAWSEGMENT self, wxPoint aPos)"""
        return _pcbnew.DRAWSEGMENT_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetPosition(self)


    def GetStart(self):
        """GetStart(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetStart(self)


    def SetStart(self, aStart):
        """SetStart(DRAWSEGMENT self, wxPoint aStart)"""
        return _pcbnew.DRAWSEGMENT_SetStart(self, aStart)


    def SetStartY(self, y):
        """SetStartY(DRAWSEGMENT self, int y)"""
        return _pcbnew.DRAWSEGMENT_SetStartY(self, y)


    def SetStartX(self, x):
        """SetStartX(DRAWSEGMENT self, int x)"""
        return _pcbnew.DRAWSEGMENT_SetStartX(self, x)


    def GetEnd(self):
        """GetEnd(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetEnd(self)


    def SetEnd(self, aEnd):
        """SetEnd(DRAWSEGMENT self, wxPoint aEnd)"""
        return _pcbnew.DRAWSEGMENT_SetEnd(self, aEnd)


    def SetEndY(self, y):
        """SetEndY(DRAWSEGMENT self, int y)"""
        return _pcbnew.DRAWSEGMENT_SetEndY(self, y)


    def SetEndX(self, x):
        """SetEndX(DRAWSEGMENT self, int x)"""
        return _pcbnew.DRAWSEGMENT_SetEndX(self, x)


    def GetCenter(self):
        """GetCenter(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetCenter(self)


    def GetArcStart(self):
        """GetArcStart(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetArcStart(self)


    def GetArcEnd(self):
        """GetArcEnd(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetArcEnd(self)


    def GetArcAngleStart(self):
        """GetArcAngleStart(DRAWSEGMENT self) -> double"""
        return _pcbnew.DRAWSEGMENT_GetArcAngleStart(self)


    def GetRadius(self):
        """GetRadius(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetRadius(self)


    def SetArcStart(self, aArcStartPoint):
        """SetArcStart(DRAWSEGMENT self, wxPoint aArcStartPoint)"""
        return _pcbnew.DRAWSEGMENT_SetArcStart(self, aArcStartPoint)


    def SetCenter(self, aCenterPoint):
        """SetCenter(DRAWSEGMENT self, wxPoint aCenterPoint)"""
        return _pcbnew.DRAWSEGMENT_SetCenter(self, aCenterPoint)


    def GetParentModule(self):
        """GetParentModule(DRAWSEGMENT self) -> MODULE"""
        return _pcbnew.DRAWSEGMENT_GetParentModule(self)


    def GetBezierPoints(self):
        """GetBezierPoints(DRAWSEGMENT self) -> wxPoint_Vector"""
        return _pcbnew.DRAWSEGMENT_GetBezierPoints(self)


    def GetPolyPoints(self, *args):
        """
        GetPolyPoints(DRAWSEGMENT self) -> wxPoint_Vector
        GetPolyPoints(DRAWSEGMENT self) -> wxPoint_Vector
        """
        return _pcbnew.DRAWSEGMENT_GetPolyPoints(self, *args)


    def SetBezierPoints(self, aPoints):
        """SetBezierPoints(DRAWSEGMENT self, wxPoint_Vector aPoints)"""
        return _pcbnew.DRAWSEGMENT_SetBezierPoints(self, aPoints)


    def SetPolyPoints(self, aPoints):
        """SetPolyPoints(DRAWSEGMENT self, wxPoint_Vector aPoints)"""
        return _pcbnew.DRAWSEGMENT_SetPolyPoints(self, aPoints)


    def Copy(self, source):
        """Copy(DRAWSEGMENT self, DRAWSEGMENT source)"""
        return _pcbnew.DRAWSEGMENT_Copy(self, source)


    def Draw(self, *args):
        """
        Draw(DRAWSEGMENT self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(DRAWSEGMENT self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.DRAWSEGMENT_Draw(self, *args)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(DRAWSEGMENT self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.DRAWSEGMENT_GetMsgPanelInfo(self, aList)


    def GetBoundingBox(self):
        """GetBoundingBox(DRAWSEGMENT self) -> EDA_RECT"""
        return _pcbnew.DRAWSEGMENT_GetBoundingBox(self)


    def HitTest(self, *args):
        """
        HitTest(DRAWSEGMENT self, wxPoint aPosition) -> bool
        HitTest(DRAWSEGMENT self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(DRAWSEGMENT self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(DRAWSEGMENT self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.DRAWSEGMENT_HitTest(self, *args)


    def GetClass(self):
        """GetClass(DRAWSEGMENT self) -> wxString"""
        return _pcbnew.DRAWSEGMENT_GetClass(self)


    def GetLength(self):
        """GetLength(DRAWSEGMENT self) -> double"""
        return _pcbnew.DRAWSEGMENT_GetLength(self)


    def Move(self, aMoveVector):
        """Move(DRAWSEGMENT self, wxPoint aMoveVector)"""
        return _pcbnew.DRAWSEGMENT_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(DRAWSEGMENT self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.DRAWSEGMENT_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(DRAWSEGMENT self, wxPoint aCentre)"""
        return _pcbnew.DRAWSEGMENT_Flip(self, aCentre)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygon(DRAWSEGMENT self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.DRAWSEGMENT_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def GetSelectMenuText(self):
        """GetSelectMenuText(DRAWSEGMENT self) -> wxString"""
        return _pcbnew.DRAWSEGMENT_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(DRAWSEGMENT self) -> BITMAP_DEF"""
        return _pcbnew.DRAWSEGMENT_GetMenuImage(self)


    def Clone(self):
        """Clone(DRAWSEGMENT self) -> EDA_ITEM"""
        return _pcbnew.DRAWSEGMENT_Clone(self)


    def GetShapeStr(self):
        return self.ShowShape(self.GetShape())

DRAWSEGMENT_swigregister = _pcbnew.DRAWSEGMENT_swigregister
DRAWSEGMENT_swigregister(DRAWSEGMENT)

def DRAWSEGMENT_ClassOf(aItem):
    """DRAWSEGMENT_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.DRAWSEGMENT_ClassOf(aItem)

class MARKER_PCB(BOARD_ITEM, MARKER_BASE):
    """Proxy of C++ MARKER_PCB class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM, MARKER_BASE]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MARKER_PCB, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM, MARKER_BASE]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MARKER_PCB, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MARKER_PCB self, BOARD_ITEM aParent) -> MARKER_PCB
        __init__(MARKER_PCB self, int aErrorCode, wxPoint aMarkerPos, wxString const & aText, wxPoint aPos, wxString const & bText, wxPoint bPos) -> MARKER_PCB
        __init__(MARKER_PCB self, int aErrorCode, wxPoint aMarkerPos, wxString const & aText, wxPoint aPos) -> MARKER_PCB
        """
        this = _pcbnew.new_MARKER_PCB(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MARKER_PCB
    __del__ = lambda self: None

    def Move(self, aMoveVector):
        """Move(MARKER_PCB self, wxPoint aMoveVector)"""
        return _pcbnew.MARKER_PCB_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(MARKER_PCB self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MARKER_PCB_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(MARKER_PCB self, wxPoint aCentre)"""
        return _pcbnew.MARKER_PCB_Flip(self, aCentre)


    def Draw(self, *args):
        """
        Draw(MARKER_PCB self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(MARKER_PCB self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.MARKER_PCB_Draw(self, *args)


    def GetPosition(self):
        """GetPosition(MARKER_PCB self) -> wxPoint"""
        return _pcbnew.MARKER_PCB_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(MARKER_PCB self, wxPoint aPos)"""
        return _pcbnew.MARKER_PCB_SetPosition(self, aPos)


    def SetItem(self, aItem):
        """SetItem(MARKER_PCB self, BOARD_ITEM aItem)"""
        return _pcbnew.MARKER_PCB_SetItem(self, aItem)


    def GetItem(self):
        """GetItem(MARKER_PCB self) -> BOARD_ITEM"""
        return _pcbnew.MARKER_PCB_GetItem(self)


    def HitTest(self, aPosition):
        """HitTest(MARKER_PCB self, wxPoint aPosition) -> bool"""
        return _pcbnew.MARKER_PCB_HitTest(self, aPosition)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(MARKER_PCB self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.MARKER_PCB_IsOnLayer(self, aLayer)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(MARKER_PCB self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MARKER_PCB_GetMsgPanelInfo(self, aList)


    def GetSelectMenuText(self):
        """GetSelectMenuText(MARKER_PCB self) -> wxString"""
        return _pcbnew.MARKER_PCB_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(MARKER_PCB self) -> BITMAP_DEF"""
        return _pcbnew.MARKER_PCB_GetMenuImage(self)


    def ViewBBox(self):
        """ViewBBox(MARKER_PCB self) -> BOX2I const"""
        return _pcbnew.MARKER_PCB_ViewBBox(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(MARKER_PCB self, int [] aLayers, int & aCount)"""
        return _pcbnew.MARKER_PCB_ViewGetLayers(self, aLayers, aCount)


    def GetClass(self):
        """GetClass(MARKER_PCB self) -> wxString"""
        return _pcbnew.MARKER_PCB_GetClass(self)

MARKER_PCB_swigregister = _pcbnew.MARKER_PCB_swigregister
MARKER_PCB_swigregister(MARKER_PCB)

class PCB_TARGET(BOARD_ITEM):
    """Proxy of C++ PCB_TARGET class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCB_TARGET, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PCB_TARGET, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(PCB_TARGET self, BOARD_ITEM aParent) -> PCB_TARGET
        __init__(PCB_TARGET self, BOARD_ITEM aParent, int aShape, LAYER_ID aLayer, wxPoint aPos, int aSize, int aWidth) -> PCB_TARGET
        """
        this = _pcbnew.new_PCB_TARGET(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PCB_TARGET
    __del__ = lambda self: None

    def SetPosition(self, aPos):
        """SetPosition(PCB_TARGET self, wxPoint aPos)"""
        return _pcbnew.PCB_TARGET_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(PCB_TARGET self) -> wxPoint"""
        return _pcbnew.PCB_TARGET_GetPosition(self)


    def SetShape(self, aShape):
        """SetShape(PCB_TARGET self, int aShape)"""
        return _pcbnew.PCB_TARGET_SetShape(self, aShape)


    def GetShape(self):
        """GetShape(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetShape(self)


    def SetSize(self, aSize):
        """SetSize(PCB_TARGET self, int aSize)"""
        return _pcbnew.PCB_TARGET_SetSize(self, aSize)


    def GetSize(self):
        """GetSize(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetSize(self)


    def SetWidth(self, aWidth):
        """SetWidth(PCB_TARGET self, int aWidth)"""
        return _pcbnew.PCB_TARGET_SetWidth(self, aWidth)


    def GetWidth(self):
        """GetWidth(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetWidth(self)


    def Move(self, aMoveVector):
        """Move(PCB_TARGET self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_TARGET_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(PCB_TARGET self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_TARGET_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(PCB_TARGET self, wxPoint aCentre)"""
        return _pcbnew.PCB_TARGET_Flip(self, aCentre)


    def Copy(self, source):
        """Copy(PCB_TARGET self, PCB_TARGET source)"""
        return _pcbnew.PCB_TARGET_Copy(self, source)


    def Draw(self, *args):
        """
        Draw(PCB_TARGET self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(PCB_TARGET self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.PCB_TARGET_Draw(self, *args)


    def GetClass(self):
        """GetClass(PCB_TARGET self) -> wxString"""
        return _pcbnew.PCB_TARGET_GetClass(self)


    def HitTest(self, *args):
        """
        HitTest(PCB_TARGET self, wxPoint aPosition) -> bool
        HitTest(PCB_TARGET self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(PCB_TARGET self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(PCB_TARGET self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.PCB_TARGET_HitTest(self, *args)


    def GetBoundingBox(self):
        """GetBoundingBox(PCB_TARGET self) -> EDA_RECT"""
        return _pcbnew.PCB_TARGET_GetBoundingBox(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(PCB_TARGET self) -> wxString"""
        return _pcbnew.PCB_TARGET_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(PCB_TARGET self) -> BITMAP_DEF"""
        return _pcbnew.PCB_TARGET_GetMenuImage(self)


    def Clone(self):
        """Clone(PCB_TARGET self) -> EDA_ITEM"""
        return _pcbnew.PCB_TARGET_Clone(self)

PCB_TARGET_swigregister = _pcbnew.PCB_TARGET_swigregister
PCB_TARGET_swigregister(PCB_TARGET)

class TEXTE_MODULE(BOARD_ITEM, EDA_TEXT):
    """Proxy of C++ TEXTE_MODULE class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM, EDA_TEXT]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TEXTE_MODULE, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_ITEM, EDA_TEXT]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TEXTE_MODULE, name)
    __repr__ = _swig_repr
    TEXT_is_REFERENCE = _pcbnew.TEXTE_MODULE_TEXT_is_REFERENCE
    TEXT_is_VALUE = _pcbnew.TEXTE_MODULE_TEXT_is_VALUE
    TEXT_is_DIVERS = _pcbnew.TEXTE_MODULE_TEXT_is_DIVERS

    def __init__(self, *args):
        """
        __init__(TEXTE_MODULE self, MODULE parent, TEXTE_MODULE::TEXT_TYPE text_type) -> TEXTE_MODULE
        __init__(TEXTE_MODULE self, MODULE parent) -> TEXTE_MODULE
        """
        this = _pcbnew.new_TEXTE_MODULE(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_TEXTE_MODULE
    __del__ = lambda self: None

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TEXTE_MODULE_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def GetPosition(self):
        """GetPosition(TEXTE_MODULE self) -> wxPoint"""
        return _pcbnew.TEXTE_MODULE_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(TEXTE_MODULE self, wxPoint aPos)"""
        return _pcbnew.TEXTE_MODULE_SetPosition(self, aPos)


    def Rotate(self, aOffset, aAngle):
        """Rotate(TEXTE_MODULE self, wxPoint aOffset, double aAngle)"""
        return _pcbnew.TEXTE_MODULE_Rotate(self, aOffset, aAngle)


    def Flip(self, aCentre):
        """Flip(TEXTE_MODULE self, wxPoint aCentre)"""
        return _pcbnew.TEXTE_MODULE_Flip(self, aCentre)


    def Mirror(self, aCentre, aMirrorAroundXAxis):
        """Mirror(TEXTE_MODULE self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.TEXTE_MODULE_Mirror(self, aCentre, aMirrorAroundXAxis)


    def Move(self, aMoveVector):
        """Move(TEXTE_MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.TEXTE_MODULE_Move(self, aMoveVector)


    def SetType(self, aType):
        """SetType(TEXTE_MODULE self, TEXTE_MODULE::TEXT_TYPE aType)"""
        return _pcbnew.TEXTE_MODULE_SetType(self, aType)


    def GetType(self):
        """GetType(TEXTE_MODULE self) -> TEXTE_MODULE::TEXT_TYPE"""
        return _pcbnew.TEXTE_MODULE_GetType(self)


    def SetVisible(self, isVisible):
        """SetVisible(TEXTE_MODULE self, bool isVisible)"""
        return _pcbnew.TEXTE_MODULE_SetVisible(self, isVisible)


    def IsVisible(self):
        """IsVisible(TEXTE_MODULE self) -> bool"""
        return _pcbnew.TEXTE_MODULE_IsVisible(self)


    def SetPos0(self, aPos):
        """SetPos0(TEXTE_MODULE self, wxPoint aPos)"""
        return _pcbnew.TEXTE_MODULE_SetPos0(self, aPos)


    def GetPos0(self):
        """GetPos0(TEXTE_MODULE self) -> wxPoint"""
        return _pcbnew.TEXTE_MODULE_GetPos0(self)


    def Copy(self, source):
        """Copy(TEXTE_MODULE self, TEXTE_MODULE source)"""
        return _pcbnew.TEXTE_MODULE_Copy(self, source)


    def GetLength(self):
        """GetLength(TEXTE_MODULE self) -> int"""
        return _pcbnew.TEXTE_MODULE_GetLength(self)


    def GetDrawRotation(self):
        """GetDrawRotation(TEXTE_MODULE self) -> double"""
        return _pcbnew.TEXTE_MODULE_GetDrawRotation(self)


    def GetBoundingBox(self):
        """GetBoundingBox(TEXTE_MODULE self) -> EDA_RECT"""
        return _pcbnew.TEXTE_MODULE_GetBoundingBox(self)


    def SetDrawCoord(self):
        """SetDrawCoord(TEXTE_MODULE self)"""
        return _pcbnew.TEXTE_MODULE_SetDrawCoord(self)


    def SetLocalCoord(self):
        """SetLocalCoord(TEXTE_MODULE self)"""
        return _pcbnew.TEXTE_MODULE_SetLocalCoord(self)


    def Draw(self, *args):
        """
        Draw(TEXTE_MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(TEXTE_MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TEXTE_MODULE_Draw(self, *args)


    def DrawUmbilical(self, *args):
        """
        DrawUmbilical(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        DrawUmbilical(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TEXTE_MODULE_DrawUmbilical(self, *args)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(TEXTE_MODULE self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TEXTE_MODULE_GetMsgPanelInfo(self, aList)


    def HitTest(self, aPosition):
        """HitTest(TEXTE_MODULE self, wxPoint aPosition) -> bool"""
        return _pcbnew.TEXTE_MODULE_HitTest(self, aPosition)


    def GetClass(self):
        """GetClass(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TEXTE_MODULE self) -> BITMAP_DEF"""
        return _pcbnew.TEXTE_MODULE_GetMenuImage(self)


    def Clone(self):
        """Clone(TEXTE_MODULE self) -> EDA_ITEM"""
        return _pcbnew.TEXTE_MODULE_Clone(self)


    def GetShownText(self):
        """GetShownText(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetShownText(self)


    def ViewBBox(self):
        """ViewBBox(TEXTE_MODULE self) -> BOX2I const"""
        return _pcbnew.TEXTE_MODULE_ViewBBox(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(TEXTE_MODULE self, int [] aLayers, int & aCount)"""
        return _pcbnew.TEXTE_MODULE_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(TEXTE_MODULE self, int aLayer) -> unsigned int"""
        return _pcbnew.TEXTE_MODULE_ViewGetLOD(self, aLayer)

TEXTE_MODULE_swigregister = _pcbnew.TEXTE_MODULE_swigregister
TEXTE_MODULE_swigregister(TEXTE_MODULE)

def TEXTE_MODULE_ClassOf(aItem):
    """TEXTE_MODULE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.TEXTE_MODULE_ClassOf(aItem)

class EDGE_MODULE(DRAWSEGMENT):
    """Proxy of C++ EDGE_MODULE class"""
    __swig_setmethods__ = {}
    for _s in [DRAWSEGMENT]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDGE_MODULE, name, value)
    __swig_getmethods__ = {}
    for _s in [DRAWSEGMENT]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EDGE_MODULE, name)
    __repr__ = _swig_repr

    def __init__(self, parent, aShape=S_SEGMENT):
        """
        __init__(EDGE_MODULE self, MODULE parent, STROKE_T aShape=S_SEGMENT) -> EDGE_MODULE
        __init__(EDGE_MODULE self, MODULE parent) -> EDGE_MODULE
        """
        this = _pcbnew.new_EDGE_MODULE(parent, aShape)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_EDGE_MODULE
    __del__ = lambda self: None

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.EDGE_MODULE_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf

    def Copy(self, source):
        """Copy(EDGE_MODULE self, EDGE_MODULE source)"""
        return _pcbnew.EDGE_MODULE_Copy(self, source)


    def Move(self, aMoveVector):
        """Move(EDGE_MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.EDGE_MODULE_Move(self, aMoveVector)


    def Mirror(self, aCentre, aMirrorAroundXAxis):
        """Mirror(EDGE_MODULE self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.EDGE_MODULE_Mirror(self, aCentre, aMirrorAroundXAxis)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(EDGE_MODULE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.EDGE_MODULE_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(EDGE_MODULE self, wxPoint aCentre)"""
        return _pcbnew.EDGE_MODULE_Flip(self, aCentre)


    def SetStart0(self, aPoint):
        """SetStart0(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetStart0(self, aPoint)


    def GetStart0(self):
        """GetStart0(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetStart0(self)


    def SetEnd0(self, aPoint):
        """SetEnd0(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetEnd0(self, aPoint)


    def GetEnd0(self):
        """GetEnd0(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetEnd0(self)


    def SetLocalCoord(self):
        """SetLocalCoord(EDGE_MODULE self)"""
        return _pcbnew.EDGE_MODULE_SetLocalCoord(self)


    def SetDrawCoord(self):
        """SetDrawCoord(EDGE_MODULE self)"""
        return _pcbnew.EDGE_MODULE_SetDrawCoord(self)


    def Draw(self, *args):
        """
        Draw(EDGE_MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(EDGE_MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.EDGE_MODULE_Draw(self, *args)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(EDGE_MODULE self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDGE_MODULE_GetMsgPanelInfo(self, aList)


    def GetClass(self):
        """GetClass(EDGE_MODULE self) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(EDGE_MODULE self) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(EDGE_MODULE self) -> BITMAP_DEF"""
        return _pcbnew.EDGE_MODULE_GetMenuImage(self)


    def Clone(self):
        """Clone(EDGE_MODULE self) -> EDA_ITEM"""
        return _pcbnew.EDGE_MODULE_Clone(self)

    __swig_setmethods__["m_Start0"] = _pcbnew.EDGE_MODULE_m_Start0_set
    __swig_getmethods__["m_Start0"] = _pcbnew.EDGE_MODULE_m_Start0_get
    if _newclass:
        m_Start0 = _swig_property(_pcbnew.EDGE_MODULE_m_Start0_get, _pcbnew.EDGE_MODULE_m_Start0_set)
    __swig_setmethods__["m_End0"] = _pcbnew.EDGE_MODULE_m_End0_set
    __swig_getmethods__["m_End0"] = _pcbnew.EDGE_MODULE_m_End0_get
    if _newclass:
        m_End0 = _swig_property(_pcbnew.EDGE_MODULE_m_End0_get, _pcbnew.EDGE_MODULE_m_End0_set)
EDGE_MODULE_swigregister = _pcbnew.EDGE_MODULE_swigregister
EDGE_MODULE_swigregister(EDGE_MODULE)

def EDGE_MODULE_ClassOf(aItem):
    """EDGE_MODULE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.EDGE_MODULE_ClassOf(aItem)


_pcbnew.MAX_ZONE_CORNER_RADIUS_MILS_swigconstant(_pcbnew)
MAX_ZONE_CORNER_RADIUS_MILS = _pcbnew.MAX_ZONE_CORNER_RADIUS_MILS
class ZONE_SETTINGS(_object):
    """Proxy of C++ ZONE_SETTINGS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZONE_SETTINGS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ZONE_SETTINGS, name)
    __repr__ = _swig_repr
    SMOOTHING_NONE = _pcbnew.ZONE_SETTINGS_SMOOTHING_NONE
    SMOOTHING_CHAMFER = _pcbnew.ZONE_SETTINGS_SMOOTHING_CHAMFER
    SMOOTHING_FILLET = _pcbnew.ZONE_SETTINGS_SMOOTHING_FILLET
    SMOOTHING_LAST = _pcbnew.ZONE_SETTINGS_SMOOTHING_LAST
    __swig_setmethods__["m_FillMode"] = _pcbnew.ZONE_SETTINGS_m_FillMode_set
    __swig_getmethods__["m_FillMode"] = _pcbnew.ZONE_SETTINGS_m_FillMode_get
    if _newclass:
        m_FillMode = _swig_property(_pcbnew.ZONE_SETTINGS_m_FillMode_get, _pcbnew.ZONE_SETTINGS_m_FillMode_set)
    __swig_setmethods__["m_ZonePriority"] = _pcbnew.ZONE_SETTINGS_m_ZonePriority_set
    __swig_getmethods__["m_ZonePriority"] = _pcbnew.ZONE_SETTINGS_m_ZonePriority_get
    if _newclass:
        m_ZonePriority = _swig_property(_pcbnew.ZONE_SETTINGS_m_ZonePriority_get, _pcbnew.ZONE_SETTINGS_m_ZonePriority_set)
    __swig_setmethods__["m_ZoneClearance"] = _pcbnew.ZONE_SETTINGS_m_ZoneClearance_set
    __swig_getmethods__["m_ZoneClearance"] = _pcbnew.ZONE_SETTINGS_m_ZoneClearance_get
    if _newclass:
        m_ZoneClearance = _swig_property(_pcbnew.ZONE_SETTINGS_m_ZoneClearance_get, _pcbnew.ZONE_SETTINGS_m_ZoneClearance_set)
    __swig_setmethods__["m_ZoneMinThickness"] = _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_set
    __swig_getmethods__["m_ZoneMinThickness"] = _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_get
    if _newclass:
        m_ZoneMinThickness = _swig_property(_pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_get, _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_set)
    __swig_setmethods__["m_NetcodeSelection"] = _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_set
    __swig_getmethods__["m_NetcodeSelection"] = _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_get
    if _newclass:
        m_NetcodeSelection = _swig_property(_pcbnew.ZONE_SETTINGS_m_NetcodeSelection_get, _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_set)
    __swig_setmethods__["m_CurrentZone_Layer"] = _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_set
    __swig_getmethods__["m_CurrentZone_Layer"] = _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_get
    if _newclass:
        m_CurrentZone_Layer = _swig_property(_pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_get, _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_set)
    __swig_setmethods__["m_Zone_HatchingStyle"] = _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_set
    __swig_getmethods__["m_Zone_HatchingStyle"] = _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_get
    if _newclass:
        m_Zone_HatchingStyle = _swig_property(_pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_get, _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_set)
    __swig_setmethods__["m_ArcToSegmentsCount"] = _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_set
    __swig_getmethods__["m_ArcToSegmentsCount"] = _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_get
    if _newclass:
        m_ArcToSegmentsCount = _swig_property(_pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_get, _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_set)
    __swig_setmethods__["m_ThermalReliefGap"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set
    __swig_getmethods__["m_ThermalReliefGap"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get
    if _newclass:
        m_ThermalReliefGap = _swig_property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set)
    __swig_setmethods__["m_ThermalReliefCopperBridge"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_set
    __swig_getmethods__["m_ThermalReliefCopperBridge"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_get
    if _newclass:
        m_ThermalReliefCopperBridge = _swig_property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_set)
    __swig_setmethods__["m_Zone_45_Only"] = _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_set
    __swig_getmethods__["m_Zone_45_Only"] = _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_get
    if _newclass:
        m_Zone_45_Only = _swig_property(_pcbnew.ZONE_SETTINGS_m_Zone_45_Only_get, _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_set)

    def __init__(self):
        """__init__(ZONE_SETTINGS self) -> ZONE_SETTINGS"""
        this = _pcbnew.new_ZONE_SETTINGS()
        try:
            self.this.append(this)
        except:
            self.this = this

    def __lshift__(self, aSource):
        """__lshift__(ZONE_SETTINGS self, ZONE_CONTAINER aSource) -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS___lshift__(self, aSource)


    def ExportSetting(self, aTarget, aFullExport=True):
        """
        ExportSetting(ZONE_SETTINGS self, ZONE_CONTAINER aTarget, bool aFullExport=True)
        ExportSetting(ZONE_SETTINGS self, ZONE_CONTAINER aTarget)
        """
        return _pcbnew.ZONE_SETTINGS_ExportSetting(self, aTarget, aFullExport)


    def SetCornerSmoothingType(self, aType):
        """SetCornerSmoothingType(ZONE_SETTINGS self, int aType)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerSmoothingType(self, aType)


    def GetCornerSmoothingType(self):
        """GetCornerSmoothingType(ZONE_SETTINGS self) -> int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerSmoothingType(self)


    def SetCornerRadius(self, aRadius):
        """SetCornerRadius(ZONE_SETTINGS self, int aRadius)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerRadius(self, aRadius)


    def GetCornerRadius(self):
        """GetCornerRadius(ZONE_SETTINGS self) -> unsigned int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerRadius(self)


    def GetPadConnection(self):
        """GetPadConnection(ZONE_SETTINGS self) -> ZoneConnection"""
        return _pcbnew.ZONE_SETTINGS_GetPadConnection(self)


    def SetPadConnection(self, aPadConnection):
        """SetPadConnection(ZONE_SETTINGS self, ZoneConnection aPadConnection)"""
        return _pcbnew.ZONE_SETTINGS_SetPadConnection(self, aPadConnection)


    def GetIsKeepout(self):
        """GetIsKeepout(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetIsKeepout(self)


    def GetDoNotAllowCopperPour(self):
        """GetDoNotAllowCopperPour(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowCopperPour(self)


    def GetDoNotAllowVias(self):
        """GetDoNotAllowVias(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowVias(self)


    def GetDoNotAllowTracks(self):
        """GetDoNotAllowTracks(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowTracks(self)


    def SetIsKeepout(self, aEnable):
        """SetIsKeepout(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetIsKeepout(self, aEnable)


    def SetDoNotAllowCopperPour(self, aEnable):
        """SetDoNotAllowCopperPour(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowCopperPour(self, aEnable)


    def SetDoNotAllowVias(self, aEnable):
        """SetDoNotAllowVias(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowVias(self, aEnable)


    def SetDoNotAllowTracks(self, aEnable):
        """SetDoNotAllowTracks(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowTracks(self, aEnable)

    __swig_destroy__ = _pcbnew.delete_ZONE_SETTINGS
    __del__ = lambda self: None
ZONE_SETTINGS_swigregister = _pcbnew.ZONE_SETTINGS_swigregister
ZONE_SETTINGS_swigregister(ZONE_SETTINGS)

class NETCLASS(_object):
    """Proxy of C++ NETCLASS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NETCLASS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NETCLASS, name)
    __repr__ = _swig_repr

    def __init__(self, aName):
        """__init__(NETCLASS self, wxString const & aName) -> NETCLASS"""
        this = _pcbnew.new_NETCLASS(aName)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETCLASS
    __del__ = lambda self: None

    def GetClass(self):
        """GetClass(NETCLASS self) -> wxString"""
        return _pcbnew.NETCLASS_GetClass(self)


    def GetName(self):
        """GetName(NETCLASS self) -> wxString const &"""
        return _pcbnew.NETCLASS_GetName(self)


    def SetName(self, aName):
        """SetName(NETCLASS self, wxString const & aName)"""
        return _pcbnew.NETCLASS_SetName(self, aName)


    def GetCount(self):
        """GetCount(NETCLASS self) -> unsigned int"""
        return _pcbnew.NETCLASS_GetCount(self)


    def Clear(self):
        """Clear(NETCLASS self)"""
        return _pcbnew.NETCLASS_Clear(self)


    def AddNative(self, aNetname):
        """AddNative(NETCLASS self, wxString const & aNetname)"""
        return _pcbnew.NETCLASS_AddNative(self, aNetname)


    def begin(self, *args):
        """
        begin(NETCLASS self) -> NETCLASS::iterator
        begin(NETCLASS self) -> NETCLASS::const_iterator
        """
        return _pcbnew.NETCLASS_begin(self, *args)


    def end(self, *args):
        """
        end(NETCLASS self) -> NETCLASS::iterator
        end(NETCLASS self) -> NETCLASS::const_iterator
        """
        return _pcbnew.NETCLASS_end(self, *args)


    def Remove(self, *args):
        """
        Remove(NETCLASS self, NETCLASS::iterator aName)
        Remove(NETCLASS self, wxString const & aName)
        """
        return _pcbnew.NETCLASS_Remove(self, *args)


    def GetDescription(self):
        """GetDescription(NETCLASS self) -> wxString const &"""
        return _pcbnew.NETCLASS_GetDescription(self)


    def SetDescription(self, aDesc):
        """SetDescription(NETCLASS self, wxString const & aDesc)"""
        return _pcbnew.NETCLASS_SetDescription(self, aDesc)


    def GetClearance(self):
        """GetClearance(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetClearance(self)


    def SetClearance(self, aClearance):
        """SetClearance(NETCLASS self, int aClearance)"""
        return _pcbnew.NETCLASS_SetClearance(self, aClearance)


    def GetTrackWidth(self):
        """GetTrackWidth(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetTrackWidth(self)


    def SetTrackWidth(self, aWidth):
        """SetTrackWidth(NETCLASS self, int aWidth)"""
        return _pcbnew.NETCLASS_SetTrackWidth(self, aWidth)


    def GetViaDiameter(self):
        """GetViaDiameter(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetViaDiameter(self)


    def SetViaDiameter(self, aDia):
        """SetViaDiameter(NETCLASS self, int aDia)"""
        return _pcbnew.NETCLASS_SetViaDiameter(self, aDia)


    def GetViaDrill(self):
        """GetViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetViaDrill(self)


    def SetViaDrill(self, aSize):
        """SetViaDrill(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetViaDrill(self, aSize)


    def GetuViaDiameter(self):
        """GetuViaDiameter(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetuViaDiameter(self)


    def SetuViaDiameter(self, aSize):
        """SetuViaDiameter(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetuViaDiameter(self, aSize)


    def GetuViaDrill(self):
        """GetuViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetuViaDrill(self)


    def SetuViaDrill(self, aSize):
        """SetuViaDrill(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetuViaDrill(self, aSize)


    def SetParams(self, aDefaults):
        """SetParams(NETCLASS self, NETCLASS aDefaults)"""
        return _pcbnew.NETCLASS_SetParams(self, aDefaults)


    def Format(self, aFormatter, aNestLevel, aControlBits):
        """Format(NETCLASS self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)"""
        return _pcbnew.NETCLASS_Format(self, aFormatter, aNestLevel, aControlBits)

NETCLASS_swigregister = _pcbnew.NETCLASS_swigregister
NETCLASS_swigregister(NETCLASS)
NETCLASS.Default = _pcbnew.cvar.NETCLASS_Default

class NETCLASSES(_object):
    """Proxy of C++ NETCLASSES class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NETCLASSES, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NETCLASSES, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(NETCLASSES self) -> NETCLASSES"""
        this = _pcbnew.new_NETCLASSES()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETCLASSES
    __del__ = lambda self: None

    def Clear(self):
        """Clear(NETCLASSES self)"""
        return _pcbnew.NETCLASSES_Clear(self)


    def begin(self, *args):
        """
        begin(NETCLASSES self) -> NETCLASSES::iterator
        begin(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_begin(self, *args)


    def end(self, *args):
        """
        end(NETCLASSES self) -> NETCLASSES::iterator
        end(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_end(self, *args)


    def GetCount(self):
        """GetCount(NETCLASSES self) -> unsigned int"""
        return _pcbnew.NETCLASSES_GetCount(self)


    def GetDefault(self):
        """GetDefault(NETCLASSES self) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_GetDefault(self)


    def AddNative(self, aNetclass):
        """AddNative(NETCLASSES self, NETCLASSPTR aNetclass) -> bool"""
        return _pcbnew.NETCLASSES_AddNative(self, aNetclass)


    def Remove(self, aNetName):
        """Remove(NETCLASSES self, wxString const & aNetName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Remove(self, aNetName)


    def Find(self, aName):
        """Find(NETCLASSES self, wxString const & aName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Find(self, aName)

NETCLASSES_swigregister = _pcbnew.NETCLASSES_swigregister
NETCLASSES_swigregister(NETCLASSES)

class PLOT_CONTROLLER(_object):
    """Proxy of C++ PLOT_CONTROLLER class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PLOT_CONTROLLER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PLOT_CONTROLLER, name)
    __repr__ = _swig_repr

    def __init__(self, aBoard):
        """__init__(PLOT_CONTROLLER self, BOARD aBoard) -> PLOT_CONTROLLER"""
        this = _pcbnew.new_PLOT_CONTROLLER(aBoard)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PLOT_CONTROLLER
    __del__ = lambda self: None

    def GetPlotOptions(self):
        """GetPlotOptions(PLOT_CONTROLLER self) -> PCB_PLOT_PARAMS"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotOptions(self)


    def SetLayer(self, aLayer):
        """SetLayer(PLOT_CONTROLLER self, LAYER_NUM aLayer)"""
        return _pcbnew.PLOT_CONTROLLER_SetLayer(self, aLayer)


    def GetLayer(self):
        """GetLayer(PLOT_CONTROLLER self) -> LAYER_NUM"""
        return _pcbnew.PLOT_CONTROLLER_GetLayer(self)


    def IsPlotOpen(self):
        """IsPlotOpen(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_IsPlotOpen(self)


    def ClosePlot(self):
        """ClosePlot(PLOT_CONTROLLER self)"""
        return _pcbnew.PLOT_CONTROLLER_ClosePlot(self)


    def OpenPlotfile(self, aSuffix, aFormat, aSheetDesc):
        """OpenPlotfile(PLOT_CONTROLLER self, wxString const & aSuffix, PlotFormat aFormat, wxString const & aSheetDesc) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_OpenPlotfile(self, aSuffix, aFormat, aSheetDesc)


    def PlotLayer(self):
        """PlotLayer(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_PlotLayer(self)


    def SetColorMode(self, aColorMode):
        """SetColorMode(PLOT_CONTROLLER self, bool aColorMode)"""
        return _pcbnew.PLOT_CONTROLLER_SetColorMode(self, aColorMode)


    def GetColorMode(self):
        """GetColorMode(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_GetColorMode(self)

PLOT_CONTROLLER_swigregister = _pcbnew.PLOT_CONTROLLER_swigregister
PLOT_CONTROLLER_swigregister(PLOT_CONTROLLER)

class PCB_PLOT_PARAMS(_object):
    """Proxy of C++ PCB_PLOT_PARAMS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCB_PLOT_PARAMS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PCB_PLOT_PARAMS, name)
    __repr__ = _swig_repr
    NO_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_NO_DRILL_SHAPE
    SMALL_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_SMALL_DRILL_SHAPE
    FULL_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_FULL_DRILL_SHAPE

    def __init__(self):
        """__init__(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS"""
        this = _pcbnew.new_PCB_PLOT_PARAMS()
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetSkipPlotNPTH_Pads(self, aSkip):
        """SetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self, bool aSkip)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSkipPlotNPTH_Pads(self, aSkip)


    def GetSkipPlotNPTH_Pads(self):
        """GetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSkipPlotNPTH_Pads(self)


    def Format(self, aFormatter, aNestLevel, aControl=0):
        """
        Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControl=0)
        Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER * aFormatter, int aNestLevel)
        """
        return _pcbnew.PCB_PLOT_PARAMS_Format(self, aFormatter, aNestLevel, aControl)


    def Parse(self, aParser):
        """Parse(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS_PARSER * aParser)"""
        return _pcbnew.PCB_PLOT_PARAMS_Parse(self, aParser)


    def __eq__(self, aPcbPlotParams):
        """__eq__(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS___eq__(self, aPcbPlotParams)


    def __ne__(self, aPcbPlotParams):
        """__ne__(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS___ne__(self, aPcbPlotParams)


    def SetColor(self, aVal):
        """SetColor(PCB_PLOT_PARAMS self, EDA_COLOR_T aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetColor(self, aVal)


    def GetColor(self):
        """GetColor(PCB_PLOT_PARAMS self) -> EDA_COLOR_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetColor(self)


    def SetReferenceColor(self, aVal):
        """SetReferenceColor(PCB_PLOT_PARAMS self, EDA_COLOR_T aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetReferenceColor(self, aVal)


    def GetReferenceColor(self):
        """GetReferenceColor(PCB_PLOT_PARAMS self) -> EDA_COLOR_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetReferenceColor(self)


    def SetValueColor(self, aVal):
        """SetValueColor(PCB_PLOT_PARAMS self, EDA_COLOR_T aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetValueColor(self, aVal)


    def GetValueColor(self):
        """GetValueColor(PCB_PLOT_PARAMS self) -> EDA_COLOR_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetValueColor(self)


    def SetTextMode(self, aVal):
        """SetTextMode(PCB_PLOT_PARAMS self, PlotTextMode aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetTextMode(self, aVal)


    def GetTextMode(self):
        """GetTextMode(PCB_PLOT_PARAMS self) -> PlotTextMode"""
        return _pcbnew.PCB_PLOT_PARAMS_GetTextMode(self)


    def SetPlotMode(self, aPlotMode):
        """SetPlotMode(PCB_PLOT_PARAMS self, EDA_DRAW_MODE_T aPlotMode)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotMode(self, aPlotMode)


    def GetPlotMode(self):
        """GetPlotMode(PCB_PLOT_PARAMS self) -> EDA_DRAW_MODE_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotMode(self)


    def SetDrillMarksType(self, aVal):
        """SetDrillMarksType(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS::DrillMarksType aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDrillMarksType(self, aVal)


    def GetDrillMarksType(self):
        """GetDrillMarksType(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS::DrillMarksType"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDrillMarksType(self)


    def SetScale(self, aVal):
        """SetScale(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScale(self, aVal)


    def GetScale(self):
        """GetScale(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScale(self)


    def SetFineScaleAdjustX(self, aVal):
        """SetFineScaleAdjustX(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustX(self, aVal)


    def GetFineScaleAdjustX(self):
        """GetFineScaleAdjustX(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustX(self)


    def SetFineScaleAdjustY(self, aVal):
        """SetFineScaleAdjustY(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustY(self, aVal)


    def GetFineScaleAdjustY(self):
        """GetFineScaleAdjustY(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustY(self)


    def SetWidthAdjust(self, aVal):
        """SetWidthAdjust(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetWidthAdjust(self, aVal)


    def GetWidthAdjust(self):
        """GetWidthAdjust(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetWidthAdjust(self)


    def SetAutoScale(self, aFlag):
        """SetAutoScale(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetAutoScale(self, aFlag)


    def GetAutoScale(self):
        """GetAutoScale(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetAutoScale(self)


    def SetMirror(self, aFlag):
        """SetMirror(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetMirror(self, aFlag)


    def GetMirror(self):
        """GetMirror(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetMirror(self)


    def SetPlotPadsOnSilkLayer(self, aFlag):
        """SetPlotPadsOnSilkLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotPadsOnSilkLayer(self, aFlag)


    def GetPlotPadsOnSilkLayer(self):
        """GetPlotPadsOnSilkLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotPadsOnSilkLayer(self)


    def SetPlotInvisibleText(self, aFlag):
        """SetPlotInvisibleText(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotInvisibleText(self, aFlag)


    def GetPlotInvisibleText(self):
        """GetPlotInvisibleText(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotInvisibleText(self)


    def SetPlotValue(self, aFlag):
        """SetPlotValue(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotValue(self, aFlag)


    def GetPlotValue(self):
        """GetPlotValue(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotValue(self)


    def SetPlotReference(self, aFlag):
        """SetPlotReference(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotReference(self, aFlag)


    def GetPlotReference(self):
        """GetPlotReference(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotReference(self)


    def SetNegative(self, aFlag):
        """SetNegative(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetNegative(self, aFlag)


    def GetNegative(self):
        """GetNegative(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetNegative(self)


    def SetPlotViaOnMaskLayer(self, aFlag):
        """SetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotViaOnMaskLayer(self, aFlag)


    def GetPlotViaOnMaskLayer(self):
        """GetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotViaOnMaskLayer(self)


    def SetPlotFrameRef(self, aFlag):
        """SetPlotFrameRef(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotFrameRef(self, aFlag)


    def GetPlotFrameRef(self):
        """GetPlotFrameRef(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotFrameRef(self)


    def SetExcludeEdgeLayer(self, aFlag):
        """SetExcludeEdgeLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetExcludeEdgeLayer(self, aFlag)


    def GetExcludeEdgeLayer(self):
        """GetExcludeEdgeLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetExcludeEdgeLayer(self)


    def SetFormat(self, aFormat):
        """SetFormat(PCB_PLOT_PARAMS self, PlotFormat aFormat)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFormat(self, aFormat)


    def GetFormat(self):
        """GetFormat(PCB_PLOT_PARAMS self) -> PlotFormat"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFormat(self)


    def SetOutputDirectory(self, aDir):
        """SetOutputDirectory(PCB_PLOT_PARAMS self, wxString aDir)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetOutputDirectory(self, aDir)


    def GetOutputDirectory(self):
        """GetOutputDirectory(PCB_PLOT_PARAMS self) -> wxString"""
        return _pcbnew.PCB_PLOT_PARAMS_GetOutputDirectory(self)


    def SetUseGerberAttributes(self, aUse):
        """SetUseGerberAttributes(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberAttributes(self, aUse)


    def GetUseGerberAttributes(self):
        """GetUseGerberAttributes(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberAttributes(self)


    def SetUseGerberExtensions(self, aUse):
        """SetUseGerberExtensions(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberExtensions(self, aUse)


    def GetUseGerberExtensions(self):
        """GetUseGerberExtensions(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberExtensions(self)


    def SetGerberPrecision(self, aPrecision):
        """SetGerberPrecision(PCB_PLOT_PARAMS self, int aPrecision)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetGerberPrecision(self, aPrecision)


    def GetGerberPrecision(self):
        """GetGerberPrecision(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberPrecision(self)


    def GetGerberDefaultPrecision():
        """GetGerberDefaultPrecision() -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberDefaultPrecision()

    if _newclass:
        GetGerberDefaultPrecision = staticmethod(GetGerberDefaultPrecision)
    __swig_getmethods__["GetGerberDefaultPrecision"] = lambda x: GetGerberDefaultPrecision

    def SetSubtractMaskFromSilk(self, aSubtract):
        """SetSubtractMaskFromSilk(PCB_PLOT_PARAMS self, bool aSubtract)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSubtractMaskFromSilk(self, aSubtract)


    def GetSubtractMaskFromSilk(self):
        """GetSubtractMaskFromSilk(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSubtractMaskFromSilk(self)


    def SetLayerSelection(self, aSelection):
        """SetLayerSelection(PCB_PLOT_PARAMS self, LSET aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetLayerSelection(self, aSelection)


    def GetLayerSelection(self):
        """GetLayerSelection(PCB_PLOT_PARAMS self) -> LSET"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLayerSelection(self)


    def SetUseAuxOrigin(self, aAux):
        """SetUseAuxOrigin(PCB_PLOT_PARAMS self, bool aAux)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseAuxOrigin(self, aAux)


    def GetUseAuxOrigin(self):
        """GetUseAuxOrigin(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseAuxOrigin(self)


    def SetScaleSelection(self, aSelection):
        """SetScaleSelection(PCB_PLOT_PARAMS self, int aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScaleSelection(self, aSelection)


    def GetScaleSelection(self):
        """GetScaleSelection(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScaleSelection(self)


    def SetA4Output(self, aForce):
        """SetA4Output(PCB_PLOT_PARAMS self, int aForce)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetA4Output(self, aForce)


    def GetA4Output(self):
        """GetA4Output(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetA4Output(self)


    def GetHPGLPenDiameter(self):
        """GetHPGLPenDiameter(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenDiameter(self)


    def SetHPGLPenDiameter(self, aValue):
        """SetHPGLPenDiameter(PCB_PLOT_PARAMS self, int aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenDiameter(self, aValue)


    def GetHPGLPenSpeed(self):
        """GetHPGLPenSpeed(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenSpeed(self)


    def SetHPGLPenSpeed(self, aValue):
        """SetHPGLPenSpeed(PCB_PLOT_PARAMS self, int aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenSpeed(self, aValue)


    def GetHPGLPenOverlay(self):
        """GetHPGLPenOverlay(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenOverlay(self)


    def SetHPGLPenOverlay(self, aValue):
        """SetHPGLPenOverlay(PCB_PLOT_PARAMS self, int aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenOverlay(self, aValue)


    def SetHPGLPenNum(self, aVal):
        """SetHPGLPenNum(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenNum(self, aVal)


    def GetHPGLPenNum(self):
        """GetHPGLPenNum(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenNum(self)


    def GetLineWidth(self):
        """GetLineWidth(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLineWidth(self)


    def SetLineWidth(self, aValue):
        """SetLineWidth(PCB_PLOT_PARAMS self, int aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetLineWidth(self, aValue)

    __swig_destroy__ = _pcbnew.delete_PCB_PLOT_PARAMS
    __del__ = lambda self: None
PCB_PLOT_PARAMS_swigregister = _pcbnew.PCB_PLOT_PARAMS_swigregister
PCB_PLOT_PARAMS_swigregister(PCB_PLOT_PARAMS)

def PCB_PLOT_PARAMS_GetGerberDefaultPrecision():
    """PCB_PLOT_PARAMS_GetGerberDefaultPrecision() -> int"""
    return _pcbnew.PCB_PLOT_PARAMS_GetGerberDefaultPrecision()


_pcbnew.PLOT_FIRST_FORMAT_swigconstant(_pcbnew)
PLOT_FIRST_FORMAT = _pcbnew.PLOT_FIRST_FORMAT

_pcbnew.PLOT_FORMAT_HPGL_swigconstant(_pcbnew)
PLOT_FORMAT_HPGL = _pcbnew.PLOT_FORMAT_HPGL

_pcbnew.PLOT_FORMAT_GERBER_swigconstant(_pcbnew)
PLOT_FORMAT_GERBER = _pcbnew.PLOT_FORMAT_GERBER

_pcbnew.PLOT_FORMAT_POST_swigconstant(_pcbnew)
PLOT_FORMAT_POST = _pcbnew.PLOT_FORMAT_POST

_pcbnew.PLOT_FORMAT_DXF_swigconstant(_pcbnew)
PLOT_FORMAT_DXF = _pcbnew.PLOT_FORMAT_DXF

_pcbnew.PLOT_FORMAT_PDF_swigconstant(_pcbnew)
PLOT_FORMAT_PDF = _pcbnew.PLOT_FORMAT_PDF

_pcbnew.PLOT_FORMAT_SVG_swigconstant(_pcbnew)
PLOT_FORMAT_SVG = _pcbnew.PLOT_FORMAT_SVG

_pcbnew.PLOT_LAST_FORMAT_swigconstant(_pcbnew)
PLOT_LAST_FORMAT = _pcbnew.PLOT_LAST_FORMAT

_pcbnew.PLOTTEXTMODE_STROKE_swigconstant(_pcbnew)
PLOTTEXTMODE_STROKE = _pcbnew.PLOTTEXTMODE_STROKE

_pcbnew.PLOTTEXTMODE_NATIVE_swigconstant(_pcbnew)
PLOTTEXTMODE_NATIVE = _pcbnew.PLOTTEXTMODE_NATIVE

_pcbnew.PLOTTEXTMODE_PHANTOM_swigconstant(_pcbnew)
PLOTTEXTMODE_PHANTOM = _pcbnew.PLOTTEXTMODE_PHANTOM

_pcbnew.PLOTTEXTMODE_DEFAULT_swigconstant(_pcbnew)
PLOTTEXTMODE_DEFAULT = _pcbnew.PLOTTEXTMODE_DEFAULT
class PLOTTER(_object):
    """Proxy of C++ PLOTTER class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PLOTTER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PLOTTER, name)

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

    def GetPlotterType(self):
        """GetPlotterType(PLOTTER self) -> PlotFormat"""
        return _pcbnew.PLOTTER_GetPlotterType(self)


    def StartPlot(self):
        """StartPlot(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_EndPlot(self)


    def SetNegative(self, _negative):
        """SetNegative(PLOTTER self, bool _negative)"""
        return _pcbnew.PLOTTER_SetNegative(self, _negative)


    def SetColorMode(self, _color_mode):
        """SetColorMode(PLOTTER self, bool _color_mode)"""
        return _pcbnew.PLOTTER_SetColorMode(self, _color_mode)


    def GetColorMode(self):
        """GetColorMode(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_GetColorMode(self)


    def SetPageSettings(self, aPageSettings):
        """SetPageSettings(PLOTTER self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.PLOTTER_SetPageSettings(self, aPageSettings)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(PLOTTER self, int width)"""
        return _pcbnew.PLOTTER_SetCurrentLineWidth(self, width)


    def SetDefaultLineWidth(self, width):
        """SetDefaultLineWidth(PLOTTER self, int width)"""
        return _pcbnew.PLOTTER_SetDefaultLineWidth(self, width)


    def GetCurrentLineWidth(self):
        """GetCurrentLineWidth(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetCurrentLineWidth(self)


    def SetColor(self, color):
        """SetColor(PLOTTER self, EDA_COLOR_T color)"""
        return _pcbnew.PLOTTER_SetColor(self, color)


    def SetDash(self, dashed):
        """SetDash(PLOTTER self, bool dashed)"""
        return _pcbnew.PLOTTER_SetDash(self, dashed)


    def SetCreator(self, aCreator):
        """SetCreator(PLOTTER self, wxString const & aCreator)"""
        return _pcbnew.PLOTTER_SetCreator(self, aCreator)


    def AddLineToHeader(self, aExtraString):
        """AddLineToHeader(PLOTTER self, wxString const & aExtraString)"""
        return _pcbnew.PLOTTER_AddLineToHeader(self, aExtraString)


    def ClearHeaderLinesList(self):
        """ClearHeaderLinesList(PLOTTER self)"""
        return _pcbnew.PLOTTER_ClearHeaderLinesList(self)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def OpenFile(self, aFullFilename):
        """OpenFile(PLOTTER self, wxString const & aFullFilename) -> bool"""
        return _pcbnew.PLOTTER_OpenFile(self, aFullFilename)


    def GetIUsPerDecimil(self):
        """GetIUsPerDecimil(PLOTTER self) -> double"""
        return _pcbnew.PLOTTER_GetIUsPerDecimil(self)


    def Rect(self, *args):
        """
        Rect(PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.PLOTTER_Circle(self, *args)


    def Arc(self, *args):
        """
        Arc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width)
        Arc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill)
        """
        return _pcbnew.PLOTTER_Arc(self, *args)


    def PenTo(self, pos, plume):
        """PenTo(PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.PLOTTER_PenTo(self, pos, plume)


    def MoveTo(self, pos):
        """MoveTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_MoveTo(self, pos)


    def LineTo(self, pos):
        """LineTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_LineTo(self, pos)


    def FinishTo(self, pos):
        """FinishTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_FinishTo(self, pos)


    def PenFinish(self):
        """PenFinish(PLOTTER self)"""
        return _pcbnew.PLOTTER_PenFinish(self)


    def PlotPoly(self, *args):
        """
        PlotPoly(PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.PLOTTER_PlotPoly(self, *args)


    def PlotImage(self, aImage, aPos, aScaleFactor):
        """PlotImage(PLOTTER self, wxImage const & aImage, wxPoint aPos, double aScaleFactor)"""
        return _pcbnew.PLOTTER_PlotImage(self, aImage, aPos, aScaleFactor)


    def ThickSegment(self, start, end, width, tracemode):
        """ThickSegment(PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode)"""
        return _pcbnew.PLOTTER_ThickSegment(self, start, end, width, tracemode)


    def ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode):
        """ThickArc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, int width, EDA_DRAW_MODE_T tracemode)"""
        return _pcbnew.PLOTTER_ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode)


    def ThickRect(self, p1, p2, width, tracemode):
        """ThickRect(PLOTTER self, wxPoint p1, wxPoint p2, int width, EDA_DRAW_MODE_T tracemode)"""
        return _pcbnew.PLOTTER_ThickRect(self, p1, p2, width, tracemode)


    def ThickCircle(self, pos, diametre, width, tracemode):
        """ThickCircle(PLOTTER self, wxPoint pos, int diametre, int width, EDA_DRAW_MODE_T tracemode)"""
        return _pcbnew.PLOTTER_ThickCircle(self, pos, diametre, width, tracemode)


    def FlashPadCircle(self, aPadPos, aDiameter, aTraceMode):
        """FlashPadCircle(PLOTTER self, wxPoint aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode)"""
        return _pcbnew.PLOTTER_FlashPadCircle(self, aPadPos, aDiameter, aTraceMode)


    def FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode):
        """FlashPadOval(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode)"""
        return _pcbnew.PLOTTER_FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode)


    def FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode):
        """FlashPadRect(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode)"""
        return _pcbnew.PLOTTER_FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode):
        """FlashPadTrapez(PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode)"""
        return _pcbnew.PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False):
        """
        Text(PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=False)
        Text(PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold)
        """
        return _pcbnew.PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed)

    MARKER_COUNT = _pcbnew.PLOTTER_MARKER_COUNT

    def Marker(self, position, diametre, aShapeId):
        """Marker(PLOTTER self, wxPoint position, int diametre, unsigned int aShapeId)"""
        return _pcbnew.PLOTTER_Marker(self, position, diametre, aShapeId)


    def SetLayerPolarity(self, aPositive):
        """SetLayerPolarity(PLOTTER self, bool aPositive)"""
        return _pcbnew.PLOTTER_SetLayerPolarity(self, aPositive)


    def SetTextMode(self, mode):
        """SetTextMode(PLOTTER self, PlotTextMode mode)"""
        return _pcbnew.PLOTTER_SetTextMode(self, mode)


    def SetGerberCoordinatesFormat(self, aResolution, aUseInches=False):
        """
        SetGerberCoordinatesFormat(PLOTTER self, int aResolution, bool aUseInches=False)
        SetGerberCoordinatesFormat(PLOTTER self, int aResolution)
        """
        return _pcbnew.PLOTTER_SetGerberCoordinatesFormat(self, aResolution, aUseInches)

PLOTTER_swigregister = _pcbnew.PLOTTER_swigregister
PLOTTER_swigregister(PLOTTER)

class HPGL_PLOTTER(PLOTTER):
    """Proxy of C++ HPGL_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HPGL_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HPGL_PLOTTER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(HPGL_PLOTTER self) -> HPGL_PLOTTER"""
        this = _pcbnew.new_HPGL_PLOTTER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPlotterType(self):
        """GetPlotterType(HPGL_PLOTTER self) -> PlotFormat"""
        return _pcbnew.HPGL_PLOTTER_GetPlotterType(self)


    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.HPGL_PLOTTER_GetDefaultFileExtension()

    if _newclass:
        GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)
    __swig_getmethods__["GetDefaultFileExtension"] = lambda x: GetDefaultFileExtension

    def StartPlot(self):
        """StartPlot(HPGL_PLOTTER self) -> bool"""
        return _pcbnew.HPGL_PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(HPGL_PLOTTER self) -> bool"""
        return _pcbnew.HPGL_PLOTTER_EndPlot(self)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(HPGL_PLOTTER self, int width)"""
        return _pcbnew.HPGL_PLOTTER_SetCurrentLineWidth(self, width)


    def SetDefaultLineWidth(self, width):
        """SetDefaultLineWidth(HPGL_PLOTTER self, int width)"""
        return _pcbnew.HPGL_PLOTTER_SetDefaultLineWidth(self, width)


    def SetDash(self, dashed):
        """SetDash(HPGL_PLOTTER self, bool dashed)"""
        return _pcbnew.HPGL_PLOTTER_SetDash(self, dashed)


    def SetColor(self, color):
        """SetColor(HPGL_PLOTTER self, EDA_COLOR_T color)"""
        return _pcbnew.HPGL_PLOTTER_SetColor(self, color)


    def SetPenSpeed(self, speed):
        """SetPenSpeed(HPGL_PLOTTER self, int speed)"""
        return _pcbnew.HPGL_PLOTTER_SetPenSpeed(self, speed)


    def SetPenNumber(self, number):
        """SetPenNumber(HPGL_PLOTTER self, int number)"""
        return _pcbnew.HPGL_PLOTTER_SetPenNumber(self, number)


    def SetPenDiameter(self, diameter):
        """SetPenDiameter(HPGL_PLOTTER self, double diameter)"""
        return _pcbnew.HPGL_PLOTTER_SetPenDiameter(self, diameter)


    def SetPenOverlap(self, overlap):
        """SetPenOverlap(HPGL_PLOTTER self, double overlap)"""
        return _pcbnew.HPGL_PLOTTER_SetPenOverlap(self, overlap)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(HPGL_PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.HPGL_PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def Rect(self, *args):
        """
        Rect(HPGL_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(HPGL_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.HPGL_PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(HPGL_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(HPGL_PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.HPGL_PLOTTER_Circle(self, *args)


    def PlotPoly(self, *args):
        """
        PlotPoly(HPGL_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(HPGL_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.HPGL_PLOTTER_PlotPoly(self, *args)


    def ThickSegment(self, start, end, width, tracemode):
        """ThickSegment(HPGL_PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode)"""
        return _pcbnew.HPGL_PLOTTER_ThickSegment(self, start, end, width, tracemode)


    def Arc(self, *args):
        """
        Arc(HPGL_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width)
        Arc(HPGL_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill)
        """
        return _pcbnew.HPGL_PLOTTER_Arc(self, *args)


    def PenTo(self, pos, plume):
        """PenTo(HPGL_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.HPGL_PLOTTER_PenTo(self, pos, plume)


    def FlashPadCircle(self, pos, diametre, trace_mode):
        """FlashPadCircle(HPGL_PLOTTER self, wxPoint pos, int diametre, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadCircle(self, pos, diametre, trace_mode)


    def FlashPadOval(self, pos, size, orient, trace_mode):
        """FlashPadOval(HPGL_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadOval(self, pos, size, orient, trace_mode)


    def FlashPadRect(self, pos, size, orient, trace_mode):
        """FlashPadRect(HPGL_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadRect(self, pos, size, orient, trace_mode)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode):
        """FlashPadTrapez(HPGL_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode)

    __swig_destroy__ = _pcbnew.delete_HPGL_PLOTTER
    __del__ = lambda self: None
HPGL_PLOTTER_swigregister = _pcbnew.HPGL_PLOTTER_swigregister
HPGL_PLOTTER_swigregister(HPGL_PLOTTER)

def HPGL_PLOTTER_GetDefaultFileExtension():
    """HPGL_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.HPGL_PLOTTER_GetDefaultFileExtension()

class PSLIKE_PLOTTER(PLOTTER):
    """Proxy of C++ PSLIKE_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PSLIKE_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PSLIKE_PLOTTER, name)

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

    def SetTextMode(self, mode):
        """SetTextMode(PSLIKE_PLOTTER self, PlotTextMode mode)"""
        return _pcbnew.PSLIKE_PLOTTER_SetTextMode(self, mode)


    def SetDefaultLineWidth(self, width):
        """SetDefaultLineWidth(PSLIKE_PLOTTER self, int width)"""
        return _pcbnew.PSLIKE_PLOTTER_SetDefaultLineWidth(self, width)


    def SetScaleAdjust(self, scaleX, scaleY):
        """SetScaleAdjust(PSLIKE_PLOTTER self, double scaleX, double scaleY)"""
        return _pcbnew.PSLIKE_PLOTTER_SetScaleAdjust(self, scaleX, scaleY)


    def FlashPadCircle(self, pos, diametre, trace_mode):
        """FlashPadCircle(PSLIKE_PLOTTER self, wxPoint pos, int diametre, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadCircle(self, pos, diametre, trace_mode)


    def FlashPadOval(self, pos, size, orient, trace_mode):
        """FlashPadOval(PSLIKE_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadOval(self, pos, size, orient, trace_mode)


    def FlashPadRect(self, pos, size, orient, trace_mode):
        """FlashPadRect(PSLIKE_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadRect(self, pos, size, orient, trace_mode)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode):
        """FlashPadTrapez(PSLIKE_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode)


    def SetColor(self, color):
        """SetColor(PSLIKE_PLOTTER self, EDA_COLOR_T color)"""
        return _pcbnew.PSLIKE_PLOTTER_SetColor(self, color)

    __swig_destroy__ = _pcbnew.delete_PSLIKE_PLOTTER
    __del__ = lambda self: None
PSLIKE_PLOTTER_swigregister = _pcbnew.PSLIKE_PLOTTER_swigregister
PSLIKE_PLOTTER_swigregister(PSLIKE_PLOTTER)

class PS_PLOTTER(PSLIKE_PLOTTER):
    """Proxy of C++ PS_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PSLIKE_PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PS_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PSLIKE_PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PS_PLOTTER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(PS_PLOTTER self) -> PS_PLOTTER"""
        this = _pcbnew.new_PS_PLOTTER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.PS_PLOTTER_GetDefaultFileExtension()

    if _newclass:
        GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)
    __swig_getmethods__["GetDefaultFileExtension"] = lambda x: GetDefaultFileExtension

    def GetPlotterType(self):
        """GetPlotterType(PS_PLOTTER self) -> PlotFormat"""
        return _pcbnew.PS_PLOTTER_GetPlotterType(self)


    def StartPlot(self):
        """StartPlot(PS_PLOTTER self) -> bool"""
        return _pcbnew.PS_PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(PS_PLOTTER self) -> bool"""
        return _pcbnew.PS_PLOTTER_EndPlot(self)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(PS_PLOTTER self, int width)"""
        return _pcbnew.PS_PLOTTER_SetCurrentLineWidth(self, width)


    def SetDash(self, dashed):
        """SetDash(PS_PLOTTER self, bool dashed)"""
        return _pcbnew.PS_PLOTTER_SetDash(self, dashed)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(PS_PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.PS_PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def Rect(self, *args):
        """
        Rect(PS_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(PS_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.PS_PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(PS_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(PS_PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.PS_PLOTTER_Circle(self, *args)


    def Arc(self, *args):
        """
        Arc(PS_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width)
        Arc(PS_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill)
        """
        return _pcbnew.PS_PLOTTER_Arc(self, *args)


    def PlotPoly(self, *args):
        """
        PlotPoly(PS_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(PS_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.PS_PLOTTER_PlotPoly(self, *args)


    def PlotImage(self, aImage, aPos, aScaleFactor):
        """PlotImage(PS_PLOTTER self, wxImage const & aImage, wxPoint aPos, double aScaleFactor)"""
        return _pcbnew.PS_PLOTTER_PlotImage(self, aImage, aPos, aScaleFactor)


    def PenTo(self, pos, plume):
        """PenTo(PS_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.PS_PLOTTER_PenTo(self, pos, plume)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False):
        """
        Text(PS_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=False)
        Text(PS_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold)
        """
        return _pcbnew.PS_PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed)

    __swig_destroy__ = _pcbnew.delete_PS_PLOTTER
    __del__ = lambda self: None
PS_PLOTTER_swigregister = _pcbnew.PS_PLOTTER_swigregister
PS_PLOTTER_swigregister(PS_PLOTTER)

def PS_PLOTTER_GetDefaultFileExtension():
    """PS_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.PS_PLOTTER_GetDefaultFileExtension()

class PDF_PLOTTER(PSLIKE_PLOTTER):
    """Proxy of C++ PDF_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PSLIKE_PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PDF_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PSLIKE_PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PDF_PLOTTER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(PDF_PLOTTER self) -> PDF_PLOTTER"""
        this = _pcbnew.new_PDF_PLOTTER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPlotterType(self):
        """GetPlotterType(PDF_PLOTTER self) -> PlotFormat"""
        return _pcbnew.PDF_PLOTTER_GetPlotterType(self)


    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.PDF_PLOTTER_GetDefaultFileExtension()

    if _newclass:
        GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)
    __swig_getmethods__["GetDefaultFileExtension"] = lambda x: GetDefaultFileExtension

    def OpenFile(self, aFullFilename):
        """OpenFile(PDF_PLOTTER self, wxString const & aFullFilename) -> bool"""
        return _pcbnew.PDF_PLOTTER_OpenFile(self, aFullFilename)


    def StartPlot(self):
        """StartPlot(PDF_PLOTTER self) -> bool"""
        return _pcbnew.PDF_PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(PDF_PLOTTER self) -> bool"""
        return _pcbnew.PDF_PLOTTER_EndPlot(self)


    def StartPage(self):
        """StartPage(PDF_PLOTTER self)"""
        return _pcbnew.PDF_PLOTTER_StartPage(self)


    def ClosePage(self):
        """ClosePage(PDF_PLOTTER self)"""
        return _pcbnew.PDF_PLOTTER_ClosePage(self)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(PDF_PLOTTER self, int width)"""
        return _pcbnew.PDF_PLOTTER_SetCurrentLineWidth(self, width)


    def SetDash(self, dashed):
        """SetDash(PDF_PLOTTER self, bool dashed)"""
        return _pcbnew.PDF_PLOTTER_SetDash(self, dashed)


    def SetPageSettings(self, aPageSettings):
        """SetPageSettings(PDF_PLOTTER self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.PDF_PLOTTER_SetPageSettings(self, aPageSettings)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(PDF_PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.PDF_PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def Rect(self, *args):
        """
        Rect(PDF_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(PDF_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.PDF_PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(PDF_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(PDF_PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.PDF_PLOTTER_Circle(self, *args)


    def Arc(self, *args):
        """
        Arc(PDF_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width)
        Arc(PDF_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill)
        """
        return _pcbnew.PDF_PLOTTER_Arc(self, *args)


    def PlotPoly(self, *args):
        """
        PlotPoly(PDF_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(PDF_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.PDF_PLOTTER_PlotPoly(self, *args)


    def PenTo(self, pos, plume):
        """PenTo(PDF_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.PDF_PLOTTER_PenTo(self, pos, plume)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False):
        """
        Text(PDF_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=False)
        Text(PDF_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold)
        """
        return _pcbnew.PDF_PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed)


    def PlotImage(self, aImage, aPos, aScaleFactor):
        """PlotImage(PDF_PLOTTER self, wxImage const & aImage, wxPoint aPos, double aScaleFactor)"""
        return _pcbnew.PDF_PLOTTER_PlotImage(self, aImage, aPos, aScaleFactor)

    __swig_destroy__ = _pcbnew.delete_PDF_PLOTTER
    __del__ = lambda self: None
PDF_PLOTTER_swigregister = _pcbnew.PDF_PLOTTER_swigregister
PDF_PLOTTER_swigregister(PDF_PLOTTER)

def PDF_PLOTTER_GetDefaultFileExtension():
    """PDF_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.PDF_PLOTTER_GetDefaultFileExtension()

class SVG_PLOTTER(PSLIKE_PLOTTER):
    """Proxy of C++ SVG_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PSLIKE_PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SVG_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PSLIKE_PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SVG_PLOTTER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(SVG_PLOTTER self) -> SVG_PLOTTER"""
        this = _pcbnew.new_SVG_PLOTTER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.SVG_PLOTTER_GetDefaultFileExtension()

    if _newclass:
        GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)
    __swig_getmethods__["GetDefaultFileExtension"] = lambda x: GetDefaultFileExtension

    def GetPlotterType(self):
        """GetPlotterType(SVG_PLOTTER self) -> PlotFormat"""
        return _pcbnew.SVG_PLOTTER_GetPlotterType(self)


    def SetColor(self, color):
        """SetColor(SVG_PLOTTER self, EDA_COLOR_T color)"""
        return _pcbnew.SVG_PLOTTER_SetColor(self, color)


    def StartPlot(self):
        """StartPlot(SVG_PLOTTER self) -> bool"""
        return _pcbnew.SVG_PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(SVG_PLOTTER self) -> bool"""
        return _pcbnew.SVG_PLOTTER_EndPlot(self)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(SVG_PLOTTER self, int width)"""
        return _pcbnew.SVG_PLOTTER_SetCurrentLineWidth(self, width)


    def SetDash(self, dashed):
        """SetDash(SVG_PLOTTER self, bool dashed)"""
        return _pcbnew.SVG_PLOTTER_SetDash(self, dashed)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(SVG_PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.SVG_PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def Rect(self, *args):
        """
        Rect(SVG_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(SVG_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.SVG_PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(SVG_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(SVG_PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.SVG_PLOTTER_Circle(self, *args)


    def Arc(self, *args):
        """
        Arc(SVG_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width)
        Arc(SVG_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill)
        """
        return _pcbnew.SVG_PLOTTER_Arc(self, *args)


    def PlotPoly(self, *args):
        """
        PlotPoly(SVG_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(SVG_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.SVG_PLOTTER_PlotPoly(self, *args)


    def PlotImage(self, aImage, aPos, aScaleFactor):
        """PlotImage(SVG_PLOTTER self, wxImage const & aImage, wxPoint aPos, double aScaleFactor)"""
        return _pcbnew.SVG_PLOTTER_PlotImage(self, aImage, aPos, aScaleFactor)


    def PenTo(self, pos, plume):
        """PenTo(SVG_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.SVG_PLOTTER_PenTo(self, pos, plume)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False):
        """
        Text(SVG_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=False)
        Text(SVG_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold)
        """
        return _pcbnew.SVG_PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed)

    __swig_destroy__ = _pcbnew.delete_SVG_PLOTTER
    __del__ = lambda self: None
SVG_PLOTTER_swigregister = _pcbnew.SVG_PLOTTER_swigregister
SVG_PLOTTER_swigregister(SVG_PLOTTER)

def SVG_PLOTTER_GetDefaultFileExtension():
    """SVG_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.SVG_PLOTTER_GetDefaultFileExtension()


_pcbnew.FIRST_DCODE_VALUE_swigconstant(_pcbnew)
FIRST_DCODE_VALUE = _pcbnew.FIRST_DCODE_VALUE
class APERTURE(_object):
    """Proxy of C++ APERTURE class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, APERTURE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, APERTURE, name)
    __repr__ = _swig_repr
    Circle = _pcbnew.APERTURE_Circle
    Rect = _pcbnew.APERTURE_Rect
    Plotting = _pcbnew.APERTURE_Plotting
    Oval = _pcbnew.APERTURE_Oval
    __swig_setmethods__["Size"] = _pcbnew.APERTURE_Size_set
    __swig_getmethods__["Size"] = _pcbnew.APERTURE_Size_get
    if _newclass:
        Size = _swig_property(_pcbnew.APERTURE_Size_get, _pcbnew.APERTURE_Size_set)
    __swig_setmethods__["Type"] = _pcbnew.APERTURE_Type_set
    __swig_getmethods__["Type"] = _pcbnew.APERTURE_Type_get
    if _newclass:
        Type = _swig_property(_pcbnew.APERTURE_Type_get, _pcbnew.APERTURE_Type_set)
    __swig_setmethods__["DCode"] = _pcbnew.APERTURE_DCode_set
    __swig_getmethods__["DCode"] = _pcbnew.APERTURE_DCode_get
    if _newclass:
        DCode = _swig_property(_pcbnew.APERTURE_DCode_get, _pcbnew.APERTURE_DCode_set)

    def __init__(self):
        """__init__(APERTURE self) -> APERTURE"""
        this = _pcbnew.new_APERTURE()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_APERTURE
    __del__ = lambda self: None
APERTURE_swigregister = _pcbnew.APERTURE_swigregister
APERTURE_swigregister(APERTURE)

class GERBER_PLOTTER(PLOTTER):
    """Proxy of C++ GERBER_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GERBER_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GERBER_PLOTTER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(GERBER_PLOTTER self) -> GERBER_PLOTTER"""
        this = _pcbnew.new_GERBER_PLOTTER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPlotterType(self):
        """GetPlotterType(GERBER_PLOTTER self) -> PlotFormat"""
        return _pcbnew.GERBER_PLOTTER_GetPlotterType(self)


    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.GERBER_PLOTTER_GetDefaultFileExtension()

    if _newclass:
        GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)
    __swig_getmethods__["GetDefaultFileExtension"] = lambda x: GetDefaultFileExtension

    def StartPlot(self):
        """StartPlot(GERBER_PLOTTER self) -> bool"""
        return _pcbnew.GERBER_PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(GERBER_PLOTTER self) -> bool"""
        return _pcbnew.GERBER_PLOTTER_EndPlot(self)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(GERBER_PLOTTER self, int width)"""
        return _pcbnew.GERBER_PLOTTER_SetCurrentLineWidth(self, width)


    def SetDefaultLineWidth(self, width):
        """SetDefaultLineWidth(GERBER_PLOTTER self, int width)"""
        return _pcbnew.GERBER_PLOTTER_SetDefaultLineWidth(self, width)


    def SetDash(self, dashed):
        """SetDash(GERBER_PLOTTER self, bool dashed)"""
        return _pcbnew.GERBER_PLOTTER_SetDash(self, dashed)


    def SetColor(self, color):
        """SetColor(GERBER_PLOTTER self, EDA_COLOR_T color)"""
        return _pcbnew.GERBER_PLOTTER_SetColor(self, color)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(GERBER_PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.GERBER_PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def Rect(self, *args):
        """
        Rect(GERBER_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(GERBER_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.GERBER_PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(GERBER_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(GERBER_PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.GERBER_PLOTTER_Circle(self, *args)


    def Arc(self, *args):
        """
        Arc(GERBER_PLOTTER self, wxPoint aCenter, double aStAngle, double aEndAngle, int aRadius, FILL_T aFill, int aWidth)
        Arc(GERBER_PLOTTER self, wxPoint aCenter, double aStAngle, double aEndAngle, int aRadius, FILL_T aFill)
        """
        return _pcbnew.GERBER_PLOTTER_Arc(self, *args)


    def PlotPoly(self, *args):
        """
        PlotPoly(GERBER_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(GERBER_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.GERBER_PLOTTER_PlotPoly(self, *args)


    def PenTo(self, pos, plume):
        """PenTo(GERBER_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.GERBER_PLOTTER_PenTo(self, pos, plume)


    def FlashPadCircle(self, pos, diametre, trace_mode):
        """FlashPadCircle(GERBER_PLOTTER self, wxPoint pos, int diametre, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadCircle(self, pos, diametre, trace_mode)


    def FlashPadOval(self, pos, size, orient, trace_mode):
        """FlashPadOval(GERBER_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadOval(self, pos, size, orient, trace_mode)


    def FlashPadRect(self, pos, size, orient, trace_mode):
        """FlashPadRect(GERBER_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadRect(self, pos, size, orient, trace_mode)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode):
        """FlashPadTrapez(GERBER_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode)


    def SetLayerPolarity(self, aPositive):
        """SetLayerPolarity(GERBER_PLOTTER self, bool aPositive)"""
        return _pcbnew.GERBER_PLOTTER_SetLayerPolarity(self, aPositive)


    def SetGerberCoordinatesFormat(self, aResolution, aUseInches=False):
        """
        SetGerberCoordinatesFormat(GERBER_PLOTTER self, int aResolution, bool aUseInches=False)
        SetGerberCoordinatesFormat(GERBER_PLOTTER self, int aResolution)
        """
        return _pcbnew.GERBER_PLOTTER_SetGerberCoordinatesFormat(self, aResolution, aUseInches)

    __swig_destroy__ = _pcbnew.delete_GERBER_PLOTTER
    __del__ = lambda self: None
GERBER_PLOTTER_swigregister = _pcbnew.GERBER_PLOTTER_swigregister
GERBER_PLOTTER_swigregister(GERBER_PLOTTER)

def GERBER_PLOTTER_GetDefaultFileExtension():
    """GERBER_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.GERBER_PLOTTER_GetDefaultFileExtension()

class DXF_PLOTTER(PLOTTER):
    """Proxy of C++ DXF_PLOTTER class"""
    __swig_setmethods__ = {}
    for _s in [PLOTTER]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DXF_PLOTTER, name, value)
    __swig_getmethods__ = {}
    for _s in [PLOTTER]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DXF_PLOTTER, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(DXF_PLOTTER self) -> DXF_PLOTTER"""
        this = _pcbnew.new_DXF_PLOTTER()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPlotterType(self):
        """GetPlotterType(DXF_PLOTTER self) -> PlotFormat"""
        return _pcbnew.DXF_PLOTTER_GetPlotterType(self)


    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.DXF_PLOTTER_GetDefaultFileExtension()

    if _newclass:
        GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)
    __swig_getmethods__["GetDefaultFileExtension"] = lambda x: GetDefaultFileExtension

    def SetTextMode(self, mode):
        """SetTextMode(DXF_PLOTTER self, PlotTextMode mode)"""
        return _pcbnew.DXF_PLOTTER_SetTextMode(self, mode)


    def StartPlot(self):
        """StartPlot(DXF_PLOTTER self) -> bool"""
        return _pcbnew.DXF_PLOTTER_StartPlot(self)


    def EndPlot(self):
        """EndPlot(DXF_PLOTTER self) -> bool"""
        return _pcbnew.DXF_PLOTTER_EndPlot(self)


    def SetCurrentLineWidth(self, width):
        """SetCurrentLineWidth(DXF_PLOTTER self, int width)"""
        return _pcbnew.DXF_PLOTTER_SetCurrentLineWidth(self, width)


    def SetDefaultLineWidth(self, width):
        """SetDefaultLineWidth(DXF_PLOTTER self, int width)"""
        return _pcbnew.DXF_PLOTTER_SetDefaultLineWidth(self, width)


    def SetDash(self, dashed):
        """SetDash(DXF_PLOTTER self, bool dashed)"""
        return _pcbnew.DXF_PLOTTER_SetDash(self, dashed)


    def SetColor(self, color):
        """SetColor(DXF_PLOTTER self, EDA_COLOR_T color)"""
        return _pcbnew.DXF_PLOTTER_SetColor(self, color)


    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        """SetViewport(DXF_PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.DXF_PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)


    def Rect(self, *args):
        """
        Rect(DXF_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width)
        Rect(DXF_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill)
        """
        return _pcbnew.DXF_PLOTTER_Rect(self, *args)


    def Circle(self, *args):
        """
        Circle(DXF_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width)
        Circle(DXF_PLOTTER self, wxPoint pos, int diametre, FILL_T fill)
        """
        return _pcbnew.DXF_PLOTTER_Circle(self, *args)


    def PlotPoly(self, *args):
        """
        PlotPoly(DXF_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(DXF_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        """
        return _pcbnew.DXF_PLOTTER_PlotPoly(self, *args)


    def ThickSegment(self, start, end, width, tracemode):
        """ThickSegment(DXF_PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode)"""
        return _pcbnew.DXF_PLOTTER_ThickSegment(self, start, end, width, tracemode)


    def Arc(self, *args):
        """
        Arc(DXF_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width)
        Arc(DXF_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill)
        """
        return _pcbnew.DXF_PLOTTER_Arc(self, *args)


    def PenTo(self, pos, plume):
        """PenTo(DXF_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.DXF_PLOTTER_PenTo(self, pos, plume)


    def FlashPadCircle(self, pos, diametre, trace_mode):
        """FlashPadCircle(DXF_PLOTTER self, wxPoint pos, int diametre, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.DXF_PLOTTER_FlashPadCircle(self, pos, diametre, trace_mode)


    def FlashPadOval(self, pos, size, orient, trace_mode):
        """FlashPadOval(DXF_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.DXF_PLOTTER_FlashPadOval(self, pos, size, orient, trace_mode)


    def FlashPadRect(self, pos, size, orient, trace_mode):
        """FlashPadRect(DXF_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode)"""
        return _pcbnew.DXF_PLOTTER_FlashPadRect(self, pos, size, orient, trace_mode)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode):
        """FlashPadTrapez(DXF_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode)"""
        return _pcbnew.DXF_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTrace_Mode)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False):
        """
        Text(DXF_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=False)
        Text(DXF_PLOTTER self, wxPoint aPos, enum EDA_COLOR_T aColor, wxString const & aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold)
        """
        return _pcbnew.DXF_PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed)

    __swig_destroy__ = _pcbnew.delete_DXF_PLOTTER
    __del__ = lambda self: None
DXF_PLOTTER_swigregister = _pcbnew.DXF_PLOTTER_swigregister
DXF_PLOTTER_swigregister(DXF_PLOTTER)

def DXF_PLOTTER_GetDefaultFileExtension():
    """DXF_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.DXF_PLOTTER_GetDefaultFileExtension()


def PlotWorkSheet(plotter, aTitleBlock, aPageInfo, aSheetNumber, aNumberOfSheets, aSheetDesc, aFilename):
    """PlotWorkSheet(PLOTTER plotter, TITLE_BLOCK aTitleBlock, PAGE_INFO const & aPageInfo, int aSheetNumber, int aNumberOfSheets, wxString const & aSheetDesc, wxString const & aFilename)"""
    return _pcbnew.PlotWorkSheet(plotter, aTitleBlock, aPageInfo, aSheetNumber, aNumberOfSheets, aSheetDesc, aFilename)

def GetDefaultPlotExtension(aFormat):
    """GetDefaultPlotExtension(PlotFormat aFormat) -> wxString"""
    return _pcbnew.GetDefaultPlotExtension(aFormat)
class DRILL_TOOL(_object):
    """Proxy of C++ DRILL_TOOL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DRILL_TOOL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DRILL_TOOL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Diameter"] = _pcbnew.DRILL_TOOL_m_Diameter_set
    __swig_getmethods__["m_Diameter"] = _pcbnew.DRILL_TOOL_m_Diameter_get
    if _newclass:
        m_Diameter = _swig_property(_pcbnew.DRILL_TOOL_m_Diameter_get, _pcbnew.DRILL_TOOL_m_Diameter_set)
    __swig_setmethods__["m_TotalCount"] = _pcbnew.DRILL_TOOL_m_TotalCount_set
    __swig_getmethods__["m_TotalCount"] = _pcbnew.DRILL_TOOL_m_TotalCount_get
    if _newclass:
        m_TotalCount = _swig_property(_pcbnew.DRILL_TOOL_m_TotalCount_get, _pcbnew.DRILL_TOOL_m_TotalCount_set)
    __swig_setmethods__["m_OvalCount"] = _pcbnew.DRILL_TOOL_m_OvalCount_set
    __swig_getmethods__["m_OvalCount"] = _pcbnew.DRILL_TOOL_m_OvalCount_get
    if _newclass:
        m_OvalCount = _swig_property(_pcbnew.DRILL_TOOL_m_OvalCount_get, _pcbnew.DRILL_TOOL_m_OvalCount_set)

    def __init__(self, diametre):
        """__init__(DRILL_TOOL self, int diametre) -> DRILL_TOOL"""
        this = _pcbnew.new_DRILL_TOOL(diametre)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_DRILL_TOOL
    __del__ = lambda self: None
DRILL_TOOL_swigregister = _pcbnew.DRILL_TOOL_swigregister
DRILL_TOOL_swigregister(DRILL_TOOL)

class HOLE_INFO(_object):
    """Proxy of C++ HOLE_INFO class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HOLE_INFO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HOLE_INFO, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Hole_Diameter"] = _pcbnew.HOLE_INFO_m_Hole_Diameter_set
    __swig_getmethods__["m_Hole_Diameter"] = _pcbnew.HOLE_INFO_m_Hole_Diameter_get
    if _newclass:
        m_Hole_Diameter = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Diameter_get, _pcbnew.HOLE_INFO_m_Hole_Diameter_set)
    __swig_setmethods__["m_Tool_Reference"] = _pcbnew.HOLE_INFO_m_Tool_Reference_set
    __swig_getmethods__["m_Tool_Reference"] = _pcbnew.HOLE_INFO_m_Tool_Reference_get
    if _newclass:
        m_Tool_Reference = _swig_property(_pcbnew.HOLE_INFO_m_Tool_Reference_get, _pcbnew.HOLE_INFO_m_Tool_Reference_set)
    __swig_setmethods__["m_Hole_Size"] = _pcbnew.HOLE_INFO_m_Hole_Size_set
    __swig_getmethods__["m_Hole_Size"] = _pcbnew.HOLE_INFO_m_Hole_Size_get
    if _newclass:
        m_Hole_Size = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Size_get, _pcbnew.HOLE_INFO_m_Hole_Size_set)
    __swig_setmethods__["m_Hole_Orient"] = _pcbnew.HOLE_INFO_m_Hole_Orient_set
    __swig_getmethods__["m_Hole_Orient"] = _pcbnew.HOLE_INFO_m_Hole_Orient_get
    if _newclass:
        m_Hole_Orient = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Orient_get, _pcbnew.HOLE_INFO_m_Hole_Orient_set)
    __swig_setmethods__["m_Hole_Shape"] = _pcbnew.HOLE_INFO_m_Hole_Shape_set
    __swig_getmethods__["m_Hole_Shape"] = _pcbnew.HOLE_INFO_m_Hole_Shape_get
    if _newclass:
        m_Hole_Shape = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Shape_get, _pcbnew.HOLE_INFO_m_Hole_Shape_set)
    __swig_setmethods__["m_Hole_Pos"] = _pcbnew.HOLE_INFO_m_Hole_Pos_set
    __swig_getmethods__["m_Hole_Pos"] = _pcbnew.HOLE_INFO_m_Hole_Pos_get
    if _newclass:
        m_Hole_Pos = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Pos_get, _pcbnew.HOLE_INFO_m_Hole_Pos_set)
    __swig_setmethods__["m_Hole_Bottom_Layer"] = _pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_set
    __swig_getmethods__["m_Hole_Bottom_Layer"] = _pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_get
    if _newclass:
        m_Hole_Bottom_Layer = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_get, _pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_set)
    __swig_setmethods__["m_Hole_Top_Layer"] = _pcbnew.HOLE_INFO_m_Hole_Top_Layer_set
    __swig_getmethods__["m_Hole_Top_Layer"] = _pcbnew.HOLE_INFO_m_Hole_Top_Layer_get
    if _newclass:
        m_Hole_Top_Layer = _swig_property(_pcbnew.HOLE_INFO_m_Hole_Top_Layer_get, _pcbnew.HOLE_INFO_m_Hole_Top_Layer_set)
    __swig_setmethods__["m_Hole_NotPlated"] = _pcbnew.HOLE_INFO_m_Hole_NotPlated_set
    __swig_getmethods__["m_Hole_NotPlated"] = _pcbnew.HOLE_INFO_m_Hole_NotPlated_get
    if _newclass:
        m_Hole_NotPlated = _swig_property(_pcbnew.HOLE_INFO_m_Hole_NotPlated_get, _pcbnew.HOLE_INFO_m_Hole_NotPlated_set)

    def __init__(self):
        """__init__(HOLE_INFO self) -> HOLE_INFO"""
        this = _pcbnew.new_HOLE_INFO()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_HOLE_INFO
    __del__ = lambda self: None
HOLE_INFO_swigregister = _pcbnew.HOLE_INFO_swigregister
HOLE_INFO_swigregister(HOLE_INFO)

class DRILL_PRECISION(_object):
    """Proxy of C++ DRILL_PRECISION class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DRILL_PRECISION, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DRILL_PRECISION, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_lhs"] = _pcbnew.DRILL_PRECISION_m_lhs_set
    __swig_getmethods__["m_lhs"] = _pcbnew.DRILL_PRECISION_m_lhs_get
    if _newclass:
        m_lhs = _swig_property(_pcbnew.DRILL_PRECISION_m_lhs_get, _pcbnew.DRILL_PRECISION_m_lhs_set)
    __swig_setmethods__["m_rhs"] = _pcbnew.DRILL_PRECISION_m_rhs_set
    __swig_getmethods__["m_rhs"] = _pcbnew.DRILL_PRECISION_m_rhs_get
    if _newclass:
        m_rhs = _swig_property(_pcbnew.DRILL_PRECISION_m_rhs_get, _pcbnew.DRILL_PRECISION_m_rhs_set)

    def __init__(self, l=2, r=4):
        """
        __init__(DRILL_PRECISION self, int l=2, int r=4) -> DRILL_PRECISION
        __init__(DRILL_PRECISION self, int l=2) -> DRILL_PRECISION
        __init__(DRILL_PRECISION self) -> DRILL_PRECISION
        """
        this = _pcbnew.new_DRILL_PRECISION(l, r)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPrecisionString(self):
        """GetPrecisionString(DRILL_PRECISION self) -> wxString"""
        return _pcbnew.DRILL_PRECISION_GetPrecisionString(self)

    __swig_destroy__ = _pcbnew.delete_DRILL_PRECISION
    __del__ = lambda self: None
DRILL_PRECISION_swigregister = _pcbnew.DRILL_PRECISION_swigregister
DRILL_PRECISION_swigregister(DRILL_PRECISION)

class EXCELLON_WRITER(_object):
    """Proxy of C++ EXCELLON_WRITER class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EXCELLON_WRITER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EXCELLON_WRITER, name)
    __repr__ = _swig_repr
    DECIMAL_FORMAT = _pcbnew.EXCELLON_WRITER_DECIMAL_FORMAT
    SUPPRESS_LEADING = _pcbnew.EXCELLON_WRITER_SUPPRESS_LEADING
    SUPPRESS_TRAILING = _pcbnew.EXCELLON_WRITER_SUPPRESS_TRAILING
    KEEP_ZEROS = _pcbnew.EXCELLON_WRITER_KEEP_ZEROS
    __swig_setmethods__["m_Offset"] = _pcbnew.EXCELLON_WRITER_m_Offset_set
    __swig_getmethods__["m_Offset"] = _pcbnew.EXCELLON_WRITER_m_Offset_get
    if _newclass:
        m_Offset = _swig_property(_pcbnew.EXCELLON_WRITER_m_Offset_get, _pcbnew.EXCELLON_WRITER_m_Offset_set)
    __swig_setmethods__["m_ShortHeader"] = _pcbnew.EXCELLON_WRITER_m_ShortHeader_set
    __swig_getmethods__["m_ShortHeader"] = _pcbnew.EXCELLON_WRITER_m_ShortHeader_get
    if _newclass:
        m_ShortHeader = _swig_property(_pcbnew.EXCELLON_WRITER_m_ShortHeader_get, _pcbnew.EXCELLON_WRITER_m_ShortHeader_set)

    def __init__(self, aPcb):
        """__init__(EXCELLON_WRITER self, BOARD aPcb) -> EXCELLON_WRITER"""
        this = _pcbnew.new_EXCELLON_WRITER(aPcb)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_EXCELLON_WRITER
    __del__ = lambda self: None

    def GetOffset(self):
        """GetOffset(EXCELLON_WRITER self) -> wxPoint"""
        return _pcbnew.EXCELLON_WRITER_GetOffset(self)


    def SetFormat(self, *args):
        """
        SetFormat(EXCELLON_WRITER self, bool aMetric, EXCELLON_WRITER::ZEROS_FMT aZerosFmt, int aLeftDigits=0, int aRightDigits=0)
        SetFormat(EXCELLON_WRITER self, bool aMetric, EXCELLON_WRITER::ZEROS_FMT aZerosFmt, int aLeftDigits=0)
        SetFormat(EXCELLON_WRITER self, bool aMetric, EXCELLON_WRITER::ZEROS_FMT aZerosFmt)
        SetFormat(EXCELLON_WRITER self, bool aMetric)
        """
        return _pcbnew.EXCELLON_WRITER_SetFormat(self, *args)


    def SetPageInfo(self, aPageInfo):
        """SetPageInfo(EXCELLON_WRITER self, PAGE_INFO const * aPageInfo)"""
        return _pcbnew.EXCELLON_WRITER_SetPageInfo(self, aPageInfo)


    def SetMapFileFormat(self, aMapFmt):
        """SetMapFileFormat(EXCELLON_WRITER self, PlotFormat aMapFmt)"""
        return _pcbnew.EXCELLON_WRITER_SetMapFileFormat(self, aMapFmt)


    def SetOptions(self, aMirror, aMinimalHeader, aOffset, aMerge_PTH_NPTH):
        """SetOptions(EXCELLON_WRITER self, bool aMirror, bool aMinimalHeader, wxPoint aOffset, bool aMerge_PTH_NPTH)"""
        return _pcbnew.EXCELLON_WRITER_SetOptions(self, aMirror, aMinimalHeader, aOffset, aMerge_PTH_NPTH)


    def BuildHolesList(self, aFirstLayer, aLastLayer, aExcludeThroughHoles, aGenerateNPTH_list, aMerge_PTH_NPTH):
        """BuildHolesList(EXCELLON_WRITER self, int aFirstLayer, int aLastLayer, bool aExcludeThroughHoles, bool aGenerateNPTH_list, bool aMerge_PTH_NPTH)"""
        return _pcbnew.EXCELLON_WRITER_BuildHolesList(self, aFirstLayer, aLastLayer, aExcludeThroughHoles, aGenerateNPTH_list, aMerge_PTH_NPTH)


    def GetHolesCount(self):
        """GetHolesCount(EXCELLON_WRITER self) -> int"""
        return _pcbnew.EXCELLON_WRITER_GetHolesCount(self)


    def CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter=None):
        """
        CreateDrillandMapFilesSet(EXCELLON_WRITER self, wxString const & aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER * aReporter=None)
        CreateDrillandMapFilesSet(EXCELLON_WRITER self, wxString const & aPlotDirectory, bool aGenDrill, bool aGenMap)
        """
        return _pcbnew.EXCELLON_WRITER_CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter)


    def CreateDrillFile(self, aFile):
        """CreateDrillFile(EXCELLON_WRITER self, FILE * aFile) -> int"""
        return _pcbnew.EXCELLON_WRITER_CreateDrillFile(self, aFile)


    def GenDrillReportFile(self, aFullFileName):
        """GenDrillReportFile(EXCELLON_WRITER self, wxString const & aFullFileName) -> bool"""
        return _pcbnew.EXCELLON_WRITER_GenDrillReportFile(self, aFullFileName)


    def GenDrillMapFile(self, aFullFileName, aFormat):
        """GenDrillMapFile(EXCELLON_WRITER self, wxString const & aFullFileName, PlotFormat aFormat) -> bool"""
        return _pcbnew.EXCELLON_WRITER_GenDrillMapFile(self, aFullFileName, aFormat)

EXCELLON_WRITER_swigregister = _pcbnew.EXCELLON_WRITER_swigregister
EXCELLON_WRITER_swigregister(EXCELLON_WRITER)


_pcbnew.UNSPECIFIED_COLOR_swigconstant(_pcbnew)
UNSPECIFIED_COLOR = _pcbnew.UNSPECIFIED_COLOR

_pcbnew.BLACK_swigconstant(_pcbnew)
BLACK = _pcbnew.BLACK

_pcbnew.DARKDARKGRAY_swigconstant(_pcbnew)
DARKDARKGRAY = _pcbnew.DARKDARKGRAY

_pcbnew.DARKGRAY_swigconstant(_pcbnew)
DARKGRAY = _pcbnew.DARKGRAY

_pcbnew.LIGHTGRAY_swigconstant(_pcbnew)
LIGHTGRAY = _pcbnew.LIGHTGRAY

_pcbnew.WHITE_swigconstant(_pcbnew)
WHITE = _pcbnew.WHITE

_pcbnew.LIGHTYELLOW_swigconstant(_pcbnew)
LIGHTYELLOW = _pcbnew.LIGHTYELLOW

_pcbnew.DARKBLUE_swigconstant(_pcbnew)
DARKBLUE = _pcbnew.DARKBLUE

_pcbnew.DARKGREEN_swigconstant(_pcbnew)
DARKGREEN = _pcbnew.DARKGREEN

_pcbnew.DARKCYAN_swigconstant(_pcbnew)
DARKCYAN = _pcbnew.DARKCYAN

_pcbnew.DARKRED_swigconstant(_pcbnew)
DARKRED = _pcbnew.DARKRED

_pcbnew.DARKMAGENTA_swigconstant(_pcbnew)
DARKMAGENTA = _pcbnew.DARKMAGENTA

_pcbnew.DARKBROWN_swigconstant(_pcbnew)
DARKBROWN = _pcbnew.DARKBROWN

_pcbnew.BLUE_swigconstant(_pcbnew)
BLUE = _pcbnew.BLUE

_pcbnew.GREEN_swigconstant(_pcbnew)
GREEN = _pcbnew.GREEN

_pcbnew.CYAN_swigconstant(_pcbnew)
CYAN = _pcbnew.CYAN

_pcbnew.RED_swigconstant(_pcbnew)
RED = _pcbnew.RED

_pcbnew.MAGENTA_swigconstant(_pcbnew)
MAGENTA = _pcbnew.MAGENTA

_pcbnew.BROWN_swigconstant(_pcbnew)
BROWN = _pcbnew.BROWN

_pcbnew.LIGHTBLUE_swigconstant(_pcbnew)
LIGHTBLUE = _pcbnew.LIGHTBLUE

_pcbnew.LIGHTGREEN_swigconstant(_pcbnew)
LIGHTGREEN = _pcbnew.LIGHTGREEN

_pcbnew.LIGHTCYAN_swigconstant(_pcbnew)
LIGHTCYAN = _pcbnew.LIGHTCYAN

_pcbnew.LIGHTRED_swigconstant(_pcbnew)
LIGHTRED = _pcbnew.LIGHTRED

_pcbnew.LIGHTMAGENTA_swigconstant(_pcbnew)
LIGHTMAGENTA = _pcbnew.LIGHTMAGENTA

_pcbnew.YELLOW_swigconstant(_pcbnew)
YELLOW = _pcbnew.YELLOW

_pcbnew.PUREBLUE_swigconstant(_pcbnew)
PUREBLUE = _pcbnew.PUREBLUE

_pcbnew.PUREGREEN_swigconstant(_pcbnew)
PUREGREEN = _pcbnew.PUREGREEN

_pcbnew.PURECYAN_swigconstant(_pcbnew)
PURECYAN = _pcbnew.PURECYAN

_pcbnew.PURERED_swigconstant(_pcbnew)
PURERED = _pcbnew.PURERED

_pcbnew.PUREMAGENTA_swigconstant(_pcbnew)
PUREMAGENTA = _pcbnew.PUREMAGENTA

_pcbnew.PUREYELLOW_swigconstant(_pcbnew)
PUREYELLOW = _pcbnew.PUREYELLOW

_pcbnew.NBCOLORS_swigconstant(_pcbnew)
NBCOLORS = _pcbnew.NBCOLORS

_pcbnew.HIGHLIGHT_FLAG_swigconstant(_pcbnew)
HIGHLIGHT_FLAG = _pcbnew.HIGHLIGHT_FLAG

_pcbnew.MASKCOLOR_swigconstant(_pcbnew)
MASKCOLOR = _pcbnew.MASKCOLOR

def ColorFromInt(aColor):
    """ColorFromInt(int aColor) -> EDA_COLOR_T"""
    return _pcbnew.ColorFromInt(aColor)

def NextColor(aColor):
    """NextColor(EDA_COLOR_T & aColor) -> EDA_COLOR_T"""
    return _pcbnew.NextColor(aColor)

def ColorGetBase(aColor):
    """ColorGetBase(EDA_COLOR_T aColor) -> EDA_COLOR_T"""
    return _pcbnew.ColorGetBase(aColor)

def ColorMix(aColor1, aColor2):
    """ColorMix(EDA_COLOR_T aColor1, EDA_COLOR_T aColor2) -> EDA_COLOR_T"""
    return _pcbnew.ColorMix(aColor1, aColor2)

def ColorTurnToDarkDarkGray(aColor):
    """ColorTurnToDarkDarkGray(EDA_COLOR_T * aColor)"""
    return _pcbnew.ColorTurnToDarkDarkGray(aColor)

def ColorChangeHighlightFlag(aColor, flag):
    """ColorChangeHighlightFlag(EDA_COLOR_T * aColor, bool flag)"""
    return _pcbnew.ColorChangeHighlightFlag(aColor, flag)

def SetAlpha(aColor, aBlend):
    """SetAlpha(EDA_COLOR_T * aColor, unsigned char aBlend)"""
    return _pcbnew.SetAlpha(aColor, aBlend)

def GetAlpha(aColor):
    """GetAlpha(EDA_COLOR_T aColor) -> unsigned char"""
    return _pcbnew.GetAlpha(aColor)
class StructColors(_object):
    """Proxy of C++ StructColors class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StructColors, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StructColors, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Blue"] = _pcbnew.StructColors_m_Blue_set
    __swig_getmethods__["m_Blue"] = _pcbnew.StructColors_m_Blue_get
    if _newclass:
        m_Blue = _swig_property(_pcbnew.StructColors_m_Blue_get, _pcbnew.StructColors_m_Blue_set)
    __swig_setmethods__["m_Green"] = _pcbnew.StructColors_m_Green_set
    __swig_getmethods__["m_Green"] = _pcbnew.StructColors_m_Green_get
    if _newclass:
        m_Green = _swig_property(_pcbnew.StructColors_m_Green_get, _pcbnew.StructColors_m_Green_set)
    __swig_setmethods__["m_Red"] = _pcbnew.StructColors_m_Red_set
    __swig_getmethods__["m_Red"] = _pcbnew.StructColors_m_Red_get
    if _newclass:
        m_Red = _swig_property(_pcbnew.StructColors_m_Red_get, _pcbnew.StructColors_m_Red_set)
    __swig_setmethods__["m_Numcolor"] = _pcbnew.StructColors_m_Numcolor_set
    __swig_getmethods__["m_Numcolor"] = _pcbnew.StructColors_m_Numcolor_get
    if _newclass:
        m_Numcolor = _swig_property(_pcbnew.StructColors_m_Numcolor_get, _pcbnew.StructColors_m_Numcolor_set)
    __swig_setmethods__["m_Name"] = _pcbnew.StructColors_m_Name_set
    __swig_getmethods__["m_Name"] = _pcbnew.StructColors_m_Name_get
    if _newclass:
        m_Name = _swig_property(_pcbnew.StructColors_m_Name_get, _pcbnew.StructColors_m_Name_set)
    __swig_setmethods__["m_LightColor"] = _pcbnew.StructColors_m_LightColor_set
    __swig_getmethods__["m_LightColor"] = _pcbnew.StructColors_m_LightColor_get
    if _newclass:
        m_LightColor = _swig_property(_pcbnew.StructColors_m_LightColor_get, _pcbnew.StructColors_m_LightColor_set)

    def __init__(self):
        """__init__(StructColors self) -> StructColors"""
        this = _pcbnew.new_StructColors()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_StructColors
    __del__ = lambda self: None
StructColors_swigregister = _pcbnew.StructColors_swigregister
StructColors_swigregister(StructColors)


def ColorApplyHighlightFlag(aColor):
    """ColorApplyHighlightFlag(EDA_COLOR_T * aColor)"""
    return _pcbnew.ColorApplyHighlightFlag(aColor)

def ColorByName(aName):
    """ColorByName(wxString const & aName) -> EDA_COLOR_T"""
    return _pcbnew.ColorByName(aName)

def ColorFindNearest(*args):
    """
    ColorFindNearest(wxColour const & aColor) -> EDA_COLOR_T
    ColorFindNearest(int aR, int aG, int aB) -> EDA_COLOR_T
    """
    return _pcbnew.ColorFindNearest(*args)

def ColorIsLight(aColor):
    """ColorIsLight(EDA_COLOR_T aColor) -> bool"""
    return _pcbnew.ColorIsLight(aColor)

def ColorGetName(aColor):
    """ColorGetName(EDA_COLOR_T aColor) -> wxChar const *"""
    return _pcbnew.ColorGetName(aColor)

def ColorSetBrush(aBrush, aColor):
    """ColorSetBrush(wxBrush * aBrush, EDA_COLOR_T aColor)"""
    return _pcbnew.ColorSetBrush(aBrush, aColor)

def MakeColour(aColor):
    """MakeColour(EDA_COLOR_T aColor) -> wxColour"""
    return _pcbnew.MakeColour(aColor)

def Cast_to_BOARD_ITEM(base):
    """Cast_to_BOARD_ITEM(EDA_ITEM base) -> BOARD_ITEM"""
    return _pcbnew.Cast_to_BOARD_ITEM(base)

def GetBoard():
    """GetBoard() -> BOARD"""
    return _pcbnew.GetBoard()

def LoadBoard(*args):
    """
    LoadBoard(wxString & aFileName, IO_MGR::PCB_FILE_T aFormat) -> BOARD
    LoadBoard(wxString & aFileName) -> BOARD
    """
    return _pcbnew.LoadBoard(*args)

def SaveBoard(*args):
    """
    SaveBoard(wxString & aFileName, BOARD aBoard, IO_MGR::PCB_FILE_T aFormat) -> bool
    SaveBoard(wxString & aFileName, BOARD aBoard) -> bool
    """
    return _pcbnew.SaveBoard(*args)
class PROPERTIES(str_utf8_Map):
    """Proxy of C++ PROPERTIES class"""
    __swig_setmethods__ = {}
    for _s in [str_utf8_Map]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PROPERTIES, name, value)
    __swig_getmethods__ = {}
    for _s in [str_utf8_Map]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PROPERTIES, name)
    __repr__ = _swig_repr

    def Value(self, aName, aFetchedValue=None):
        """
        Value(PROPERTIES self, char const * aName, UTF8 aFetchedValue=None) -> bool
        Value(PROPERTIES self, char const * aName) -> bool
        """
        return _pcbnew.PROPERTIES_Value(self, aName, aFetchedValue)


    def __init__(self):
        """__init__(PROPERTIES self) -> PROPERTIES"""
        this = _pcbnew.new_PROPERTIES()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PROPERTIES
    __del__ = lambda self: None
PROPERTIES_swigregister = _pcbnew.PROPERTIES_swigregister
PROPERTIES_swigregister(PROPERTIES)
g_ColorRefs = cvar.g_ColorRefs

class IO_MGR(_object):
    """Proxy of C++ IO_MGR class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IO_MGR, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IO_MGR, name)
    __repr__ = _swig_repr
    LEGACY = _pcbnew.IO_MGR_LEGACY
    KICAD = _pcbnew.IO_MGR_KICAD
    EAGLE = _pcbnew.IO_MGR_EAGLE
    PCAD = _pcbnew.IO_MGR_PCAD
    GEDA_PCB = _pcbnew.IO_MGR_GEDA_PCB
    GITHUB = _pcbnew.IO_MGR_GITHUB

    def PluginFind(aFileType):
        """PluginFind(IO_MGR::PCB_FILE_T aFileType) -> PLUGIN"""
        return _pcbnew.IO_MGR_PluginFind(aFileType)

    if _newclass:
        PluginFind = staticmethod(PluginFind)
    __swig_getmethods__["PluginFind"] = lambda x: PluginFind

    def PluginRelease(aPlugin):
        """PluginRelease(PLUGIN aPlugin)"""
        return _pcbnew.IO_MGR_PluginRelease(aPlugin)

    if _newclass:
        PluginRelease = staticmethod(PluginRelease)
    __swig_getmethods__["PluginRelease"] = lambda x: PluginRelease

    def ShowType(aFileType):
        """ShowType(IO_MGR::PCB_FILE_T aFileType) -> wxString const"""
        return _pcbnew.IO_MGR_ShowType(aFileType)

    if _newclass:
        ShowType = staticmethod(ShowType)
    __swig_getmethods__["ShowType"] = lambda x: ShowType

    def EnumFromStr(aFileType):
        """EnumFromStr(wxString const & aFileType) -> IO_MGR::PCB_FILE_T"""
        return _pcbnew.IO_MGR_EnumFromStr(aFileType)

    if _newclass:
        EnumFromStr = staticmethod(EnumFromStr)
    __swig_getmethods__["EnumFromStr"] = lambda x: EnumFromStr

    def GetFileExtension(aFileType):
        """GetFileExtension(IO_MGR::PCB_FILE_T aFileType) -> wxString const"""
        return _pcbnew.IO_MGR_GetFileExtension(aFileType)

    if _newclass:
        GetFileExtension = staticmethod(GetFileExtension)
    __swig_getmethods__["GetFileExtension"] = lambda x: GetFileExtension

    def GuessPluginTypeFromLibPath(aLibPath):
        """GuessPluginTypeFromLibPath(wxString const & aLibPath) -> IO_MGR::PCB_FILE_T"""
        return _pcbnew.IO_MGR_GuessPluginTypeFromLibPath(aLibPath)

    if _newclass:
        GuessPluginTypeFromLibPath = staticmethod(GuessPluginTypeFromLibPath)
    __swig_getmethods__["GuessPluginTypeFromLibPath"] = lambda x: GuessPluginTypeFromLibPath

    def Load(aFileType, aFileName, aAppendToMe=None, aProperties=None):
        """
        Load(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aAppendToMe=None, PROPERTIES aProperties=None) -> BOARD
        Load(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aAppendToMe=None) -> BOARD
        Load(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName) -> BOARD
        """
        return _pcbnew.IO_MGR_Load(aFileType, aFileName, aAppendToMe, aProperties)

    if _newclass:
        Load = staticmethod(Load)
    __swig_getmethods__["Load"] = lambda x: Load

    def Save(aFileType, aFileName, aBoard, aProperties=None):
        """
        Save(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aBoard, PROPERTIES aProperties=None)
        Save(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aBoard)
        """
        return _pcbnew.IO_MGR_Save(aFileType, aFileName, aBoard, aProperties)

    if _newclass:
        Save = staticmethod(Save)
    __swig_getmethods__["Save"] = lambda x: Save

    def __init__(self):
        """__init__(IO_MGR self) -> IO_MGR"""
        this = _pcbnew.new_IO_MGR()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_IO_MGR
    __del__ = lambda self: None
IO_MGR_swigregister = _pcbnew.IO_MGR_swigregister
IO_MGR_swigregister(IO_MGR)

def IO_MGR_PluginFind(aFileType):
    """IO_MGR_PluginFind(IO_MGR::PCB_FILE_T aFileType) -> PLUGIN"""
    return _pcbnew.IO_MGR_PluginFind(aFileType)

def IO_MGR_PluginRelease(aPlugin):
    """IO_MGR_PluginRelease(PLUGIN aPlugin)"""
    return _pcbnew.IO_MGR_PluginRelease(aPlugin)

def IO_MGR_ShowType(aFileType):
    """IO_MGR_ShowType(IO_MGR::PCB_FILE_T aFileType) -> wxString const"""
    return _pcbnew.IO_MGR_ShowType(aFileType)

def IO_MGR_EnumFromStr(aFileType):
    """IO_MGR_EnumFromStr(wxString const & aFileType) -> IO_MGR::PCB_FILE_T"""
    return _pcbnew.IO_MGR_EnumFromStr(aFileType)

def IO_MGR_GetFileExtension(aFileType):
    """IO_MGR_GetFileExtension(IO_MGR::PCB_FILE_T aFileType) -> wxString const"""
    return _pcbnew.IO_MGR_GetFileExtension(aFileType)

def IO_MGR_GuessPluginTypeFromLibPath(aLibPath):
    """IO_MGR_GuessPluginTypeFromLibPath(wxString const & aLibPath) -> IO_MGR::PCB_FILE_T"""
    return _pcbnew.IO_MGR_GuessPluginTypeFromLibPath(aLibPath)

def IO_MGR_Load(aFileType, aFileName, aAppendToMe=None, aProperties=None):
    """
    Load(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aAppendToMe=None, PROPERTIES aProperties=None) -> BOARD
    Load(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aAppendToMe=None) -> BOARD
    IO_MGR_Load(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName) -> BOARD
    """
    return _pcbnew.IO_MGR_Load(aFileType, aFileName, aAppendToMe, aProperties)

def IO_MGR_Save(aFileType, aFileName, aBoard, aProperties=None):
    """
    Save(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aBoard, PROPERTIES aProperties=None)
    IO_MGR_Save(IO_MGR::PCB_FILE_T aFileType, wxString const & aFileName, BOARD aBoard)
    """
    return _pcbnew.IO_MGR_Save(aFileType, aFileName, aBoard, aProperties)

class PLUGIN(_object):
    """Proxy of C++ PLUGIN class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PLUGIN, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PLUGIN, name)

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

    def PluginName(self):
        """PluginName(PLUGIN self) -> wxString const"""
        return _pcbnew.PLUGIN_PluginName(self)


    def GetFileExtension(self):
        """GetFileExtension(PLUGIN self) -> wxString const"""
        return _pcbnew.PLUGIN_GetFileExtension(self)


    def Load(self, aFileName, aAppendToMe, aProperties=None):
        """
        Load(PLUGIN self, wxString const & aFileName, BOARD aAppendToMe, PROPERTIES aProperties=None) -> BOARD
        Load(PLUGIN self, wxString const & aFileName, BOARD aAppendToMe) -> BOARD
        """
        return _pcbnew.PLUGIN_Load(self, aFileName, aAppendToMe, aProperties)


    def Save(self, aFileName, aBoard, aProperties=None):
        """
        Save(PLUGIN self, wxString const & aFileName, BOARD aBoard, PROPERTIES aProperties=None)
        Save(PLUGIN self, wxString const & aFileName, BOARD aBoard)
        """
        return _pcbnew.PLUGIN_Save(self, aFileName, aBoard, aProperties)


    def FootprintEnumerate(self, aLibraryPath, aProperties=None):
        """
        FootprintEnumerate(PLUGIN self, wxString const & aLibraryPath, PROPERTIES aProperties=None) -> wxArrayString
        FootprintEnumerate(PLUGIN self, wxString const & aLibraryPath) -> wxArrayString
        """
        return _pcbnew.PLUGIN_FootprintEnumerate(self, aLibraryPath, aProperties)


    def FootprintLoad(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintLoad(PLUGIN self, wxString const & aLibraryPath, wxString const & aFootprintName, PROPERTIES aProperties=None) -> MODULE
        FootprintLoad(PLUGIN self, wxString const & aLibraryPath, wxString const & aFootprintName) -> MODULE
        """
        return _pcbnew.PLUGIN_FootprintLoad(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintSave(self, aLibraryPath, aFootprint, aProperties=None):
        """
        FootprintSave(PLUGIN self, wxString const & aLibraryPath, MODULE aFootprint, PROPERTIES aProperties=None)
        FootprintSave(PLUGIN self, wxString const & aLibraryPath, MODULE aFootprint)
        """
        return _pcbnew.PLUGIN_FootprintSave(self, aLibraryPath, aFootprint, aProperties)


    def FootprintDelete(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintDelete(PLUGIN self, wxString const & aLibraryPath, wxString const & aFootprintName, PROPERTIES aProperties=None)
        FootprintDelete(PLUGIN self, wxString const & aLibraryPath, wxString const & aFootprintName)
        """
        return _pcbnew.PLUGIN_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintLibCreate(self, aLibraryPath, aProperties=None):
        """
        FootprintLibCreate(PLUGIN self, wxString const & aLibraryPath, PROPERTIES aProperties=None)
        FootprintLibCreate(PLUGIN self, wxString const & aLibraryPath)
        """
        return _pcbnew.PLUGIN_FootprintLibCreate(self, aLibraryPath, aProperties)


    def FootprintLibDelete(self, aLibraryPath, aProperties=None):
        """
        FootprintLibDelete(PLUGIN self, wxString const & aLibraryPath, PROPERTIES aProperties=None) -> bool
        FootprintLibDelete(PLUGIN self, wxString const & aLibraryPath) -> bool
        """
        return _pcbnew.PLUGIN_FootprintLibDelete(self, aLibraryPath, aProperties)


    def IsFootprintLibWritable(self, aLibraryPath):
        """IsFootprintLibWritable(PLUGIN self, wxString const & aLibraryPath) -> bool"""
        return _pcbnew.PLUGIN_IsFootprintLibWritable(self, aLibraryPath)


    def FootprintLibOptions(self, aListToAppendTo):
        """FootprintLibOptions(PLUGIN self, PROPERTIES aListToAppendTo)"""
        return _pcbnew.PLUGIN_FootprintLibOptions(self, aListToAppendTo)

    __swig_destroy__ = _pcbnew.delete_PLUGIN
    __del__ = lambda self: None
PLUGIN_swigregister = _pcbnew.PLUGIN_swigregister
PLUGIN_swigregister(PLUGIN)


_pcbnew.SEXPR_BOARD_FILE_VERSION_swigconstant(_pcbnew)
SEXPR_BOARD_FILE_VERSION = _pcbnew.SEXPR_BOARD_FILE_VERSION

_pcbnew.CTL_STD_LAYER_NAMES_swigconstant(_pcbnew)
CTL_STD_LAYER_NAMES = _pcbnew.CTL_STD_LAYER_NAMES

_pcbnew.CTL_OMIT_NETS_swigconstant(_pcbnew)
CTL_OMIT_NETS = _pcbnew.CTL_OMIT_NETS

_pcbnew.CTL_OMIT_TSTAMPS_swigconstant(_pcbnew)
CTL_OMIT_TSTAMPS = _pcbnew.CTL_OMIT_TSTAMPS

_pcbnew.CTL_OMIT_INITIAL_COMMENTS_swigconstant(_pcbnew)
CTL_OMIT_INITIAL_COMMENTS = _pcbnew.CTL_OMIT_INITIAL_COMMENTS

_pcbnew.CTL_OMIT_PATH_swigconstant(_pcbnew)
CTL_OMIT_PATH = _pcbnew.CTL_OMIT_PATH

_pcbnew.CTL_OMIT_AT_swigconstant(_pcbnew)
CTL_OMIT_AT = _pcbnew.CTL_OMIT_AT

_pcbnew.CTL_FOR_CLIPBOARD_swigconstant(_pcbnew)
CTL_FOR_CLIPBOARD = _pcbnew.CTL_FOR_CLIPBOARD

_pcbnew.CTL_FOR_LIBRARY_swigconstant(_pcbnew)
CTL_FOR_LIBRARY = _pcbnew.CTL_FOR_LIBRARY

_pcbnew.CTL_FOR_BOARD_swigconstant(_pcbnew)
CTL_FOR_BOARD = _pcbnew.CTL_FOR_BOARD
class PCB_IO(PLUGIN):
    """Proxy of C++ PCB_IO class"""
    __swig_setmethods__ = {}
    for _s in [PLUGIN]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCB_IO, name, value)
    __swig_getmethods__ = {}
    for _s in [PLUGIN]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PCB_IO, name)
    __repr__ = _swig_repr

    def PluginName(self):
        """PluginName(PCB_IO self) -> wxString const"""
        return _pcbnew.PCB_IO_PluginName(self)


    def GetFileExtension(self):
        """GetFileExtension(PCB_IO self) -> wxString const"""
        return _pcbnew.PCB_IO_GetFileExtension(self)


    def Save(self, aFileName, aBoard, aProperties=None):
        """
        Save(PCB_IO self, wxString const & aFileName, BOARD aBoard, PROPERTIES aProperties=None)
        Save(PCB_IO self, wxString const & aFileName, BOARD aBoard)
        """
        return _pcbnew.PCB_IO_Save(self, aFileName, aBoard, aProperties)


    def Load(self, aFileName, aAppendToMe, aProperties=None):
        """
        Load(PCB_IO self, wxString const & aFileName, BOARD aAppendToMe, PROPERTIES aProperties=None) -> BOARD
        Load(PCB_IO self, wxString const & aFileName, BOARD aAppendToMe) -> BOARD
        """
        return _pcbnew.PCB_IO_Load(self, aFileName, aAppendToMe, aProperties)


    def FootprintEnumerate(self, aLibraryPath, aProperties=None):
        """
        FootprintEnumerate(PCB_IO self, wxString const & aLibraryPath, PROPERTIES aProperties=None) -> wxArrayString
        FootprintEnumerate(PCB_IO self, wxString const & aLibraryPath) -> wxArrayString
        """
        return _pcbnew.PCB_IO_FootprintEnumerate(self, aLibraryPath, aProperties)


    def FootprintLoad(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintLoad(PCB_IO self, wxString const & aLibraryPath, wxString const & aFootprintName, PROPERTIES aProperties=None) -> MODULE
        FootprintLoad(PCB_IO self, wxString const & aLibraryPath, wxString const & aFootprintName) -> MODULE
        """
        return _pcbnew.PCB_IO_FootprintLoad(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintSave(self, aLibraryPath, aFootprint, aProperties=None):
        """
        FootprintSave(PCB_IO self, wxString const & aLibraryPath, MODULE aFootprint, PROPERTIES aProperties=None)
        FootprintSave(PCB_IO self, wxString const & aLibraryPath, MODULE aFootprint)
        """
        return _pcbnew.PCB_IO_FootprintSave(self, aLibraryPath, aFootprint, aProperties)


    def FootprintDelete(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintDelete(PCB_IO self, wxString const & aLibraryPath, wxString const & aFootprintName, PROPERTIES aProperties=None)
        FootprintDelete(PCB_IO self, wxString const & aLibraryPath, wxString const & aFootprintName)
        """
        return _pcbnew.PCB_IO_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintLibCreate(self, aLibraryPath, aProperties=None):
        """
        FootprintLibCreate(PCB_IO self, wxString const & aLibraryPath, PROPERTIES aProperties=None)
        FootprintLibCreate(PCB_IO self, wxString const & aLibraryPath)
        """
        return _pcbnew.PCB_IO_FootprintLibCreate(self, aLibraryPath, aProperties)


    def FootprintLibDelete(self, aLibraryPath, aProperties=None):
        """
        FootprintLibDelete(PCB_IO self, wxString const & aLibraryPath, PROPERTIES aProperties=None) -> bool
        FootprintLibDelete(PCB_IO self, wxString const & aLibraryPath) -> bool
        """
        return _pcbnew.PCB_IO_FootprintLibDelete(self, aLibraryPath, aProperties)


    def IsFootprintLibWritable(self, aLibraryPath):
        """IsFootprintLibWritable(PCB_IO self, wxString const & aLibraryPath) -> bool"""
        return _pcbnew.PCB_IO_IsFootprintLibWritable(self, aLibraryPath)


    def __init__(self, *args):
        """
        __init__(PCB_IO self, int aControlFlags) -> PCB_IO
        __init__(PCB_IO self) -> PCB_IO
        """
        this = _pcbnew.new_PCB_IO(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PCB_IO
    __del__ = lambda self: None

    def Format(self, aItem, aNestLevel=0):
        """
        Format(PCB_IO self, BOARD_ITEM aItem, int aNestLevel=0)
        Format(PCB_IO self, BOARD_ITEM aItem)
        """
        return _pcbnew.PCB_IO_Format(self, aItem, aNestLevel)


    def GetStringOutput(self, doClear):
        """GetStringOutput(PCB_IO self, bool doClear) -> string"""
        return _pcbnew.PCB_IO_GetStringOutput(self, doClear)


    def SetOutputFormatter(self, aFormatter):
        """SetOutputFormatter(PCB_IO self, OUTPUTFORMATTER * aFormatter)"""
        return _pcbnew.PCB_IO_SetOutputFormatter(self, aFormatter)


    def Parse(self, aClipboardSourceInput):
        """Parse(PCB_IO self, wxString const & aClipboardSourceInput) -> BOARD_ITEM"""
        return _pcbnew.PCB_IO_Parse(self, aClipboardSourceInput)

PCB_IO_swigregister = _pcbnew.PCB_IO_swigregister
PCB_IO_swigregister(PCB_IO)

class BOARD_ITEM_List(DHEAD):
    """Proxy of C++ DLIST<(BOARD_ITEM)> class"""
    __swig_setmethods__ = {}
    for _s in [DHEAD]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BOARD_ITEM_List, name, value)
    __swig_getmethods__ = {}
    for _s in [DHEAD]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BOARD_ITEM_List, name)
    __repr__ = _swig_repr

    def Get(self):
        """Get(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Get(self)


    def __deref__(self):
        """__deref__(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List___deref__(self)


    def GetFirst(self):
        """GetFirst(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_GetFirst(self)


    def GetLast(self):
        """GetLast(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_GetLast(self)


    def Append(self, *args):
        """
        Append(BOARD_ITEM_List self, BOARD_ITEM aNewElement)
        Append(BOARD_ITEM_List self, BOARD_ITEM_List aList)
        """
        return _pcbnew.BOARD_ITEM_List_Append(self, *args)


    def Insert(self, aNewElement, aElementAfterMe):
        """Insert(BOARD_ITEM_List self, BOARD_ITEM aNewElement, BOARD_ITEM aElementAfterMe)"""
        return _pcbnew.BOARD_ITEM_List_Insert(self, aNewElement, aElementAfterMe)


    def Remove(self, aElement):
        """Remove(BOARD_ITEM_List self, BOARD_ITEM aElement) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Remove(self, aElement)


    def begin(self):
        """begin(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_begin(self)


    def end(self):
        """end(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_end(self)


    def PopFront(self):
        """PopFront(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_PopFront(self)


    def PopBack(self):
        """PopBack(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_PopBack(self)


    def PushFront(self, aNewElement):
        """PushFront(BOARD_ITEM_List self, BOARD_ITEM aNewElement)"""
        return _pcbnew.BOARD_ITEM_List_PushFront(self, aNewElement)


    def PushBack(self, aNewElement):
        """PushBack(BOARD_ITEM_List self, BOARD_ITEM aNewElement)"""
        return _pcbnew.BOARD_ITEM_List_PushBack(self, aNewElement)


    class DLISTIter:
        def __init__(self,aList):
            self.last = aList   # last item is the start of list

        def next(self):         # get the next item

            item = self.last
            try:
              item = item.Get()
            except:
              pass

            if item is None:    # if the item is None, then finish the iteration
                raise StopIteration
            else:
                ret = None

    # first item in list has "Get" as a DLIST
                try:
                    ret = self.last.Get()
                except:
                    ret = self.last # next items do not..

                self.last = self.last.Next()

    # when the iterated object can be casted down in inheritance, just do it..

                if 'Cast' in dir(ret):
                    ret = ret.Cast()

                return ret

    def __iter__(self):
        return self.DLISTIter(self)



    def __init__(self):
        """__init__(DLIST<(BOARD_ITEM)> self) -> BOARD_ITEM_List"""
        this = _pcbnew.new_BOARD_ITEM_List()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM_List
    __del__ = lambda self: None

    def GetPosition(self):
        """GetPosition(BOARD_ITEM_List self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_List_GetPosition(self)


    def GetCenter(self):
        """GetCenter(BOARD_ITEM_List self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_List_GetCenter(self)


    def SetPosition(self, aPos):
        """SetPosition(BOARD_ITEM_List self, wxPoint aPos)"""
        return _pcbnew.BOARD_ITEM_List_SetPosition(self, aPos)


    def IsConnected(self):
        """IsConnected(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsConnected(self)


    def Next(self):
        """Next(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Next(self)


    def Back(self):
        """Back(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Back(self)


    def GetParent(self):
        """GetParent(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(BOARD_ITEM_List self) -> LAYER_ID"""
        return _pcbnew.BOARD_ITEM_List_GetLayer(self)


    def GetLayerSet(self):
        """GetLayerSet(BOARD_ITEM_List self) -> LSET"""
        return _pcbnew.BOARD_ITEM_List_GetLayerSet(self)


    def SetLayer(self, aLayer):
        """SetLayer(BOARD_ITEM_List self, LAYER_ID aLayer)"""
        return _pcbnew.BOARD_ITEM_List_SetLayer(self, aLayer)


    def Draw(self, *args):
        """
        Draw(BOARD_ITEM_List self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(BOARD_ITEM_List self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.BOARD_ITEM_List_Draw(self, *args)


    def SwapData(self, aImage):
        """SwapData(BOARD_ITEM_List self, BOARD_ITEM aImage)"""
        return _pcbnew.BOARD_ITEM_List_SwapData(self, aImage)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(BOARD_ITEM_List self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsOnLayer(self, aLayer)


    def IsTrack(self):
        """IsTrack(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsTrack(self)


    def IsLocked(self):
        """IsLocked(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsLocked(self)


    def UnLink(self):
        """UnLink(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_UnLink(self)


    def DeleteStructure(self):
        """DeleteStructure(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_DeleteStructure(self)


    def ShowShape(self, aShape):
        """ShowShape(BOARD_ITEM_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_ShowShape(self, aShape)


    def Move(self, aMoveVector):
        """Move(BOARD_ITEM_List self, wxPoint aMoveVector)"""
        return _pcbnew.BOARD_ITEM_List_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(BOARD_ITEM_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.BOARD_ITEM_List_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(BOARD_ITEM_List self, wxPoint aCentre)"""
        return _pcbnew.BOARD_ITEM_List_Flip(self, aCentre)


    def GetBoard(self):
        """GetBoard(BOARD_ITEM_List self) -> BOARD"""
        return _pcbnew.BOARD_ITEM_List_GetBoard(self)


    def GetLayerName(self):
        """GetLayerName(BOARD_ITEM_List self) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetLayerName(self)


    def HitTest(self, *args):
        """
        HitTest(BOARD_ITEM_List self, wxPoint aPosition) -> bool
        HitTest(BOARD_ITEM_List self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(BOARD_ITEM_List self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(BOARD_ITEM_List self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.BOARD_ITEM_List_HitTest(self, *args)


    def FormatInternalUnits(self, *args):
        """
        FormatInternalUnits(BOARD_ITEM_List self, int aValue) -> string
        FormatInternalUnits(BOARD_ITEM_List self, wxPoint aPoint) -> string
        FormatInternalUnits(BOARD_ITEM_List self, wxSize aSize) -> string
        """
        return _pcbnew.BOARD_ITEM_List_FormatInternalUnits(self, *args)


    def FormatAngle(self, aAngle):
        """FormatAngle(BOARD_ITEM_List self, double aAngle) -> string"""
        return _pcbnew.BOARD_ITEM_List_FormatAngle(self, aAngle)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(BOARD_ITEM_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.BOARD_ITEM_List_ViewGetLayers(self, aLayers, aCount)


    def IncrementItemReference(self):
        """IncrementItemReference(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IncrementItemReference(self)


    def Cast_to_TEXTE_PCB(self):
        """Cast_to_TEXTE_PCB(BOARD_ITEM_List self) -> TEXTE_PCB"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_TEXTE_PCB(self)


    def Cast_to_DIMENSION(self):
        """Cast_to_DIMENSION(BOARD_ITEM_List self) -> DIMENSION"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_DIMENSION(self)


    def Cast_to_MODULE(self):
        """Cast_to_MODULE(BOARD_ITEM_List self) -> MODULE"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_MODULE(self)


    def Cast_to_TEXTE_MODULE(self):
        """Cast_to_TEXTE_MODULE(BOARD_ITEM_List self) -> TEXTE_MODULE"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_TEXTE_MODULE(self)


    def Cast_to_DRAWSEGMENT(self):
        """Cast_to_DRAWSEGMENT(BOARD_ITEM_List self) -> DRAWSEGMENT"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_DRAWSEGMENT(self)


    def Cast_to_MARKER_PCB(self):
        """Cast_to_MARKER_PCB(BOARD_ITEM_List self) -> MARKER_PCB"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_MARKER_PCB(self)


    def Cast_to_BOARD(self):
        """Cast_to_BOARD(BOARD_ITEM_List self) -> BOARD"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_BOARD(self)


    def Cast_to_EDGE_MODULE(self):
        """Cast_to_EDGE_MODULE(BOARD_ITEM_List self) -> EDGE_MODULE"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_EDGE_MODULE(self)


    def Cast_to_D_PAD(self):
        """Cast_to_D_PAD(BOARD_ITEM_List self) -> D_PAD"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_D_PAD(self)


    def Cast_to_TRACK(self):
        """Cast_to_TRACK(BOARD_ITEM_List self) -> TRACK"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_TRACK(self)


    def Cast_to_VIA(self):
        """Cast_to_VIA(BOARD_ITEM_List self) -> VIA"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_VIA(self)


    def Cast_to_ZONE_CONTAINER(self):
        """Cast_to_ZONE_CONTAINER(BOARD_ITEM_List self) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_ZONE_CONTAINER(self)


    def Cast_to_PCB_TARGET(self):
        """Cast_to_PCB_TARGET(BOARD_ITEM_List self) -> PCB_TARGET"""
        return _pcbnew.BOARD_ITEM_List_Cast_to_PCB_TARGET(self)


    def Type(self):
        """Type(BOARD_ITEM_List self) -> KICAD_T"""
        return _pcbnew.BOARD_ITEM_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(BOARD_ITEM_List self, time_t aNewTimeStamp)"""
        return _pcbnew.BOARD_ITEM_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(BOARD_ITEM_List self) -> time_t"""
        return _pcbnew.BOARD_ITEM_List_GetTimeStamp(self)


    def GetList(self):
        """GetList(BOARD_ITEM_List self) -> DHEAD"""
        return _pcbnew.BOARD_ITEM_List_GetList(self)


    def SetParent(self, aParent):
        """SetParent(BOARD_ITEM_List self, EDA_ITEM aParent)"""
        return _pcbnew.BOARD_ITEM_List_SetParent(self, aParent)


    def SetList(self, aList):
        """SetList(BOARD_ITEM_List self, DHEAD aList)"""
        return _pcbnew.BOARD_ITEM_List_SetList(self, aList)


    def IsNew(self):
        """IsNew(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsNew(self)


    def IsModified(self):
        """IsModified(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsModified(self)


    def IsMoving(self):
        """IsMoving(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsMoving(self)


    def IsDragging(self):
        """IsDragging(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsDragging(self)


    def IsWireImage(self):
        """IsWireImage(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsWireImage(self)


    def IsSelected(self):
        """IsSelected(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsSelected(self)


    def IsResized(self):
        """IsResized(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsResized(self)


    def IsHighlighted(self):
        """IsHighlighted(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsHighlighted(self)


    def IsBrightened(self):
        """IsBrightened(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsBrightened(self)


    def SetWireImage(self):
        """SetWireImage(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetWireImage(self)


    def SetSelected(self):
        """SetSelected(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetSelected(self)


    def SetHighlighted(self):
        """SetHighlighted(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetHighlighted(self)


    def SetBrightened(self):
        """SetBrightened(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetBrightened(self)


    def ClearSelected(self):
        """ClearSelected(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_ClearSelected(self)


    def ClearHighlighted(self):
        """ClearHighlighted(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_ClearHighlighted(self)


    def ClearBrightened(self):
        """ClearBrightened(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_ClearBrightened(self)


    def SetModified(self):
        """SetModified(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetModified(self)


    def GetState(self, type):
        """GetState(BOARD_ITEM_List self, int type) -> int"""
        return _pcbnew.BOARD_ITEM_List_GetState(self, type)


    def SetState(self, type, state):
        """SetState(BOARD_ITEM_List self, int type, int state)"""
        return _pcbnew.BOARD_ITEM_List_SetState(self, type, state)


    def GetStatus(self):
        """GetStatus(BOARD_ITEM_List self) -> STATUS_FLAGS"""
        return _pcbnew.BOARD_ITEM_List_GetStatus(self)


    def SetStatus(self, aStatus):
        """SetStatus(BOARD_ITEM_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.BOARD_ITEM_List_SetStatus(self, aStatus)


    def SetFlags(self, aMask):
        """SetFlags(BOARD_ITEM_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.BOARD_ITEM_List_SetFlags(self, aMask)


    def ClearFlags(self, aMask=-1):
        """
        ClearFlags(BOARD_ITEM_List self, STATUS_FLAGS aMask=-1)
        ClearFlags(BOARD_ITEM_List self)
        """
        return _pcbnew.BOARD_ITEM_List_ClearFlags(self, aMask)


    def GetFlags(self):
        """GetFlags(BOARD_ITEM_List self) -> STATUS_FLAGS"""
        return _pcbnew.BOARD_ITEM_List_GetFlags(self)


    def SetImage(self, aItem):
        """SetImage(BOARD_ITEM_List self, EDA_ITEM aItem)"""
        return _pcbnew.BOARD_ITEM_List_SetImage(self, aItem)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(BOARD_ITEM_List self, bool aEnable)"""
        return _pcbnew.BOARD_ITEM_List_SetForceVisible(self, aEnable)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(BOARD_ITEM_List self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.BOARD_ITEM_List_GetMsgPanelInfo(self, aList)


    def GetBoundingBox(self):
        """GetBoundingBox(BOARD_ITEM_List self) -> EDA_RECT"""
        return _pcbnew.BOARD_ITEM_List_GetBoundingBox(self)


    def Clone(self):
        """Clone(BOARD_ITEM_List self) -> EDA_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Clone(self)


    def IterateForward(self, listStart, inspector, testData, scanTypes):
        """IterateForward(BOARD_ITEM_List self, EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.BOARD_ITEM_List_IterateForward(self, listStart, inspector, testData, scanTypes)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(BOARD_ITEM_List self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.BOARD_ITEM_List_Visit(self, inspector, testData, scanTypes)


    def GetClass(self):
        """GetClass(BOARD_ITEM_List self) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(BOARD_ITEM_List self) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(BOARD_ITEM_List self) -> BITMAP_DEF"""
        return _pcbnew.BOARD_ITEM_List_GetMenuImage(self)


    def Matches(self, aSearchData, aAuxData, aFindLocation):
        """Matches(BOARD_ITEM_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.BOARD_ITEM_List_Matches(self, aSearchData, aAuxData, aFindLocation)


    def Replace(self, *args):
        """
        Replace(BOARD_ITEM_List self, wxFindReplaceData & aSearchData, wxString & aText) -> bool
        Replace(BOARD_ITEM_List self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        Replace(BOARD_ITEM_List self, wxFindReplaceData & aSearchData) -> bool
        """
        return _pcbnew.BOARD_ITEM_List_Replace(self, *args)


    def IsReplaceable(self):
        """IsReplaceable(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsReplaceable(self)


    def __lt__(self, aItem):
        """__lt__(BOARD_ITEM_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_ITEM_List___lt__(self, aItem)


    def Sort(self, aLeft, aRight):
        """Sort(BOARD_ITEM_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.BOARD_ITEM_List_Sort(self, aLeft, aRight)


    def ViewBBox(self):
        """ViewBBox(BOARD_ITEM_List self) -> BOX2I const"""
        return _pcbnew.BOARD_ITEM_List_ViewBBox(self)

BOARD_ITEM_List_swigregister = _pcbnew.BOARD_ITEM_List_swigregister
BOARD_ITEM_List_swigregister(BOARD_ITEM_List)

class MODULE_List(DHEAD):
    """Proxy of C++ DLIST<(MODULE)> class"""
    __swig_setmethods__ = {}
    for _s in [DHEAD]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MODULE_List, name, value)
    __swig_getmethods__ = {}
    for _s in [DHEAD]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MODULE_List, name)
    __repr__ = _swig_repr

    def Get(self):
        """Get(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Get(self)


    def __deref__(self):
        """__deref__(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List___deref__(self)


    def GetFirst(self):
        """GetFirst(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_GetFirst(self)


    def GetLast(self):
        """GetLast(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_GetLast(self)


    def Append(self, *args):
        """
        Append(MODULE_List self, MODULE aNewElement)
        Append(MODULE_List self, MODULE_List aList)
        """
        return _pcbnew.MODULE_List_Append(self, *args)


    def Insert(self, aNewElement, aElementAfterMe):
        """Insert(MODULE_List self, MODULE aNewElement, MODULE aElementAfterMe)"""
        return _pcbnew.MODULE_List_Insert(self, aNewElement, aElementAfterMe)


    def Remove(self, aElement):
        """Remove(MODULE_List self, MODULE aElement) -> MODULE"""
        return _pcbnew.MODULE_List_Remove(self, aElement)


    def begin(self):
        """begin(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_begin(self)


    def end(self):
        """end(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_end(self)


    def PopFront(self):
        """PopFront(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_PopFront(self)


    def PopBack(self):
        """PopBack(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_PopBack(self)


    def PushFront(self, aNewElement):
        """PushFront(MODULE_List self, MODULE aNewElement)"""
        return _pcbnew.MODULE_List_PushFront(self, aNewElement)


    def PushBack(self, aNewElement):
        """PushBack(MODULE_List self, MODULE aNewElement)"""
        return _pcbnew.MODULE_List_PushBack(self, aNewElement)


    class DLISTIter:
        def __init__(self,aList):
            self.last = aList   # last item is the start of list

        def next(self):         # get the next item

            item = self.last
            try:
              item = item.Get()
            except:
              pass

            if item is None:    # if the item is None, then finish the iteration
                raise StopIteration
            else:
                ret = None

    # first item in list has "Get" as a DLIST
                try:
                    ret = self.last.Get()
                except:
                    ret = self.last # next items do not..

                self.last = self.last.Next()

    # when the iterated object can be casted down in inheritance, just do it..

                if 'Cast' in dir(ret):
                    ret = ret.Cast()

                return ret

    def __iter__(self):
        return self.DLISTIter(self)



    def __init__(self):
        """__init__(DLIST<(MODULE)> self) -> MODULE_List"""
        this = _pcbnew.new_MODULE_List()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MODULE_List
    __del__ = lambda self: None

    def ClassOf(self, aItem):
        """ClassOf(MODULE_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.MODULE_List_ClassOf(self, aItem)


    def Next(self):
        """Next(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Next(self)


    def Back(self):
        """Back(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Back(self)


    def Copy(self, Module):
        """Copy(MODULE_List self, MODULE Module)"""
        return _pcbnew.MODULE_List_Copy(self, Module)


    def AddChild(self, aBoardItem, doAppend=True):
        """
        AddChild(MODULE_List self, BOARD_ITEM aBoardItem, bool doAppend=True)
        AddChild(MODULE_List self, BOARD_ITEM aBoardItem)
        """
        return _pcbnew.MODULE_List_AddChild(self, aBoardItem, doAppend)


    def DeleteChild(self, aBoardItem):
        """DeleteChild(MODULE_List self, BOARD_ITEM aBoardItem)"""
        return _pcbnew.MODULE_List_DeleteChild(self, aBoardItem)


    def RemoveChild(self, aBoardItem):
        """RemoveChild(MODULE_List self, BOARD_ITEM aBoardItem) -> BOARD_ITEM"""
        return _pcbnew.MODULE_List_RemoveChild(self, aBoardItem)


    def ClearAllNets(self):
        """ClearAllNets(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearAllNets(self)


    def CalculateBoundingBox(self):
        """CalculateBoundingBox(MODULE_List self)"""
        return _pcbnew.MODULE_List_CalculateBoundingBox(self)


    def GetFootprintRect(self):
        """GetFootprintRect(MODULE_List self) -> EDA_RECT"""
        return _pcbnew.MODULE_List_GetFootprintRect(self)


    def GetBoundingBox(self):
        """GetBoundingBox(MODULE_List self) -> EDA_RECT"""
        return _pcbnew.MODULE_List_GetBoundingBox(self)


    def Pads(self, *args):
        """
        Pads(MODULE_List self) -> PAD_List
        Pads(MODULE_List self) -> PAD_List
        """
        return _pcbnew.MODULE_List_Pads(self, *args)


    def GraphicalItems(self, *args):
        """
        GraphicalItems(MODULE_List self) -> BOARD_ITEM_List
        GraphicalItems(MODULE_List self) -> BOARD_ITEM_List
        """
        return _pcbnew.MODULE_List_GraphicalItems(self, *args)


    def Models(self, *args):
        """
        Models(MODULE_List self) -> DLIST< S3D_MASTER >
        Models(MODULE_List self) -> DLIST< S3D_MASTER > const &
        """
        return _pcbnew.MODULE_List_Models(self, *args)


    def SetPosition(self, aPos):
        """SetPosition(MODULE_List self, wxPoint aPos)"""
        return _pcbnew.MODULE_List_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(MODULE_List self) -> wxPoint"""
        return _pcbnew.MODULE_List_GetPosition(self)


    def SetOrientation(self, newangle):
        """SetOrientation(MODULE_List self, double newangle)"""
        return _pcbnew.MODULE_List_SetOrientation(self, newangle)


    def GetOrientation(self):
        """GetOrientation(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientation(self)


    def GetFPID(self):
        """GetFPID(MODULE_List self) -> FPID"""
        return _pcbnew.MODULE_List_GetFPID(self)


    def SetFPID(self, aFPID):
        """SetFPID(MODULE_List self, FPID aFPID)"""
        return _pcbnew.MODULE_List_SetFPID(self, aFPID)


    def GetDescription(self):
        """GetDescription(MODULE_List self) -> wxString const &"""
        return _pcbnew.MODULE_List_GetDescription(self)


    def SetDescription(self, aDoc):
        """SetDescription(MODULE_List self, wxString const & aDoc)"""
        return _pcbnew.MODULE_List_SetDescription(self, aDoc)


    def GetKeywords(self):
        """GetKeywords(MODULE_List self) -> wxString const &"""
        return _pcbnew.MODULE_List_GetKeywords(self)


    def SetKeywords(self, aKeywords):
        """SetKeywords(MODULE_List self, wxString const & aKeywords)"""
        return _pcbnew.MODULE_List_SetKeywords(self, aKeywords)


    def GetPath(self):
        """GetPath(MODULE_List self) -> wxString const &"""
        return _pcbnew.MODULE_List_GetPath(self)


    def SetPath(self, aPath):
        """SetPath(MODULE_List self, wxString const & aPath)"""
        return _pcbnew.MODULE_List_SetPath(self, aPath)


    def GetLocalSolderMaskMargin(self):
        """GetLocalSolderMaskMargin(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetLocalSolderMaskMargin(self)


    def SetLocalSolderMaskMargin(self, aMargin):
        """SetLocalSolderMaskMargin(MODULE_List self, int aMargin)"""
        return _pcbnew.MODULE_List_SetLocalSolderMaskMargin(self, aMargin)


    def GetLocalClearance(self):
        """GetLocalClearance(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetLocalClearance(self)


    def SetLocalClearance(self, aClearance):
        """SetLocalClearance(MODULE_List self, int aClearance)"""
        return _pcbnew.MODULE_List_SetLocalClearance(self, aClearance)


    def GetLocalSolderPasteMargin(self):
        """GetLocalSolderPasteMargin(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetLocalSolderPasteMargin(self)


    def SetLocalSolderPasteMargin(self, aMargin):
        """SetLocalSolderPasteMargin(MODULE_List self, int aMargin)"""
        return _pcbnew.MODULE_List_SetLocalSolderPasteMargin(self, aMargin)


    def GetLocalSolderPasteMarginRatio(self):
        """GetLocalSolderPasteMarginRatio(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetLocalSolderPasteMarginRatio(self)


    def SetLocalSolderPasteMarginRatio(self, aRatio):
        """SetLocalSolderPasteMarginRatio(MODULE_List self, double aRatio)"""
        return _pcbnew.MODULE_List_SetLocalSolderPasteMarginRatio(self, aRatio)


    def SetZoneConnection(self, aType):
        """SetZoneConnection(MODULE_List self, ZoneConnection aType)"""
        return _pcbnew.MODULE_List_SetZoneConnection(self, aType)


    def GetZoneConnection(self):
        """GetZoneConnection(MODULE_List self) -> ZoneConnection"""
        return _pcbnew.MODULE_List_GetZoneConnection(self)


    def SetThermalWidth(self, aWidth):
        """SetThermalWidth(MODULE_List self, int aWidth)"""
        return _pcbnew.MODULE_List_SetThermalWidth(self, aWidth)


    def GetThermalWidth(self):
        """GetThermalWidth(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetThermalWidth(self)


    def SetThermalGap(self, aGap):
        """SetThermalGap(MODULE_List self, int aGap)"""
        return _pcbnew.MODULE_List_SetThermalGap(self, aGap)


    def GetThermalGap(self):
        """GetThermalGap(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetThermalGap(self)


    def GetAttributes(self):
        """GetAttributes(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetAttributes(self)


    def SetAttributes(self, aAttributes):
        """SetAttributes(MODULE_List self, int aAttributes)"""
        return _pcbnew.MODULE_List_SetAttributes(self, aAttributes)


    def SetFlag(self, aFlag):
        """SetFlag(MODULE_List self, int aFlag)"""
        return _pcbnew.MODULE_List_SetFlag(self, aFlag)


    def IncrementFlag(self):
        """IncrementFlag(MODULE_List self)"""
        return _pcbnew.MODULE_List_IncrementFlag(self)


    def GetFlag(self):
        """GetFlag(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetFlag(self)


    def Move(self, aMoveVector):
        """Move(MODULE_List self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_List_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(MODULE_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MODULE_List_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(MODULE_List self, wxPoint aCentre)"""
        return _pcbnew.MODULE_List_Flip(self, aCentre)


    def MoveAnchorPosition(self, aMoveVector):
        """MoveAnchorPosition(MODULE_List self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_List_MoveAnchorPosition(self, aMoveVector)


    def IsFlipped(self):
        """IsFlipped(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsFlipped(self)


    def IsLocked(self):
        """IsLocked(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsLocked(self)


    def SetLocked(self, isLocked):
        """SetLocked(MODULE_List self, bool isLocked)"""
        return _pcbnew.MODULE_List_SetLocked(self, isLocked)


    def IsPlaced(self):
        """IsPlaced(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsPlaced(self)


    def SetIsPlaced(self, isPlaced):
        """SetIsPlaced(MODULE_List self, bool isPlaced)"""
        return _pcbnew.MODULE_List_SetIsPlaced(self, isPlaced)


    def NeedsPlaced(self):
        """NeedsPlaced(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_NeedsPlaced(self)


    def SetNeedsPlaced(self, needsPlaced):
        """SetNeedsPlaced(MODULE_List self, bool needsPlaced)"""
        return _pcbnew.MODULE_List_SetNeedsPlaced(self, needsPlaced)


    def PadsLocked(self):
        """PadsLocked(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_PadsLocked(self)


    def SetPadsLocked(self, aPadsLocked):
        """SetPadsLocked(MODULE_List self, bool aPadsLocked)"""
        return _pcbnew.MODULE_List_SetPadsLocked(self, aPadsLocked)


    def SetLastEditTime(self, *args):
        """
        SetLastEditTime(MODULE_List self, time_t aTime)
        SetLastEditTime(MODULE_List self)
        """
        return _pcbnew.MODULE_List_SetLastEditTime(self, *args)


    def GetLastEditTime(self):
        """GetLastEditTime(MODULE_List self) -> time_t"""
        return _pcbnew.MODULE_List_GetLastEditTime(self)


    def Draw(self, *args):
        """
        Draw(MODULE_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(MODULE_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.MODULE_List_Draw(self, *args)


    def DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector):
        """DrawOutlinesWhenMoving(MODULE_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_List_DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector)


    def TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper=False):
        """
        TransformPadsShapesWithClearanceToPolygon(MODULE_List self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)
        TransformPadsShapesWithClearanceToPolygon(MODULE_List self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_List_TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper)


    def TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformGraphicShapesWithClearanceToPolygonSet(MODULE_List self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.MODULE_List_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor)


    def DrawEdgesOnly(self, panel, DC, offset, draw_mode):
        """DrawEdgesOnly(MODULE_List self, EDA_DRAW_PANEL * panel, wxDC * DC, wxPoint offset, GR_DRAWMODE draw_mode)"""
        return _pcbnew.MODULE_List_DrawEdgesOnly(self, panel, DC, offset, draw_mode)


    def DrawAncre(self, panel, DC, offset, dim_ancre, draw_mode):
        """DrawAncre(MODULE_List self, EDA_DRAW_PANEL * panel, wxDC * DC, wxPoint offset, int dim_ancre, GR_DRAWMODE draw_mode)"""
        return _pcbnew.MODULE_List_DrawAncre(self, panel, DC, offset, dim_ancre, draw_mode)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(MODULE_List self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MODULE_List_GetMsgPanelInfo(self, aList)


    def HitTest(self, *args):
        """
        HitTest(MODULE_List self, wxPoint aPosition) -> bool
        HitTest(MODULE_List self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(MODULE_List self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(MODULE_List self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.MODULE_List_HitTest(self, *args)


    def GetReference(self):
        """GetReference(MODULE_List self) -> wxString const &"""
        return _pcbnew.MODULE_List_GetReference(self)


    def SetReference(self, aReference):
        """SetReference(MODULE_List self, wxString const & aReference)"""
        return _pcbnew.MODULE_List_SetReference(self, aReference)


    def GetReferencePrefix(self):
        """GetReferencePrefix(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetReferencePrefix(self)


    def GetValue(self):
        """GetValue(MODULE_List self) -> wxString const &"""
        return _pcbnew.MODULE_List_GetValue(self)


    def SetValue(self, aValue):
        """SetValue(MODULE_List self, wxString const & aValue)"""
        return _pcbnew.MODULE_List_SetValue(self, aValue)


    def Value(self, *args):
        """
        Value(MODULE_List self) -> TEXTE_MODULE
        Value(MODULE_List self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_List_Value(self, *args)


    def Reference(self, *args):
        """
        Reference(MODULE_List self) -> TEXTE_MODULE
        Reference(MODULE_List self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_List_Reference(self, *args)


    def IncrementItemReference(self):
        """IncrementItemReference(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IncrementItemReference(self)


    def IncrementReference(self, aFillSequenceGaps):
        """IncrementReference(MODULE_List self, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.MODULE_List_IncrementReference(self, aFillSequenceGaps)


    def FindPadByName(self, aPadName):
        """FindPadByName(MODULE_List self, wxString const & aPadName) -> D_PAD"""
        return _pcbnew.MODULE_List_FindPadByName(self, aPadName)


    def GetPad(self, *args):
        """
        GetPad(MODULE_List self, wxPoint aPosition, LSET aLayerMask) -> D_PAD
        GetPad(MODULE_List self, wxPoint aPosition) -> D_PAD
        """
        return _pcbnew.MODULE_List_GetPad(self, *args)


    def GetPadCount(self, *args):
        """
        GetPadCount(MODULE_List self, INCLUDE_NPTH_T aIncludeNPTH) -> unsigned int
        GetPadCount(MODULE_List self) -> unsigned int
        """
        return _pcbnew.MODULE_List_GetPadCount(self, *args)


    def GetNextPadName(self, aFillSequenceGaps):
        """GetNextPadName(MODULE_List self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_List_GetNextPadName(self, aFillSequenceGaps)


    def GetArea(self):
        """GetArea(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetArea(self)


    def GetLink(self):
        """GetLink(MODULE_List self) -> time_t"""
        return _pcbnew.MODULE_List_GetLink(self)


    def SetLink(self, aLink):
        """SetLink(MODULE_List self, time_t aLink)"""
        return _pcbnew.MODULE_List_SetLink(self, aLink)


    def GetPlacementCost180(self):
        """GetPlacementCost180(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetPlacementCost180(self)


    def SetPlacementCost180(self, aCost):
        """SetPlacementCost180(MODULE_List self, int aCost)"""
        return _pcbnew.MODULE_List_SetPlacementCost180(self, aCost)


    def GetPlacementCost90(self):
        """GetPlacementCost90(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetPlacementCost90(self)


    def SetPlacementCost90(self, aCost):
        """SetPlacementCost90(MODULE_List self, int aCost)"""
        return _pcbnew.MODULE_List_SetPlacementCost90(self, aCost)


    def DuplicateAndAddItem(self, item, aIncrementPadNumbers):
        """DuplicateAndAddItem(MODULE_List self, BOARD_ITEM item, bool aIncrementPadNumbers) -> BOARD_ITEM"""
        return _pcbnew.MODULE_List_DuplicateAndAddItem(self, item, aIncrementPadNumbers)


    def Add3DModel(self, a3DModel):
        """Add3DModel(MODULE_List self, S3D_MASTER * a3DModel)"""
        return _pcbnew.MODULE_List_Add3DModel(self, a3DModel)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(MODULE_List self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.MODULE_List_Visit(self, inspector, testData, scanTypes)


    def GetClass(self):
        """GetClass(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(MODULE_List self) -> BITMAP_DEF"""
        return _pcbnew.MODULE_List_GetMenuImage(self)


    def Clone(self):
        """Clone(MODULE_List self) -> EDA_ITEM"""
        return _pcbnew.MODULE_List_Clone(self)


    def RunOnChildren(self, aFunction):
        """RunOnChildren(MODULE_List self, boost::function< void (BOARD_ITEM *) > aFunction)"""
        return _pcbnew.MODULE_List_RunOnChildren(self, aFunction)


    def ViewUpdate(self, *args):
        """
        ViewUpdate(MODULE_List self, int aUpdateFlags)
        ViewUpdate(MODULE_List self)
        """
        return _pcbnew.MODULE_List_ViewUpdate(self, *args)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(MODULE_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.MODULE_List_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(MODULE_List self, int aLayer) -> unsigned int"""
        return _pcbnew.MODULE_List_ViewGetLOD(self, aLayer)


    def ViewBBox(self):
        """ViewBBox(MODULE_List self) -> BOX2I const"""
        return _pcbnew.MODULE_List_ViewBBox(self)


    def CopyNetlistSettings(self, aModule):
        """CopyNetlistSettings(MODULE_List self, MODULE aModule)"""
        return _pcbnew.MODULE_List_CopyNetlistSettings(self, aModule)


    def IsLibNameValid(self, aName):
        """IsLibNameValid(MODULE_List self, wxString const & aName) -> bool"""
        return _pcbnew.MODULE_List_IsLibNameValid(self, aName)


    def StringLibNameInvalidChars(self, aUserReadable):
        """StringLibNameInvalidChars(MODULE_List self, bool aUserReadable) -> wxChar const *"""
        return _pcbnew.MODULE_List_StringLibNameInvalidChars(self, aUserReadable)


    def SetInitialComments(self, aInitialComments):
        """SetInitialComments(MODULE_List self, wxArrayString * aInitialComments)"""
        return _pcbnew.MODULE_List_SetInitialComments(self, aInitialComments)


    def PadCoverageRatio(self):
        """PadCoverageRatio(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_PadCoverageRatio(self)


    def GetInitialComments(self):
        """GetInitialComments(MODULE_List self) -> wxArrayString const *"""
        return _pcbnew.MODULE_List_GetInitialComments(self)


    def GetCenter(self):
        """GetCenter(MODULE_List self) -> wxPoint"""
        return _pcbnew.MODULE_List_GetCenter(self)


    def IsConnected(self):
        """IsConnected(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsConnected(self)


    def GetParent(self):
        """GetParent(MODULE_List self) -> BOARD_ITEM"""
        return _pcbnew.MODULE_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(MODULE_List self) -> LAYER_ID"""
        return _pcbnew.MODULE_List_GetLayer(self)


    def GetLayerSet(self):
        """GetLayerSet(MODULE_List self) -> LSET"""
        return _pcbnew.MODULE_List_GetLayerSet(self)


    def SetLayer(self, aLayer):
        """SetLayer(MODULE_List self, LAYER_ID aLayer)"""
        return _pcbnew.MODULE_List_SetLayer(self, aLayer)


    def SwapData(self, aImage):
        """SwapData(MODULE_List self, BOARD_ITEM aImage)"""
        return _pcbnew.MODULE_List_SwapData(self, aImage)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(MODULE_List self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.MODULE_List_IsOnLayer(self, aLayer)


    def IsTrack(self):
        """IsTrack(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsTrack(self)


    def UnLink(self):
        """UnLink(MODULE_List self)"""
        return _pcbnew.MODULE_List_UnLink(self)


    def DeleteStructure(self):
        """DeleteStructure(MODULE_List self)"""
        return _pcbnew.MODULE_List_DeleteStructure(self)


    def ShowShape(self, aShape):
        """ShowShape(MODULE_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.MODULE_List_ShowShape(self, aShape)


    def GetBoard(self):
        """GetBoard(MODULE_List self) -> BOARD"""
        return _pcbnew.MODULE_List_GetBoard(self)


    def GetLayerName(self):
        """GetLayerName(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetLayerName(self)


    def FormatInternalUnits(self, *args):
        """
        FormatInternalUnits(MODULE_List self, int aValue) -> string
        FormatInternalUnits(MODULE_List self, wxPoint aPoint) -> string
        FormatInternalUnits(MODULE_List self, wxSize aSize) -> string
        """
        return _pcbnew.MODULE_List_FormatInternalUnits(self, *args)


    def FormatAngle(self, aAngle):
        """FormatAngle(MODULE_List self, double aAngle) -> string"""
        return _pcbnew.MODULE_List_FormatAngle(self, aAngle)


    def Cast_to_TEXTE_PCB(self):
        """Cast_to_TEXTE_PCB(MODULE_List self) -> TEXTE_PCB"""
        return _pcbnew.MODULE_List_Cast_to_TEXTE_PCB(self)


    def Cast_to_DIMENSION(self):
        """Cast_to_DIMENSION(MODULE_List self) -> DIMENSION"""
        return _pcbnew.MODULE_List_Cast_to_DIMENSION(self)


    def Cast_to_MODULE(self):
        """Cast_to_MODULE(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Cast_to_MODULE(self)


    def Cast_to_TEXTE_MODULE(self):
        """Cast_to_TEXTE_MODULE(MODULE_List self) -> TEXTE_MODULE"""
        return _pcbnew.MODULE_List_Cast_to_TEXTE_MODULE(self)


    def Cast_to_DRAWSEGMENT(self):
        """Cast_to_DRAWSEGMENT(MODULE_List self) -> DRAWSEGMENT"""
        return _pcbnew.MODULE_List_Cast_to_DRAWSEGMENT(self)


    def Cast_to_MARKER_PCB(self):
        """Cast_to_MARKER_PCB(MODULE_List self) -> MARKER_PCB"""
        return _pcbnew.MODULE_List_Cast_to_MARKER_PCB(self)


    def Cast_to_BOARD(self):
        """Cast_to_BOARD(MODULE_List self) -> BOARD"""
        return _pcbnew.MODULE_List_Cast_to_BOARD(self)


    def Cast_to_EDGE_MODULE(self):
        """Cast_to_EDGE_MODULE(MODULE_List self) -> EDGE_MODULE"""
        return _pcbnew.MODULE_List_Cast_to_EDGE_MODULE(self)


    def Cast_to_D_PAD(self):
        """Cast_to_D_PAD(MODULE_List self) -> D_PAD"""
        return _pcbnew.MODULE_List_Cast_to_D_PAD(self)


    def Cast_to_TRACK(self):
        """Cast_to_TRACK(MODULE_List self) -> TRACK"""
        return _pcbnew.MODULE_List_Cast_to_TRACK(self)


    def Cast_to_VIA(self):
        """Cast_to_VIA(MODULE_List self) -> VIA"""
        return _pcbnew.MODULE_List_Cast_to_VIA(self)


    def Cast_to_ZONE_CONTAINER(self):
        """Cast_to_ZONE_CONTAINER(MODULE_List self) -> ZONE_CONTAINER"""
        return _pcbnew.MODULE_List_Cast_to_ZONE_CONTAINER(self)


    def Cast_to_PCB_TARGET(self):
        """Cast_to_PCB_TARGET(MODULE_List self) -> PCB_TARGET"""
        return _pcbnew.MODULE_List_Cast_to_PCB_TARGET(self)


    def Type(self):
        """Type(MODULE_List self) -> KICAD_T"""
        return _pcbnew.MODULE_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(MODULE_List self, time_t aNewTimeStamp)"""
        return _pcbnew.MODULE_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(MODULE_List self) -> time_t"""
        return _pcbnew.MODULE_List_GetTimeStamp(self)


    def GetList(self):
        """GetList(MODULE_List self) -> DHEAD"""
        return _pcbnew.MODULE_List_GetList(self)


    def SetParent(self, aParent):
        """SetParent(MODULE_List self, EDA_ITEM aParent)"""
        return _pcbnew.MODULE_List_SetParent(self, aParent)


    def SetList(self, aList):
        """SetList(MODULE_List self, DHEAD aList)"""
        return _pcbnew.MODULE_List_SetList(self, aList)


    def IsNew(self):
        """IsNew(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsNew(self)


    def IsModified(self):
        """IsModified(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsModified(self)


    def IsMoving(self):
        """IsMoving(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsMoving(self)


    def IsDragging(self):
        """IsDragging(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsDragging(self)


    def IsWireImage(self):
        """IsWireImage(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsWireImage(self)


    def IsSelected(self):
        """IsSelected(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsSelected(self)


    def IsResized(self):
        """IsResized(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsResized(self)


    def IsHighlighted(self):
        """IsHighlighted(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsHighlighted(self)


    def IsBrightened(self):
        """IsBrightened(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsBrightened(self)


    def SetWireImage(self):
        """SetWireImage(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetWireImage(self)


    def SetSelected(self):
        """SetSelected(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetSelected(self)


    def SetHighlighted(self):
        """SetHighlighted(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetHighlighted(self)


    def SetBrightened(self):
        """SetBrightened(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetBrightened(self)


    def ClearSelected(self):
        """ClearSelected(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearSelected(self)


    def ClearHighlighted(self):
        """ClearHighlighted(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearHighlighted(self)


    def ClearBrightened(self):
        """ClearBrightened(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearBrightened(self)


    def SetModified(self):
        """SetModified(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetModified(self)


    def GetState(self, type):
        """GetState(MODULE_List self, int type) -> int"""
        return _pcbnew.MODULE_List_GetState(self, type)


    def SetState(self, type, state):
        """SetState(MODULE_List self, int type, int state)"""
        return _pcbnew.MODULE_List_SetState(self, type, state)


    def GetStatus(self):
        """GetStatus(MODULE_List self) -> STATUS_FLAGS"""
        return _pcbnew.MODULE_List_GetStatus(self)


    def SetStatus(self, aStatus):
        """SetStatus(MODULE_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.MODULE_List_SetStatus(self, aStatus)


    def SetFlags(self, aMask):
        """SetFlags(MODULE_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.MODULE_List_SetFlags(self, aMask)


    def ClearFlags(self, aMask=-1):
        """
        ClearFlags(MODULE_List self, STATUS_FLAGS aMask=-1)
        ClearFlags(MODULE_List self)
        """
        return _pcbnew.MODULE_List_ClearFlags(self, aMask)


    def GetFlags(self):
        """GetFlags(MODULE_List self) -> STATUS_FLAGS"""
        return _pcbnew.MODULE_List_GetFlags(self)


    def SetImage(self, aItem):
        """SetImage(MODULE_List self, EDA_ITEM aItem)"""
        return _pcbnew.MODULE_List_SetImage(self, aItem)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(MODULE_List self, bool aEnable)"""
        return _pcbnew.MODULE_List_SetForceVisible(self, aEnable)


    def IterateForward(self, listStart, inspector, testData, scanTypes):
        """IterateForward(MODULE_List self, EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.MODULE_List_IterateForward(self, listStart, inspector, testData, scanTypes)


    def Matches(self, aSearchData, aAuxData, aFindLocation):
        """Matches(MODULE_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.MODULE_List_Matches(self, aSearchData, aAuxData, aFindLocation)


    def Replace(self, *args):
        """
        Replace(MODULE_List self, wxFindReplaceData & aSearchData, wxString & aText) -> bool
        Replace(MODULE_List self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        Replace(MODULE_List self, wxFindReplaceData & aSearchData) -> bool
        """
        return _pcbnew.MODULE_List_Replace(self, *args)


    def IsReplaceable(self):
        """IsReplaceable(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsReplaceable(self)


    def __lt__(self, aItem):
        """__lt__(MODULE_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.MODULE_List___lt__(self, aItem)


    def Sort(self, aLeft, aRight):
        """Sort(MODULE_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.MODULE_List_Sort(self, aLeft, aRight)

MODULE_List_swigregister = _pcbnew.MODULE_List_swigregister
MODULE_List_swigregister(MODULE_List)

class TRACK_List(DHEAD):
    """Proxy of C++ DLIST<(TRACK)> class"""
    __swig_setmethods__ = {}
    for _s in [DHEAD]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TRACK_List, name, value)
    __swig_getmethods__ = {}
    for _s in [DHEAD]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TRACK_List, name)
    __repr__ = _swig_repr

    def Get(self):
        """Get(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Get(self)


    def __deref__(self):
        """__deref__(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List___deref__(self)


    def GetFirst(self):
        """GetFirst(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_GetFirst(self)


    def GetLast(self):
        """GetLast(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_GetLast(self)


    def Append(self, *args):
        """
        Append(TRACK_List self, TRACK aNewElement)
        Append(TRACK_List self, TRACK_List aList)
        """
        return _pcbnew.TRACK_List_Append(self, *args)


    def Insert(self, aNewElement, aElementAfterMe):
        """Insert(TRACK_List self, TRACK aNewElement, TRACK aElementAfterMe)"""
        return _pcbnew.TRACK_List_Insert(self, aNewElement, aElementAfterMe)


    def Remove(self, aElement):
        """Remove(TRACK_List self, TRACK aElement) -> TRACK"""
        return _pcbnew.TRACK_List_Remove(self, aElement)


    def begin(self):
        """begin(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_begin(self)


    def end(self):
        """end(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_end(self)


    def PopFront(self):
        """PopFront(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_PopFront(self)


    def PopBack(self):
        """PopBack(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_PopBack(self)


    def PushFront(self, aNewElement):
        """PushFront(TRACK_List self, TRACK aNewElement)"""
        return _pcbnew.TRACK_List_PushFront(self, aNewElement)


    def PushBack(self, aNewElement):
        """PushBack(TRACK_List self, TRACK aNewElement)"""
        return _pcbnew.TRACK_List_PushBack(self, aNewElement)


    class DLISTIter:
        def __init__(self,aList):
            self.last = aList   # last item is the start of list

        def next(self):         # get the next item

            item = self.last
            try:
              item = item.Get()
            except:
              pass

            if item is None:    # if the item is None, then finish the iteration
                raise StopIteration
            else:
                ret = None

    # first item in list has "Get" as a DLIST
                try:
                    ret = self.last.Get()
                except:
                    ret = self.last # next items do not..

                self.last = self.last.Next()

    # when the iterated object can be casted down in inheritance, just do it..

                if 'Cast' in dir(ret):
                    ret = ret.Cast()

                return ret

    def __iter__(self):
        return self.DLISTIter(self)



    def __init__(self):
        """__init__(DLIST<(TRACK)> self) -> TRACK_List"""
        this = _pcbnew.new_TRACK_List()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_TRACK_List
    __del__ = lambda self: None

    def ClassOf(self, aItem):
        """ClassOf(TRACK_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_List_ClassOf(self, aItem)

    __swig_setmethods__["start"] = _pcbnew.TRACK_List_start_set
    __swig_getmethods__["start"] = _pcbnew.TRACK_List_start_get
    if _newclass:
        start = _swig_property(_pcbnew.TRACK_List_start_get, _pcbnew.TRACK_List_start_set)
    __swig_setmethods__["end"] = _pcbnew.TRACK_List_end_set
    __swig_getmethods__["end"] = _pcbnew.TRACK_List_end_get
    if _newclass:
        end = _swig_property(_pcbnew.TRACK_List_end_get, _pcbnew.TRACK_List_end_set)
    __swig_setmethods__["m_Param"] = _pcbnew.TRACK_List_m_Param_set
    __swig_getmethods__["m_Param"] = _pcbnew.TRACK_List_m_Param_get
    if _newclass:
        m_Param = _swig_property(_pcbnew.TRACK_List_m_Param_get, _pcbnew.TRACK_List_m_Param_set)

    def Next(self):
        """Next(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Next(self)


    def Back(self):
        """Back(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Back(self)


    def Move(self, aMoveVector):
        """Move(TRACK_List self, wxPoint aMoveVector)"""
        return _pcbnew.TRACK_List_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(TRACK_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TRACK_List_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(TRACK_List self, wxPoint aCentre)"""
        return _pcbnew.TRACK_List_Flip(self, aCentre)


    def SetPosition(self, aPos):
        """SetPosition(TRACK_List self, wxPoint aPos)"""
        return _pcbnew.TRACK_List_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetPosition(self)


    def SetWidth(self, aWidth):
        """SetWidth(TRACK_List self, int aWidth)"""
        return _pcbnew.TRACK_List_SetWidth(self, aWidth)


    def GetWidth(self):
        """GetWidth(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetWidth(self)


    def SetEnd(self, aEnd):
        """SetEnd(TRACK_List self, wxPoint aEnd)"""
        return _pcbnew.TRACK_List_SetEnd(self, aEnd)


    def GetEnd(self):
        """GetEnd(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetEnd(self)


    def SetStart(self, aStart):
        """SetStart(TRACK_List self, wxPoint aStart)"""
        return _pcbnew.TRACK_List_SetStart(self, aStart)


    def GetStart(self):
        """GetStart(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetStart(self)


    def GetEndPoint(self, aEndPoint):
        """GetEndPoint(TRACK_List self, ENDPOINT_T aEndPoint) -> wxPoint"""
        return _pcbnew.TRACK_List_GetEndPoint(self, aEndPoint)


    def GetBoundingBox(self):
        """GetBoundingBox(TRACK_List self) -> EDA_RECT"""
        return _pcbnew.TRACK_List_GetBoundingBox(self)


    def GetBestInsertPoint(self, aPcb):
        """GetBestInsertPoint(TRACK_List self, BOARD aPcb) -> TRACK"""
        return _pcbnew.TRACK_List_GetBestInsertPoint(self, aPcb)


    def GetStartNetCode(self, NetCode):
        """GetStartNetCode(TRACK_List self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_List_GetStartNetCode(self, NetCode)


    def GetEndNetCode(self, NetCode):
        """GetEndNetCode(TRACK_List self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_List_GetEndNetCode(self, NetCode)


    def GetLength(self):
        """GetLength(TRACK_List self) -> double"""
        return _pcbnew.TRACK_List_GetLength(self)


    def Draw(self, *args):
        """
        Draw(TRACK_List self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(TRACK_List self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TRACK_List_Draw(self, *args)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygon(TRACK_List self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.TRACK_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def IsPointOnEnds(self, point, min_dist=0):
        """
        IsPointOnEnds(TRACK_List self, wxPoint point, int min_dist=0) -> STATUS_FLAGS
        IsPointOnEnds(TRACK_List self, wxPoint point) -> STATUS_FLAGS
        """
        return _pcbnew.TRACK_List_IsPointOnEnds(self, point, min_dist)


    def IsNull(self):
        """IsNull(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsNull(self)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(TRACK_List self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TRACK_List_GetMsgPanelInfo(self, aList)


    def ShowWidth(self):
        """ShowWidth(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_ShowWidth(self)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(TRACK_List self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.TRACK_List_Visit(self, inspector, testData, scanTypes)


    def HitTest(self, *args):
        """
        HitTest(TRACK_List self, wxPoint aPosition) -> bool
        HitTest(TRACK_List self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(TRACK_List self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(TRACK_List self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.TRACK_List_HitTest(self, *args)


    def GetVia(self, *args):
        """
        GetVia(TRACK_List self, wxPoint aPosition, LAYER_ID aLayer) -> VIA
        GetVia(TRACK_List self, wxPoint aPosition) -> VIA
        GetVia(TRACK_List self, TRACK aEndTrace, wxPoint aPosition, LSET aLayerMask) -> VIA
        """
        return _pcbnew.TRACK_List_GetVia(self, *args)


    def GetTrack(self, aStartTrace, aEndTrace, aEndPoint, aSameNetOnly, aSequential):
        """GetTrack(TRACK_List self, TRACK aStartTrace, TRACK aEndTrace, ENDPOINT_T aEndPoint, bool aSameNetOnly, bool aSequential) -> TRACK"""
        return _pcbnew.TRACK_List_GetTrack(self, aStartTrace, aEndTrace, aEndPoint, aSameNetOnly, aSequential)


    def GetEndSegments(self, NbSegm, StartTrack, EndTrack):
        """GetEndSegments(TRACK_List self, int NbSegm, TRACK ** StartTrack, TRACK ** EndTrack) -> int"""
        return _pcbnew.TRACK_List_GetEndSegments(self, NbSegm, StartTrack, EndTrack)


    def GetClass(self):
        """GetClass(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetClass(self)


    def GetClearance(self, aItem=None):
        """
        GetClearance(TRACK_List self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(TRACK_List self) -> int
        """
        return _pcbnew.TRACK_List_GetClearance(self, aItem)


    def GetSelectMenuText(self):
        """GetSelectMenuText(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TRACK_List self) -> BITMAP_DEF"""
        return _pcbnew.TRACK_List_GetMenuImage(self)


    def Clone(self):
        """Clone(TRACK_List self) -> EDA_ITEM"""
        return _pcbnew.TRACK_List_Clone(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(TRACK_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.TRACK_List_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(TRACK_List self, int aLayer) -> unsigned int"""
        return _pcbnew.TRACK_List_ViewGetLOD(self, aLayer)

    __swig_setmethods__["m_TracksConnected"] = _pcbnew.TRACK_List_m_TracksConnected_set
    __swig_getmethods__["m_TracksConnected"] = _pcbnew.TRACK_List_m_TracksConnected_get
    if _newclass:
        m_TracksConnected = _swig_property(_pcbnew.TRACK_List_m_TracksConnected_get, _pcbnew.TRACK_List_m_TracksConnected_set)
    __swig_setmethods__["m_PadsConnected"] = _pcbnew.TRACK_List_m_PadsConnected_set
    __swig_getmethods__["m_PadsConnected"] = _pcbnew.TRACK_List_m_PadsConnected_get
    if _newclass:
        m_PadsConnected = _swig_property(_pcbnew.TRACK_List_m_PadsConnected_get, _pcbnew.TRACK_List_m_PadsConnected_set)

    def IsConnected(self):
        """IsConnected(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsConnected(self)


    def GetNet(self):
        """GetNet(TRACK_List self) -> NETINFO_ITEM"""
        return _pcbnew.TRACK_List_GetNet(self)


    def GetNetCode(self):
        """GetNetCode(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetNetCode(self)


    def SetNetCode(self, aNetCode, aNoAssert=False):
        """
        SetNetCode(TRACK_List self, int aNetCode, bool aNoAssert=False) -> bool
        SetNetCode(TRACK_List self, int aNetCode) -> bool
        """
        return _pcbnew.TRACK_List_SetNetCode(self, aNetCode, aNoAssert)


    def GetSubNet(self):
        """GetSubNet(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetSubNet(self)


    def SetSubNet(self, aSubNetCode):
        """SetSubNet(TRACK_List self, int aSubNetCode)"""
        return _pcbnew.TRACK_List_SetSubNet(self, aSubNetCode)


    def GetZoneSubNet(self):
        """GetZoneSubNet(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetZoneSubNet(self)


    def SetZoneSubNet(self, aSubNetCode):
        """SetZoneSubNet(TRACK_List self, int aSubNetCode)"""
        return _pcbnew.TRACK_List_SetZoneSubNet(self, aSubNetCode)


    def GetNetname(self):
        """GetNetname(TRACK_List self) -> wxString const &"""
        return _pcbnew.TRACK_List_GetNetname(self)


    def GetShortNetname(self):
        """GetShortNetname(TRACK_List self) -> wxString const &"""
        return _pcbnew.TRACK_List_GetShortNetname(self)


    def GetNetClass(self):
        """GetNetClass(TRACK_List self) -> boost::shared_ptr< NETCLASS >"""
        return _pcbnew.TRACK_List_GetNetClass(self)


    def GetNetClassName(self):
        """GetNetClassName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetClassName(self)


    def GetCenter(self):
        """GetCenter(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetCenter(self)


    def GetParent(self):
        """GetParent(TRACK_List self) -> BOARD_ITEM"""
        return _pcbnew.TRACK_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(TRACK_List self) -> LAYER_ID"""
        return _pcbnew.TRACK_List_GetLayer(self)


    def GetLayerSet(self):
        """GetLayerSet(TRACK_List self) -> LSET"""
        return _pcbnew.TRACK_List_GetLayerSet(self)


    def SetLayer(self, aLayer):
        """SetLayer(TRACK_List self, LAYER_ID aLayer)"""
        return _pcbnew.TRACK_List_SetLayer(self, aLayer)


    def SwapData(self, aImage):
        """SwapData(TRACK_List self, BOARD_ITEM aImage)"""
        return _pcbnew.TRACK_List_SwapData(self, aImage)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(TRACK_List self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.TRACK_List_IsOnLayer(self, aLayer)


    def IsTrack(self):
        """IsTrack(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsTrack(self)


    def IsLocked(self):
        """IsLocked(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsLocked(self)


    def UnLink(self):
        """UnLink(TRACK_List self)"""
        return _pcbnew.TRACK_List_UnLink(self)


    def DeleteStructure(self):
        """DeleteStructure(TRACK_List self)"""
        return _pcbnew.TRACK_List_DeleteStructure(self)


    def ShowShape(self, aShape):
        """ShowShape(TRACK_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.TRACK_List_ShowShape(self, aShape)


    def GetBoard(self):
        """GetBoard(TRACK_List self) -> BOARD"""
        return _pcbnew.TRACK_List_GetBoard(self)


    def GetLayerName(self):
        """GetLayerName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetLayerName(self)


    def FormatInternalUnits(self, *args):
        """
        FormatInternalUnits(TRACK_List self, int aValue) -> string
        FormatInternalUnits(TRACK_List self, wxPoint aPoint) -> string
        FormatInternalUnits(TRACK_List self, wxSize aSize) -> string
        """
        return _pcbnew.TRACK_List_FormatInternalUnits(self, *args)


    def FormatAngle(self, aAngle):
        """FormatAngle(TRACK_List self, double aAngle) -> string"""
        return _pcbnew.TRACK_List_FormatAngle(self, aAngle)


    def IncrementItemReference(self):
        """IncrementItemReference(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IncrementItemReference(self)


    def Cast_to_TEXTE_PCB(self):
        """Cast_to_TEXTE_PCB(TRACK_List self) -> TEXTE_PCB"""
        return _pcbnew.TRACK_List_Cast_to_TEXTE_PCB(self)


    def Cast_to_DIMENSION(self):
        """Cast_to_DIMENSION(TRACK_List self) -> DIMENSION"""
        return _pcbnew.TRACK_List_Cast_to_DIMENSION(self)


    def Cast_to_MODULE(self):
        """Cast_to_MODULE(TRACK_List self) -> MODULE"""
        return _pcbnew.TRACK_List_Cast_to_MODULE(self)


    def Cast_to_TEXTE_MODULE(self):
        """Cast_to_TEXTE_MODULE(TRACK_List self) -> TEXTE_MODULE"""
        return _pcbnew.TRACK_List_Cast_to_TEXTE_MODULE(self)


    def Cast_to_DRAWSEGMENT(self):
        """Cast_to_DRAWSEGMENT(TRACK_List self) -> DRAWSEGMENT"""
        return _pcbnew.TRACK_List_Cast_to_DRAWSEGMENT(self)


    def Cast_to_MARKER_PCB(self):
        """Cast_to_MARKER_PCB(TRACK_List self) -> MARKER_PCB"""
        return _pcbnew.TRACK_List_Cast_to_MARKER_PCB(self)


    def Cast_to_BOARD(self):
        """Cast_to_BOARD(TRACK_List self) -> BOARD"""
        return _pcbnew.TRACK_List_Cast_to_BOARD(self)


    def Cast_to_EDGE_MODULE(self):
        """Cast_to_EDGE_MODULE(TRACK_List self) -> EDGE_MODULE"""
        return _pcbnew.TRACK_List_Cast_to_EDGE_MODULE(self)


    def Cast_to_D_PAD(self):
        """Cast_to_D_PAD(TRACK_List self) -> D_PAD"""
        return _pcbnew.TRACK_List_Cast_to_D_PAD(self)


    def Cast_to_TRACK(self):
        """Cast_to_TRACK(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Cast_to_TRACK(self)


    def Cast_to_VIA(self):
        """Cast_to_VIA(TRACK_List self) -> VIA"""
        return _pcbnew.TRACK_List_Cast_to_VIA(self)


    def Cast_to_ZONE_CONTAINER(self):
        """Cast_to_ZONE_CONTAINER(TRACK_List self) -> ZONE_CONTAINER"""
        return _pcbnew.TRACK_List_Cast_to_ZONE_CONTAINER(self)


    def Cast_to_PCB_TARGET(self):
        """Cast_to_PCB_TARGET(TRACK_List self) -> PCB_TARGET"""
        return _pcbnew.TRACK_List_Cast_to_PCB_TARGET(self)


    def Type(self):
        """Type(TRACK_List self) -> KICAD_T"""
        return _pcbnew.TRACK_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(TRACK_List self, time_t aNewTimeStamp)"""
        return _pcbnew.TRACK_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(TRACK_List self) -> time_t"""
        return _pcbnew.TRACK_List_GetTimeStamp(self)


    def GetList(self):
        """GetList(TRACK_List self) -> DHEAD"""
        return _pcbnew.TRACK_List_GetList(self)


    def SetParent(self, aParent):
        """SetParent(TRACK_List self, EDA_ITEM aParent)"""
        return _pcbnew.TRACK_List_SetParent(self, aParent)


    def SetList(self, aList):
        """SetList(TRACK_List self, DHEAD aList)"""
        return _pcbnew.TRACK_List_SetList(self, aList)


    def IsNew(self):
        """IsNew(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsNew(self)


    def IsModified(self):
        """IsModified(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsModified(self)


    def IsMoving(self):
        """IsMoving(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsMoving(self)


    def IsDragging(self):
        """IsDragging(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsDragging(self)


    def IsWireImage(self):
        """IsWireImage(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsWireImage(self)


    def IsSelected(self):
        """IsSelected(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsSelected(self)


    def IsResized(self):
        """IsResized(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsResized(self)


    def IsHighlighted(self):
        """IsHighlighted(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsHighlighted(self)


    def IsBrightened(self):
        """IsBrightened(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsBrightened(self)


    def SetWireImage(self):
        """SetWireImage(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetWireImage(self)


    def SetSelected(self):
        """SetSelected(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetSelected(self)


    def SetHighlighted(self):
        """SetHighlighted(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetHighlighted(self)


    def SetBrightened(self):
        """SetBrightened(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetBrightened(self)


    def ClearSelected(self):
        """ClearSelected(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearSelected(self)


    def ClearHighlighted(self):
        """ClearHighlighted(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearHighlighted(self)


    def ClearBrightened(self):
        """ClearBrightened(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearBrightened(self)


    def SetModified(self):
        """SetModified(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetModified(self)


    def GetState(self, type):
        """GetState(TRACK_List self, int type) -> int"""
        return _pcbnew.TRACK_List_GetState(self, type)


    def SetState(self, type, state):
        """SetState(TRACK_List self, int type, int state)"""
        return _pcbnew.TRACK_List_SetState(self, type, state)


    def GetStatus(self):
        """GetStatus(TRACK_List self) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_GetStatus(self)


    def SetStatus(self, aStatus):
        """SetStatus(TRACK_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.TRACK_List_SetStatus(self, aStatus)


    def SetFlags(self, aMask):
        """SetFlags(TRACK_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.TRACK_List_SetFlags(self, aMask)


    def ClearFlags(self, aMask=-1):
        """
        ClearFlags(TRACK_List self, STATUS_FLAGS aMask=-1)
        ClearFlags(TRACK_List self)
        """
        return _pcbnew.TRACK_List_ClearFlags(self, aMask)


    def GetFlags(self):
        """GetFlags(TRACK_List self) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_GetFlags(self)


    def SetImage(self, aItem):
        """SetImage(TRACK_List self, EDA_ITEM aItem)"""
        return _pcbnew.TRACK_List_SetImage(self, aItem)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(TRACK_List self, bool aEnable)"""
        return _pcbnew.TRACK_List_SetForceVisible(self, aEnable)


    def IterateForward(self, listStart, inspector, testData, scanTypes):
        """IterateForward(TRACK_List self, EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.TRACK_List_IterateForward(self, listStart, inspector, testData, scanTypes)


    def Matches(self, aSearchData, aAuxData, aFindLocation):
        """Matches(TRACK_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.TRACK_List_Matches(self, aSearchData, aAuxData, aFindLocation)


    def Replace(self, *args):
        """
        Replace(TRACK_List self, wxFindReplaceData & aSearchData, wxString & aText) -> bool
        Replace(TRACK_List self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        Replace(TRACK_List self, wxFindReplaceData & aSearchData) -> bool
        """
        return _pcbnew.TRACK_List_Replace(self, *args)


    def IsReplaceable(self):
        """IsReplaceable(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsReplaceable(self)


    def __lt__(self, aItem):
        """__lt__(TRACK_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_List___lt__(self, aItem)


    def Sort(self, aLeft, aRight):
        """Sort(TRACK_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.TRACK_List_Sort(self, aLeft, aRight)


    def ViewBBox(self):
        """ViewBBox(TRACK_List self) -> BOX2I const"""
        return _pcbnew.TRACK_List_ViewBBox(self)

TRACK_List_swigregister = _pcbnew.TRACK_List_swigregister
TRACK_List_swigregister(TRACK_List)

class PAD_List(DHEAD):
    """Proxy of C++ DLIST<(D_PAD)> class"""
    __swig_setmethods__ = {}
    for _s in [DHEAD]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PAD_List, name, value)
    __swig_getmethods__ = {}
    for _s in [DHEAD]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PAD_List, name)
    __repr__ = _swig_repr

    def Get(self):
        """Get(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Get(self)


    def __deref__(self):
        """__deref__(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List___deref__(self)


    def GetFirst(self):
        """GetFirst(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_GetFirst(self)


    def GetLast(self):
        """GetLast(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_GetLast(self)


    def Append(self, *args):
        """
        Append(PAD_List self, D_PAD aNewElement)
        Append(PAD_List self, PAD_List aList)
        """
        return _pcbnew.PAD_List_Append(self, *args)


    def Insert(self, aNewElement, aElementAfterMe):
        """Insert(PAD_List self, D_PAD aNewElement, D_PAD aElementAfterMe)"""
        return _pcbnew.PAD_List_Insert(self, aNewElement, aElementAfterMe)


    def Remove(self, aElement):
        """Remove(PAD_List self, D_PAD aElement) -> D_PAD"""
        return _pcbnew.PAD_List_Remove(self, aElement)


    def begin(self):
        """begin(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_begin(self)


    def end(self):
        """end(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_end(self)


    def PopFront(self):
        """PopFront(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_PopFront(self)


    def PopBack(self):
        """PopBack(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_PopBack(self)


    def PushFront(self, aNewElement):
        """PushFront(PAD_List self, D_PAD aNewElement)"""
        return _pcbnew.PAD_List_PushFront(self, aNewElement)


    def PushBack(self, aNewElement):
        """PushBack(PAD_List self, D_PAD aNewElement)"""
        return _pcbnew.PAD_List_PushBack(self, aNewElement)


    class DLISTIter:
        def __init__(self,aList):
            self.last = aList   # last item is the start of list

        def next(self):         # get the next item

            item = self.last
            try:
              item = item.Get()
            except:
              pass

            if item is None:    # if the item is None, then finish the iteration
                raise StopIteration
            else:
                ret = None

    # first item in list has "Get" as a DLIST
                try:
                    ret = self.last.Get()
                except:
                    ret = self.last # next items do not..

                self.last = self.last.Next()

    # when the iterated object can be casted down in inheritance, just do it..

                if 'Cast' in dir(ret):
                    ret = ret.Cast()

                return ret

    def __iter__(self):
        return self.DLISTIter(self)



    def __init__(self):
        """__init__(DLIST<(D_PAD)> self) -> PAD_List"""
        this = _pcbnew.new_PAD_List()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PAD_List
    __del__ = lambda self: None

    def StandardMask(self):
        """StandardMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_StandardMask(self)


    def SMDMask(self):
        """SMDMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_SMDMask(self)


    def ConnSMDMask(self):
        """ConnSMDMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_ConnSMDMask(self)


    def UnplatedHoleMask(self):
        """UnplatedHoleMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_UnplatedHoleMask(self)


    def ClassOf(self, aItem):
        """ClassOf(PAD_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_List_ClassOf(self, aItem)


    def Copy(self, source):
        """Copy(PAD_List self, D_PAD source)"""
        return _pcbnew.PAD_List_Copy(self, source)


    def Next(self):
        """Next(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Next(self)


    def GetParent(self):
        """GetParent(PAD_List self) -> MODULE"""
        return _pcbnew.PAD_List_GetParent(self)


    def SetPadName(self, name):
        """SetPadName(PAD_List self, wxString const & name)"""
        return _pcbnew.PAD_List_SetPadName(self, name)


    def GetPadName(self):
        """GetPadName(PAD_List self) -> wxString const"""
        return _pcbnew.PAD_List_GetPadName(self)


    def IncrementItemReference(self):
        """IncrementItemReference(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IncrementItemReference(self)


    def IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps):
        """IncrementPadName(PAD_List self, bool aSkipUnconnectable, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.PAD_List_IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps)


    def PadNameEqual(self, other):
        """PadNameEqual(PAD_List self, D_PAD other) -> bool"""
        return _pcbnew.PAD_List_PadNameEqual(self, other)


    def GetShape(self):
        """GetShape(PAD_List self) -> PAD_SHAPE_T"""
        return _pcbnew.PAD_List_GetShape(self)


    def SetShape(self, aShape):
        """SetShape(PAD_List self, PAD_SHAPE_T aShape)"""
        return _pcbnew.PAD_List_SetShape(self, aShape)


    def SetPosition(self, aPos):
        """SetPosition(PAD_List self, wxPoint aPos)"""
        return _pcbnew.PAD_List_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetPosition(self)


    def SetY(self, y):
        """SetY(PAD_List self, int y)"""
        return _pcbnew.PAD_List_SetY(self, y)


    def SetX(self, x):
        """SetX(PAD_List self, int x)"""
        return _pcbnew.PAD_List_SetX(self, x)


    def SetPos0(self, aPos):
        """SetPos0(PAD_List self, wxPoint aPos)"""
        return _pcbnew.PAD_List_SetPos0(self, aPos)


    def GetPos0(self):
        """GetPos0(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetPos0(self)


    def SetY0(self, y):
        """SetY0(PAD_List self, int y)"""
        return _pcbnew.PAD_List_SetY0(self, y)


    def SetX0(self, x):
        """SetX0(PAD_List self, int x)"""
        return _pcbnew.PAD_List_SetX0(self, x)


    def SetSize(self, aSize):
        """SetSize(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetSize(self, aSize)


    def GetSize(self):
        """GetSize(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetSize(self)


    def SetDelta(self, aSize):
        """SetDelta(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetDelta(self, aSize)


    def GetDelta(self):
        """GetDelta(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetDelta(self)


    def SetDrillSize(self, aSize):
        """SetDrillSize(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetDrillSize(self, aSize)


    def GetDrillSize(self):
        """GetDrillSize(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetDrillSize(self)


    def SetOffset(self, aOffset):
        """SetOffset(PAD_List self, wxPoint aOffset)"""
        return _pcbnew.PAD_List_SetOffset(self, aOffset)


    def GetOffset(self):
        """GetOffset(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetOffset(self)


    def Flip(self, aCentre):
        """Flip(PAD_List self, wxPoint aCentre)"""
        return _pcbnew.PAD_List_Flip(self, aCentre)


    def SetOrientation(self, aAngle):
        """SetOrientation(PAD_List self, double aAngle)"""
        return _pcbnew.PAD_List_SetOrientation(self, aAngle)


    def GetOrientation(self):
        """GetOrientation(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientation(self)


    def SetDrillShape(self, aDrillShape):
        """SetDrillShape(PAD_List self, PAD_DRILL_SHAPE_T aDrillShape)"""
        return _pcbnew.PAD_List_SetDrillShape(self, aDrillShape)


    def GetDrillShape(self):
        """GetDrillShape(PAD_List self) -> PAD_DRILL_SHAPE_T"""
        return _pcbnew.PAD_List_GetDrillShape(self)


    def GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth):
        """GetOblongDrillGeometry(PAD_List self, wxPoint aStartPoint, wxPoint aEndPoint, int & aWidth)"""
        return _pcbnew.PAD_List_GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth)


    def SetLayerSet(self, aLayerMask):
        """SetLayerSet(PAD_List self, LSET aLayerMask)"""
        return _pcbnew.PAD_List_SetLayerSet(self, aLayerMask)


    def GetLayerSet(self):
        """GetLayerSet(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_GetLayerSet(self)


    def SetAttribute(self, aAttribute):
        """SetAttribute(PAD_List self, PAD_ATTR_T aAttribute)"""
        return _pcbnew.PAD_List_SetAttribute(self, aAttribute)


    def GetAttribute(self):
        """GetAttribute(PAD_List self) -> PAD_ATTR_T"""
        return _pcbnew.PAD_List_GetAttribute(self)


    def SetPadToDieLength(self, aLength):
        """SetPadToDieLength(PAD_List self, int aLength)"""
        return _pcbnew.PAD_List_SetPadToDieLength(self, aLength)


    def GetPadToDieLength(self):
        """GetPadToDieLength(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetPadToDieLength(self)


    def GetLocalSolderMaskMargin(self):
        """GetLocalSolderMaskMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalSolderMaskMargin(self)


    def SetLocalSolderMaskMargin(self, aMargin):
        """SetLocalSolderMaskMargin(PAD_List self, int aMargin)"""
        return _pcbnew.PAD_List_SetLocalSolderMaskMargin(self, aMargin)


    def GetLocalClearance(self):
        """GetLocalClearance(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalClearance(self)


    def SetLocalClearance(self, aClearance):
        """SetLocalClearance(PAD_List self, int aClearance)"""
        return _pcbnew.PAD_List_SetLocalClearance(self, aClearance)


    def GetLocalSolderPasteMargin(self):
        """GetLocalSolderPasteMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalSolderPasteMargin(self)


    def SetLocalSolderPasteMargin(self, aMargin):
        """SetLocalSolderPasteMargin(PAD_List self, int aMargin)"""
        return _pcbnew.PAD_List_SetLocalSolderPasteMargin(self, aMargin)


    def GetLocalSolderPasteMarginRatio(self):
        """GetLocalSolderPasteMarginRatio(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetLocalSolderPasteMarginRatio(self)


    def SetLocalSolderPasteMarginRatio(self, aRatio):
        """SetLocalSolderPasteMarginRatio(PAD_List self, double aRatio)"""
        return _pcbnew.PAD_List_SetLocalSolderPasteMarginRatio(self, aRatio)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygon(PAD_List self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.PAD_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def GetClearance(self, aItem=None):
        """
        GetClearance(PAD_List self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(PAD_List self) -> int
        """
        return _pcbnew.PAD_List_GetClearance(self, aItem)


    def GetSolderMaskMargin(self):
        """GetSolderMaskMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetSolderMaskMargin(self)


    def GetSolderPasteMargin(self):
        """GetSolderPasteMargin(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetSolderPasteMargin(self)


    def SetZoneConnection(self, aType):
        """SetZoneConnection(PAD_List self, ZoneConnection aType)"""
        return _pcbnew.PAD_List_SetZoneConnection(self, aType)


    def GetZoneConnection(self):
        """GetZoneConnection(PAD_List self) -> ZoneConnection"""
        return _pcbnew.PAD_List_GetZoneConnection(self)


    def SetThermalWidth(self, aWidth):
        """SetThermalWidth(PAD_List self, int aWidth)"""
        return _pcbnew.PAD_List_SetThermalWidth(self, aWidth)


    def GetThermalWidth(self):
        """GetThermalWidth(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetThermalWidth(self)


    def SetThermalGap(self, aGap):
        """SetThermalGap(PAD_List self, int aGap)"""
        return _pcbnew.PAD_List_SetThermalGap(self, aGap)


    def GetThermalGap(self):
        """GetThermalGap(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetThermalGap(self)


    def Draw(self, *args):
        """
        Draw(PAD_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(PAD_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.PAD_List_Draw(self, *args)


    def DrawShape(self, aClipBox, aDC, aDrawInfo):
        """DrawShape(PAD_List self, EDA_RECT aClipBox, wxDC * aDC, PAD_DRAWINFO aDrawInfo)"""
        return _pcbnew.PAD_List_DrawShape(self, aClipBox, aDC, aDrawInfo)


    def BuildPadPolygon(self, aCoord, aInflateValue, aRotation):
        """BuildPadPolygon(PAD_List self, wxPoint aCoord, wxSize aInflateValue, double aRotation)"""
        return _pcbnew.PAD_List_BuildPadPolygon(self, aCoord, aInflateValue, aRotation)


    def BuildPadShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle, aCorrectionFactor):
        """BuildPadShapePolygon(PAD_List self, SHAPE_POLY_SET & aCornerBuffer, wxSize aInflateValue, int aSegmentsPerCircle, double aCorrectionFactor)"""
        return _pcbnew.PAD_List_BuildPadShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle, aCorrectionFactor)


    def BuildPadDrillShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle):
        """BuildPadDrillShapePolygon(PAD_List self, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aSegmentsPerCircle) -> bool"""
        return _pcbnew.PAD_List_BuildPadDrillShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle)


    def BuildSegmentFromOvalShape(self, aSegStart, aSegEnd, aRotation, aMargin):
        """BuildSegmentFromOvalShape(PAD_List self, wxPoint aSegStart, wxPoint aSegEnd, double aRotation, wxSize aMargin) -> int"""
        return _pcbnew.PAD_List_BuildSegmentFromOvalShape(self, aSegStart, aSegEnd, aRotation, aMargin)


    def StringPadName(self, text):
        """StringPadName(PAD_List self, wxString & text)"""
        return _pcbnew.PAD_List_StringPadName(self, text)


    def GetBoundingRadius(self):
        """GetBoundingRadius(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetBoundingRadius(self)


    def ShapePos(self):
        """ShapePos(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_ShapePos(self)


    def GetSubRatsnest(self):
        """GetSubRatsnest(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetSubRatsnest(self)


    def SetSubRatsnest(self, aSubRatsnest):
        """SetSubRatsnest(PAD_List self, int aSubRatsnest)"""
        return _pcbnew.PAD_List_SetSubRatsnest(self, aSubRatsnest)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(PAD_List self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PAD_List_GetMsgPanelInfo(self, aList)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(PAD_List self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.PAD_List_IsOnLayer(self, aLayer)


    def HitTest(self, aPosition):
        """HitTest(PAD_List self, wxPoint aPosition) -> bool"""
        return _pcbnew.PAD_List_HitTest(self, aPosition)


    def GetClass(self):
        """GetClass(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetClass(self)


    def GetBoundingBox(self):
        """GetBoundingBox(PAD_List self) -> EDA_RECT"""
        return _pcbnew.PAD_List_GetBoundingBox(self)


    def SetDrawCoord(self):
        """SetDrawCoord(PAD_List self)"""
        return _pcbnew.PAD_List_SetDrawCoord(self)


    def SetLocalCoord(self):
        """SetLocalCoord(PAD_List self)"""
        return _pcbnew.PAD_List_SetLocalCoord(self)


    def Compare(self, padref, padcmp):
        """Compare(PAD_List self, D_PAD padref, D_PAD padcmp) -> int"""
        return _pcbnew.PAD_List_Compare(self, padref, padcmp)


    def Move(self, aMoveVector):
        """Move(PAD_List self, wxPoint aMoveVector)"""
        return _pcbnew.PAD_List_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(PAD_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PAD_List_Rotate(self, aRotCentre, aAngle)


    def GetSelectMenuText(self):
        """GetSelectMenuText(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(PAD_List self) -> BITMAP_DEF"""
        return _pcbnew.PAD_List_GetMenuImage(self)


    def ShowPadShape(self):
        """ShowPadShape(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_ShowPadShape(self)


    def ShowPadAttr(self):
        """ShowPadAttr(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_ShowPadAttr(self)


    def AppendConfigs(self, aResult):
        """AppendConfigs(PAD_List self, PARAM_CFG_ARRAY * aResult)"""
        return _pcbnew.PAD_List_AppendConfigs(self, aResult)


    def Clone(self):
        """Clone(PAD_List self) -> EDA_ITEM"""
        return _pcbnew.PAD_List_Clone(self)


    def Duplicate(self):
        """Duplicate(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Duplicate(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(PAD_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.PAD_List_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(PAD_List self, int aLayer) -> unsigned int"""
        return _pcbnew.PAD_List_ViewGetLOD(self, aLayer)


    def ViewBBox(self):
        """ViewBBox(PAD_List self) -> BOX2I const"""
        return _pcbnew.PAD_List_ViewBBox(self)


    def CopyNetlistSettings(self, aPad):
        """CopyNetlistSettings(PAD_List self, D_PAD aPad)"""
        return _pcbnew.PAD_List_CopyNetlistSettings(self, aPad)

    __swig_setmethods__["m_TracksConnected"] = _pcbnew.PAD_List_m_TracksConnected_set
    __swig_getmethods__["m_TracksConnected"] = _pcbnew.PAD_List_m_TracksConnected_get
    if _newclass:
        m_TracksConnected = _swig_property(_pcbnew.PAD_List_m_TracksConnected_get, _pcbnew.PAD_List_m_TracksConnected_set)
    __swig_setmethods__["m_PadsConnected"] = _pcbnew.PAD_List_m_PadsConnected_set
    __swig_getmethods__["m_PadsConnected"] = _pcbnew.PAD_List_m_PadsConnected_get
    if _newclass:
        m_PadsConnected = _swig_property(_pcbnew.PAD_List_m_PadsConnected_get, _pcbnew.PAD_List_m_PadsConnected_set)

    def IsConnected(self):
        """IsConnected(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsConnected(self)


    def GetNet(self):
        """GetNet(PAD_List self) -> NETINFO_ITEM"""
        return _pcbnew.PAD_List_GetNet(self)


    def GetNetCode(self):
        """GetNetCode(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetNetCode(self)


    def SetNetCode(self, aNetCode, aNoAssert=False):
        """
        SetNetCode(PAD_List self, int aNetCode, bool aNoAssert=False) -> bool
        SetNetCode(PAD_List self, int aNetCode) -> bool
        """
        return _pcbnew.PAD_List_SetNetCode(self, aNetCode, aNoAssert)


    def GetSubNet(self):
        """GetSubNet(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetSubNet(self)


    def SetSubNet(self, aSubNetCode):
        """SetSubNet(PAD_List self, int aSubNetCode)"""
        return _pcbnew.PAD_List_SetSubNet(self, aSubNetCode)


    def GetZoneSubNet(self):
        """GetZoneSubNet(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetZoneSubNet(self)


    def SetZoneSubNet(self, aSubNetCode):
        """SetZoneSubNet(PAD_List self, int aSubNetCode)"""
        return _pcbnew.PAD_List_SetZoneSubNet(self, aSubNetCode)


    def GetNetname(self):
        """GetNetname(PAD_List self) -> wxString const &"""
        return _pcbnew.PAD_List_GetNetname(self)


    def GetShortNetname(self):
        """GetShortNetname(PAD_List self) -> wxString const &"""
        return _pcbnew.PAD_List_GetShortNetname(self)


    def GetNetClass(self):
        """GetNetClass(PAD_List self) -> boost::shared_ptr< NETCLASS >"""
        return _pcbnew.PAD_List_GetNetClass(self)


    def GetNetClassName(self):
        """GetNetClassName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetClassName(self)


    def GetCenter(self):
        """GetCenter(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetCenter(self)


    def Back(self):
        """Back(PAD_List self) -> BOARD_ITEM"""
        return _pcbnew.PAD_List_Back(self)


    def GetLayer(self):
        """GetLayer(PAD_List self) -> LAYER_ID"""
        return _pcbnew.PAD_List_GetLayer(self)


    def SetLayer(self, aLayer):
        """SetLayer(PAD_List self, LAYER_ID aLayer)"""
        return _pcbnew.PAD_List_SetLayer(self, aLayer)


    def SwapData(self, aImage):
        """SwapData(PAD_List self, BOARD_ITEM aImage)"""
        return _pcbnew.PAD_List_SwapData(self, aImage)


    def IsTrack(self):
        """IsTrack(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsTrack(self)


    def IsLocked(self):
        """IsLocked(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsLocked(self)


    def UnLink(self):
        """UnLink(PAD_List self)"""
        return _pcbnew.PAD_List_UnLink(self)


    def DeleteStructure(self):
        """DeleteStructure(PAD_List self)"""
        return _pcbnew.PAD_List_DeleteStructure(self)


    def ShowShape(self, aShape):
        """ShowShape(PAD_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.PAD_List_ShowShape(self, aShape)


    def GetBoard(self):
        """GetBoard(PAD_List self) -> BOARD"""
        return _pcbnew.PAD_List_GetBoard(self)


    def GetLayerName(self):
        """GetLayerName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetLayerName(self)


    def FormatInternalUnits(self, *args):
        """
        FormatInternalUnits(PAD_List self, int aValue) -> string
        FormatInternalUnits(PAD_List self, wxPoint aPoint) -> string
        FormatInternalUnits(PAD_List self, wxSize aSize) -> string
        """
        return _pcbnew.PAD_List_FormatInternalUnits(self, *args)


    def FormatAngle(self, aAngle):
        """FormatAngle(PAD_List self, double aAngle) -> string"""
        return _pcbnew.PAD_List_FormatAngle(self, aAngle)


    def Cast_to_TEXTE_PCB(self):
        """Cast_to_TEXTE_PCB(PAD_List self) -> TEXTE_PCB"""
        return _pcbnew.PAD_List_Cast_to_TEXTE_PCB(self)


    def Cast_to_DIMENSION(self):
        """Cast_to_DIMENSION(PAD_List self) -> DIMENSION"""
        return _pcbnew.PAD_List_Cast_to_DIMENSION(self)


    def Cast_to_MODULE(self):
        """Cast_to_MODULE(PAD_List self) -> MODULE"""
        return _pcbnew.PAD_List_Cast_to_MODULE(self)


    def Cast_to_TEXTE_MODULE(self):
        """Cast_to_TEXTE_MODULE(PAD_List self) -> TEXTE_MODULE"""
        return _pcbnew.PAD_List_Cast_to_TEXTE_MODULE(self)


    def Cast_to_DRAWSEGMENT(self):
        """Cast_to_DRAWSEGMENT(PAD_List self) -> DRAWSEGMENT"""
        return _pcbnew.PAD_List_Cast_to_DRAWSEGMENT(self)


    def Cast_to_MARKER_PCB(self):
        """Cast_to_MARKER_PCB(PAD_List self) -> MARKER_PCB"""
        return _pcbnew.PAD_List_Cast_to_MARKER_PCB(self)


    def Cast_to_BOARD(self):
        """Cast_to_BOARD(PAD_List self) -> BOARD"""
        return _pcbnew.PAD_List_Cast_to_BOARD(self)


    def Cast_to_EDGE_MODULE(self):
        """Cast_to_EDGE_MODULE(PAD_List self) -> EDGE_MODULE"""
        return _pcbnew.PAD_List_Cast_to_EDGE_MODULE(self)


    def Cast_to_D_PAD(self):
        """Cast_to_D_PAD(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Cast_to_D_PAD(self)


    def Cast_to_TRACK(self):
        """Cast_to_TRACK(PAD_List self) -> TRACK"""
        return _pcbnew.PAD_List_Cast_to_TRACK(self)


    def Cast_to_VIA(self):
        """Cast_to_VIA(PAD_List self) -> VIA"""
        return _pcbnew.PAD_List_Cast_to_VIA(self)


    def Cast_to_ZONE_CONTAINER(self):
        """Cast_to_ZONE_CONTAINER(PAD_List self) -> ZONE_CONTAINER"""
        return _pcbnew.PAD_List_Cast_to_ZONE_CONTAINER(self)


    def Cast_to_PCB_TARGET(self):
        """Cast_to_PCB_TARGET(PAD_List self) -> PCB_TARGET"""
        return _pcbnew.PAD_List_Cast_to_PCB_TARGET(self)


    def Type(self):
        """Type(PAD_List self) -> KICAD_T"""
        return _pcbnew.PAD_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(PAD_List self, time_t aNewTimeStamp)"""
        return _pcbnew.PAD_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(PAD_List self) -> time_t"""
        return _pcbnew.PAD_List_GetTimeStamp(self)


    def GetList(self):
        """GetList(PAD_List self) -> DHEAD"""
        return _pcbnew.PAD_List_GetList(self)


    def SetParent(self, aParent):
        """SetParent(PAD_List self, EDA_ITEM aParent)"""
        return _pcbnew.PAD_List_SetParent(self, aParent)


    def SetList(self, aList):
        """SetList(PAD_List self, DHEAD aList)"""
        return _pcbnew.PAD_List_SetList(self, aList)


    def IsNew(self):
        """IsNew(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsNew(self)


    def IsModified(self):
        """IsModified(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsModified(self)


    def IsMoving(self):
        """IsMoving(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsMoving(self)


    def IsDragging(self):
        """IsDragging(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsDragging(self)


    def IsWireImage(self):
        """IsWireImage(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsWireImage(self)


    def IsSelected(self):
        """IsSelected(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsSelected(self)


    def IsResized(self):
        """IsResized(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsResized(self)


    def IsHighlighted(self):
        """IsHighlighted(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsHighlighted(self)


    def IsBrightened(self):
        """IsBrightened(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsBrightened(self)


    def SetWireImage(self):
        """SetWireImage(PAD_List self)"""
        return _pcbnew.PAD_List_SetWireImage(self)


    def SetSelected(self):
        """SetSelected(PAD_List self)"""
        return _pcbnew.PAD_List_SetSelected(self)


    def SetHighlighted(self):
        """SetHighlighted(PAD_List self)"""
        return _pcbnew.PAD_List_SetHighlighted(self)


    def SetBrightened(self):
        """SetBrightened(PAD_List self)"""
        return _pcbnew.PAD_List_SetBrightened(self)


    def ClearSelected(self):
        """ClearSelected(PAD_List self)"""
        return _pcbnew.PAD_List_ClearSelected(self)


    def ClearHighlighted(self):
        """ClearHighlighted(PAD_List self)"""
        return _pcbnew.PAD_List_ClearHighlighted(self)


    def ClearBrightened(self):
        """ClearBrightened(PAD_List self)"""
        return _pcbnew.PAD_List_ClearBrightened(self)


    def SetModified(self):
        """SetModified(PAD_List self)"""
        return _pcbnew.PAD_List_SetModified(self)


    def GetState(self, type):
        """GetState(PAD_List self, int type) -> int"""
        return _pcbnew.PAD_List_GetState(self, type)


    def SetState(self, type, state):
        """SetState(PAD_List self, int type, int state)"""
        return _pcbnew.PAD_List_SetState(self, type, state)


    def GetStatus(self):
        """GetStatus(PAD_List self) -> STATUS_FLAGS"""
        return _pcbnew.PAD_List_GetStatus(self)


    def SetStatus(self, aStatus):
        """SetStatus(PAD_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.PAD_List_SetStatus(self, aStatus)


    def SetFlags(self, aMask):
        """SetFlags(PAD_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.PAD_List_SetFlags(self, aMask)


    def ClearFlags(self, aMask=-1):
        """
        ClearFlags(PAD_List self, STATUS_FLAGS aMask=-1)
        ClearFlags(PAD_List self)
        """
        return _pcbnew.PAD_List_ClearFlags(self, aMask)


    def GetFlags(self):
        """GetFlags(PAD_List self) -> STATUS_FLAGS"""
        return _pcbnew.PAD_List_GetFlags(self)


    def SetImage(self, aItem):
        """SetImage(PAD_List self, EDA_ITEM aItem)"""
        return _pcbnew.PAD_List_SetImage(self, aItem)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(PAD_List self, bool aEnable)"""
        return _pcbnew.PAD_List_SetForceVisible(self, aEnable)


    def IterateForward(self, listStart, inspector, testData, scanTypes):
        """IterateForward(PAD_List self, EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.PAD_List_IterateForward(self, listStart, inspector, testData, scanTypes)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(PAD_List self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.PAD_List_Visit(self, inspector, testData, scanTypes)


    def Matches(self, aSearchData, aAuxData, aFindLocation):
        """Matches(PAD_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.PAD_List_Matches(self, aSearchData, aAuxData, aFindLocation)


    def Replace(self, *args):
        """
        Replace(PAD_List self, wxFindReplaceData & aSearchData, wxString & aText) -> bool
        Replace(PAD_List self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        Replace(PAD_List self, wxFindReplaceData & aSearchData) -> bool
        """
        return _pcbnew.PAD_List_Replace(self, *args)


    def IsReplaceable(self):
        """IsReplaceable(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsReplaceable(self)


    def __lt__(self, aItem):
        """__lt__(PAD_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_List___lt__(self, aItem)


    def Sort(self, aLeft, aRight):
        """Sort(PAD_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.PAD_List_Sort(self, aLeft, aRight)

PAD_List_swigregister = _pcbnew.PAD_List_swigregister
PAD_List_swigregister(PAD_List)

class VIA_DIMENSION_Vector(_object):
    """Proxy of C++ std::vector<(VIA_DIMENSION)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VIA_DIMENSION_Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VIA_DIMENSION_Vector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(VIA_DIMENSION_Vector self) -> SwigPyIterator"""
        return _pcbnew.VIA_DIMENSION_Vector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector___nonzero__(self)


    def __bool__(self):
        """__bool__(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector___bool__(self)


    def __len__(self):
        """__len__(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector___len__(self)


    def pop(self):
        """pop(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j) -> VIA_DIMENSION_Vector"""
        return _pcbnew.VIA_DIMENSION_Vector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j, VIA_DIMENSION_Vector v)
        __setslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j)
        """
        return _pcbnew.VIA_DIMENSION_Vector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j)"""
        return _pcbnew.VIA_DIMENSION_Vector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i)
        __delitem__(VIA_DIMENSION_Vector self, PySliceObject * slice)
        """
        return _pcbnew.VIA_DIMENSION_Vector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(VIA_DIMENSION_Vector self, PySliceObject * slice) -> VIA_DIMENSION_Vector
        __getitem__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i) -> VIA_DIMENSION
        """
        return _pcbnew.VIA_DIMENSION_Vector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(VIA_DIMENSION_Vector self, PySliceObject * slice, VIA_DIMENSION_Vector v)
        __setitem__(VIA_DIMENSION_Vector self, PySliceObject * slice)
        __setitem__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, VIA_DIMENSION x)
        """
        return _pcbnew.VIA_DIMENSION_Vector___setitem__(self, *args)


    def append(self, x):
        """append(VIA_DIMENSION_Vector self, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_append(self, x)


    def empty(self):
        """empty(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector_empty(self)


    def size(self):
        """size(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector_size(self)


    def clear(self):
        """clear(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_clear(self)


    def swap(self, v):
        """swap(VIA_DIMENSION_Vector self, VIA_DIMENSION_Vector v)"""
        return _pcbnew.VIA_DIMENSION_Vector_swap(self, v)


    def get_allocator(self):
        """get_allocator(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::allocator_type"""
        return _pcbnew.VIA_DIMENSION_Vector_get_allocator(self)


    def begin(self):
        """begin(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_begin(self)


    def end(self):
        """end(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_end(self)


    def rbegin(self):
        """rbegin(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::reverse_iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_rbegin(self)


    def rend(self):
        """rend(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::reverse_iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_rend(self)


    def pop_back(self):
        """pop_back(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_pop_back(self)


    def erase(self, *args):
        """
        erase(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator pos) -> std::vector< VIA_DIMENSION >::iterator
        erase(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator first, std::vector< VIA_DIMENSION >::iterator last) -> std::vector< VIA_DIMENSION >::iterator
        """
        return _pcbnew.VIA_DIMENSION_Vector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(VIA_DIMENSION)> self) -> VIA_DIMENSION_Vector
        __init__(std::vector<(VIA_DIMENSION)> self, VIA_DIMENSION_Vector arg2) -> VIA_DIMENSION_Vector
        __init__(std::vector<(VIA_DIMENSION)> self, std::vector< VIA_DIMENSION >::size_type size) -> VIA_DIMENSION_Vector
        __init__(std::vector<(VIA_DIMENSION)> self, std::vector< VIA_DIMENSION >::size_type size, VIA_DIMENSION value) -> VIA_DIMENSION_Vector
        """
        this = _pcbnew.new_VIA_DIMENSION_Vector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(VIA_DIMENSION_Vector self, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_push_back(self, x)


    def front(self):
        """front(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_front(self)


    def back(self):
        """back(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_back(self)


    def assign(self, n, x):
        """assign(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type n, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type new_size)
        resize(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type new_size, VIA_DIMENSION x)
        """
        return _pcbnew.VIA_DIMENSION_Vector_resize(self, *args)


    def insert(self, *args):
        """
        insert(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator pos, VIA_DIMENSION x) -> std::vector< VIA_DIMENSION >::iterator
        insert(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator pos, std::vector< VIA_DIMENSION >::size_type n, VIA_DIMENSION x)
        """
        return _pcbnew.VIA_DIMENSION_Vector_insert(self, *args)


    def reserve(self, n):
        """reserve(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type n)"""
        return _pcbnew.VIA_DIMENSION_Vector_reserve(self, n)


    def capacity(self):
        """capacity(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector_capacity(self)

    __swig_destroy__ = _pcbnew.delete_VIA_DIMENSION_Vector
    __del__ = lambda self: None
VIA_DIMENSION_Vector_swigregister = _pcbnew.VIA_DIMENSION_Vector_swigregister
VIA_DIMENSION_Vector_swigregister(VIA_DIMENSION_Vector)

class RATSNEST_Vector(_object):
    """Proxy of C++ std::vector<(RATSNEST_ITEM)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RATSNEST_Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RATSNEST_Vector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(RATSNEST_Vector self) -> SwigPyIterator"""
        return _pcbnew.RATSNEST_Vector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(RATSNEST_Vector self) -> bool"""
        return _pcbnew.RATSNEST_Vector___nonzero__(self)


    def __bool__(self):
        """__bool__(RATSNEST_Vector self) -> bool"""
        return _pcbnew.RATSNEST_Vector___bool__(self)


    def __len__(self):
        """__len__(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::size_type"""
        return _pcbnew.RATSNEST_Vector___len__(self)


    def pop(self):
        """pop(RATSNEST_Vector self) -> RATSNEST_ITEM"""
        return _pcbnew.RATSNEST_Vector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i, std::vector< RATSNEST_ITEM >::difference_type j) -> RATSNEST_Vector"""
        return _pcbnew.RATSNEST_Vector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i, std::vector< RATSNEST_ITEM >::difference_type j, RATSNEST_Vector v)
        __setslice__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i, std::vector< RATSNEST_ITEM >::difference_type j)
        """
        return _pcbnew.RATSNEST_Vector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i, std::vector< RATSNEST_ITEM >::difference_type j)"""
        return _pcbnew.RATSNEST_Vector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i)
        __delitem__(RATSNEST_Vector self, PySliceObject * slice)
        """
        return _pcbnew.RATSNEST_Vector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(RATSNEST_Vector self, PySliceObject * slice) -> RATSNEST_Vector
        __getitem__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i) -> RATSNEST_ITEM
        """
        return _pcbnew.RATSNEST_Vector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(RATSNEST_Vector self, PySliceObject * slice, RATSNEST_Vector v)
        __setitem__(RATSNEST_Vector self, PySliceObject * slice)
        __setitem__(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::difference_type i, RATSNEST_ITEM x)
        """
        return _pcbnew.RATSNEST_Vector___setitem__(self, *args)


    def append(self, x):
        """append(RATSNEST_Vector self, RATSNEST_ITEM x)"""
        return _pcbnew.RATSNEST_Vector_append(self, x)


    def empty(self):
        """empty(RATSNEST_Vector self) -> bool"""
        return _pcbnew.RATSNEST_Vector_empty(self)


    def size(self):
        """size(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::size_type"""
        return _pcbnew.RATSNEST_Vector_size(self)


    def clear(self):
        """clear(RATSNEST_Vector self)"""
        return _pcbnew.RATSNEST_Vector_clear(self)


    def swap(self, v):
        """swap(RATSNEST_Vector self, RATSNEST_Vector v)"""
        return _pcbnew.RATSNEST_Vector_swap(self, v)


    def get_allocator(self):
        """get_allocator(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::allocator_type"""
        return _pcbnew.RATSNEST_Vector_get_allocator(self)


    def begin(self):
        """begin(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::iterator"""
        return _pcbnew.RATSNEST_Vector_begin(self)


    def end(self):
        """end(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::iterator"""
        return _pcbnew.RATSNEST_Vector_end(self)


    def rbegin(self):
        """rbegin(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::reverse_iterator"""
        return _pcbnew.RATSNEST_Vector_rbegin(self)


    def rend(self):
        """rend(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::reverse_iterator"""
        return _pcbnew.RATSNEST_Vector_rend(self)


    def pop_back(self):
        """pop_back(RATSNEST_Vector self)"""
        return _pcbnew.RATSNEST_Vector_pop_back(self)


    def erase(self, *args):
        """
        erase(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::iterator pos) -> std::vector< RATSNEST_ITEM >::iterator
        erase(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::iterator first, std::vector< RATSNEST_ITEM >::iterator last) -> std::vector< RATSNEST_ITEM >::iterator
        """
        return _pcbnew.RATSNEST_Vector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(RATSNEST_ITEM)> self) -> RATSNEST_Vector
        __init__(std::vector<(RATSNEST_ITEM)> self, RATSNEST_Vector arg2) -> RATSNEST_Vector
        __init__(std::vector<(RATSNEST_ITEM)> self, std::vector< RATSNEST_ITEM >::size_type size) -> RATSNEST_Vector
        __init__(std::vector<(RATSNEST_ITEM)> self, std::vector< RATSNEST_ITEM >::size_type size, RATSNEST_ITEM value) -> RATSNEST_Vector
        """
        this = _pcbnew.new_RATSNEST_Vector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(RATSNEST_Vector self, RATSNEST_ITEM x)"""
        return _pcbnew.RATSNEST_Vector_push_back(self, x)


    def front(self):
        """front(RATSNEST_Vector self) -> RATSNEST_ITEM"""
        return _pcbnew.RATSNEST_Vector_front(self)


    def back(self):
        """back(RATSNEST_Vector self) -> RATSNEST_ITEM"""
        return _pcbnew.RATSNEST_Vector_back(self)


    def assign(self, n, x):
        """assign(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::size_type n, RATSNEST_ITEM x)"""
        return _pcbnew.RATSNEST_Vector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::size_type new_size)
        resize(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::size_type new_size, RATSNEST_ITEM x)
        """
        return _pcbnew.RATSNEST_Vector_resize(self, *args)


    def insert(self, *args):
        """
        insert(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::iterator pos, RATSNEST_ITEM x) -> std::vector< RATSNEST_ITEM >::iterator
        insert(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::iterator pos, std::vector< RATSNEST_ITEM >::size_type n, RATSNEST_ITEM x)
        """
        return _pcbnew.RATSNEST_Vector_insert(self, *args)


    def reserve(self, n):
        """reserve(RATSNEST_Vector self, std::vector< RATSNEST_ITEM >::size_type n)"""
        return _pcbnew.RATSNEST_Vector_reserve(self, n)


    def capacity(self):
        """capacity(RATSNEST_Vector self) -> std::vector< RATSNEST_ITEM >::size_type"""
        return _pcbnew.RATSNEST_Vector_capacity(self)

    __swig_destroy__ = _pcbnew.delete_RATSNEST_Vector
    __del__ = lambda self: None
RATSNEST_Vector_swigregister = _pcbnew.RATSNEST_Vector_swigregister
RATSNEST_Vector_swigregister(RATSNEST_Vector)



def GetPluginForPath(lpath):
    return IO_MGR.PluginFind(IO_MGR.LEGACY)

def FootprintEnumerate(lpath):
    plug = GetPluginForPath(lpath)
    return plug.FootprintEnumerate(lpath)

def FootprintLoad(lpath,name):
    plug = GetPluginForPath(lpath)
    return plug.FootprintLoad(lpath,name)

def FootprintSave(lpath,module):
    plug = GetPluginForPath(lpath)
    return plug.FootprintSave(lpath,module)

def FootprintDelete(lpath,name):
    plug = GetPluginForPath(lpath)
    plug.FootprintDelete(lpath,name)

def FootprintLibCreate(lpath):
    plug = GetPluginForPath(lpath)
    plug.FootprintLibCreate(lpath)

def FootprintLibDelete(lpath):
    plug = GetPluginForPath(lpath)
    plug.FootprintLibDelete(lpath)

def FootprintIsWritable(lpath):
    plug = GetPluginForPath(lpath)
    plug.FootprintLibIsWritable(lpath)

class PYTHON_FOOTPRINT_WIZARDS(_object):
    """Proxy of C++ PYTHON_FOOTPRINT_WIZARDS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PYTHON_FOOTPRINT_WIZARDS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PYTHON_FOOTPRINT_WIZARDS, name)
    __repr__ = _swig_repr

    def register_wizard(wizard):
        """register_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARDS_register_wizard(wizard)

    if _newclass:
        register_wizard = staticmethod(register_wizard)
    __swig_getmethods__["register_wizard"] = lambda x: register_wizard

    def deregister_wizard(wizard):
        """deregister_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARDS_deregister_wizard(wizard)

    if _newclass:
        deregister_wizard = staticmethod(deregister_wizard)
    __swig_getmethods__["deregister_wizard"] = lambda x: deregister_wizard

    def __init__(self):
        """__init__(PYTHON_FOOTPRINT_WIZARDS self) -> PYTHON_FOOTPRINT_WIZARDS"""
        this = _pcbnew.new_PYTHON_FOOTPRINT_WIZARDS()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PYTHON_FOOTPRINT_WIZARDS
    __del__ = lambda self: None
PYTHON_FOOTPRINT_WIZARDS_swigregister = _pcbnew.PYTHON_FOOTPRINT_WIZARDS_swigregister
PYTHON_FOOTPRINT_WIZARDS_swigregister(PYTHON_FOOTPRINT_WIZARDS)

def PYTHON_FOOTPRINT_WIZARDS_register_wizard(wizard):
    """PYTHON_FOOTPRINT_WIZARDS_register_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARDS_register_wizard(wizard)

def PYTHON_FOOTPRINT_WIZARDS_deregister_wizard(wizard):
    """PYTHON_FOOTPRINT_WIZARDS_deregister_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARDS_deregister_wizard(wizard)


def ToMM(iu):
   if type(iu) in [int,float]:
      return float(iu) / float(1e6)
   elif type(iu) in [wxPoint,wxSize]:
      return tuple(map(ToMM,iu))

def FromMM(mm):
   if type(mm) in [int,float]:
      return int(float(mm) * float(1e6))
   elif type(mm) in [wxPoint,wxSize]:
     return tuple(map(FromMM,mm))

def ToMils(iu):
   if type(iu) in [int,float]:
     return float(iu) / float((1e6 * 0.0254))
   elif type(iu) in [wxPoint,wxSize]:
     return tuple(map(ToMils,iu))

def FromMils(mils):
   if type(mils) in [int,float]:
      return int(float(mils)*float((1e6 * 0.0254)))
   elif type(mils) in [wxPoint,wxSize]:
     return tuple(map(FromMils,mils))

def wxSizeMM(mmx,mmy): return wxSize(FromMM(mmx),FromMM(mmy))
def wxSizeMils(mmx,mmy): return wxSize(FromMils(mmx),FromMils(mmy))

def wxPointMM(mmx,mmy): return wxPoint(FromMM(mmx),FromMM(mmy))
def wxPointMils(mmx,mmy): return wxPoint(FromMils(mmx),FromMils(mmy))

def wxRectMM(x,y,wx,wy):
     x = int(FromMM(x))
     y = int(FromMM(y))
     wx = int(FromMM(wx))
     wy = int (FromMM(wy))
     return wxRect(x,y,wx,wy)

def wxRectMils(x,y,wx,wy):
     x = int(FromMils(x))
     y = int(FromMils(y))
     wx = int(FromMils(wx))
     wy = int (FromMils(wy))
     return wxRect(x,y,wx,wy)


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