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

from sys import version_info as _swig_python_version_info
if False:
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_pcbnew')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_pcbnew')
    _pcbnew = swig_import_helper()
    del swig_import_helper
elif 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
        try:
            _mod = imp.load_module('_pcbnew', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _pcbnew = swig_import_helper()
    del swig_import_helper
else:
    import _pcbnew
del _swig_python_version_info

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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

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

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 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 get_allocator(self):
        """get_allocator(string self) -> std::basic_string< char >::allocator_type"""
        return _pcbnew.string_get_allocator(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 __builtin__.Exception:
            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)
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v)
        """
        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

SHARED_PTR_DISOWN = _pcbnew.SHARED_PTR_DISOWN
class KI_PARAM_ERROR(_object):
    """Proxy of C++ KI_PARAM_ERROR class."""

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

    def __init__(self, *args):
        """
        __init__(KI_PARAM_ERROR self, wxString aMessage) -> KI_PARAM_ERROR
        __init__(KI_PARAM_ERROR self) -> KI_PARAM_ERROR
        """
        this = _pcbnew.new_KI_PARAM_ERROR(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def What(self):
        """What(KI_PARAM_ERROR self) -> wxString"""
        return _pcbnew.KI_PARAM_ERROR_What(self)

    __swig_destroy__ = _pcbnew.delete_KI_PARAM_ERROR
    __del__ = lambda self: None
KI_PARAM_ERROR_swigregister = _pcbnew.KI_PARAM_ERROR_swigregister
KI_PARAM_ERROR_swigregister(KI_PARAM_ERROR)

class IO_ERROR(_object):
    """Proxy of C++ IO_ERROR class."""

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

    def __init__(self, *args):
        """
        __init__(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber) -> IO_ERROR
        __init__(IO_ERROR self) -> IO_ERROR
        """
        this = _pcbnew.new_IO_ERROR(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def init(self, aProblem, aThrowersFile, aThrowersFunction, aThrowersLineNumber):
        """init(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber)"""
        return _pcbnew.IO_ERROR_init(self, aProblem, aThrowersFile, aThrowersFunction, aThrowersLineNumber)


    def Problem(self):
        """Problem(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_Problem(self)


    def Where(self):
        """Where(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_Where(self)


    def What(self):
        """What(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_What(self)

    __swig_destroy__ = _pcbnew.delete_IO_ERROR
    __del__ = lambda self: None
IO_ERROR_swigregister = _pcbnew.IO_ERROR_swigregister
IO_ERROR_swigregister(IO_ERROR)

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)


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 __builtin__.Exception:
            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 __builtin__.Exception:
            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 __builtin__.Exception:
            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 wxString(_object):
    """Proxy of C++ wxString class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wxString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wxString, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pcbnew.delete_wxString
    __del__ = lambda self: None

    def __str__(self):
        """__str__(wxString self) -> PyObject *"""
        return _pcbnew.wxString___str__(self)


    def __repr__(self):     return 'wxString(\'' + self.__str__() + '\')'


    def __init__(self):
        """__init__(wxString self) -> wxString"""
        this = _pcbnew.new_wxString()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
wxString_swigregister = _pcbnew.wxString_swigregister
wxString_swigregister(wxString)

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 __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)
        __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j, wxPoint_Vector v)
        """
        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 pop(self):
        """pop(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_pop(self)


    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 swap(self, v):
        """swap(wxPoint_Vector self, wxPoint_Vector v)"""
        return _pcbnew.wxPoint_Vector_swap(self, v)


    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 clear(self):
        """clear(wxPoint_Vector self)"""
        return _pcbnew.wxPoint_Vector_clear(self)


    def get_allocator(self):
        """get_allocator(wxPoint_Vector self) -> std::vector< wxPoint >::allocator_type"""
        return _pcbnew.wxPoint_Vector_get_allocator(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 __builtin__.Exception:
            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)


def FROM_UTF8(cstring):
    """FROM_UTF8(char const * cstring) -> wxString"""
    return _pcbnew.FROM_UTF8(cstring)

def AccumulateDescription(aDesc, aItem):
    """AccumulateDescription(wxString aDesc, wxString aItem)"""
    return _pcbnew.AccumulateDescription(aDesc, aItem)

def GetChars(s):
    """GetChars(wxString s) -> wxChar const *"""
    return _pcbnew.GetChars(s)
NOT_USED = _pcbnew.NOT_USED
EOT = _pcbnew.EOT
TYPE_NOT_INIT = _pcbnew.TYPE_NOT_INIT
PCB_T = _pcbnew.PCB_T
SCREEN_T = _pcbnew.SCREEN_T
PCB_MODULE_T = _pcbnew.PCB_MODULE_T
PCB_PAD_T = _pcbnew.PCB_PAD_T
PCB_LINE_T = _pcbnew.PCB_LINE_T
PCB_TEXT_T = _pcbnew.PCB_TEXT_T
PCB_MODULE_TEXT_T = _pcbnew.PCB_MODULE_TEXT_T
PCB_MODULE_EDGE_T = _pcbnew.PCB_MODULE_EDGE_T
PCB_TRACE_T = _pcbnew.PCB_TRACE_T
PCB_VIA_T = _pcbnew.PCB_VIA_T
PCB_SEGZONE_T = _pcbnew.PCB_SEGZONE_T
PCB_MARKER_T = _pcbnew.PCB_MARKER_T
PCB_DIMENSION_T = _pcbnew.PCB_DIMENSION_T
PCB_TARGET_T = _pcbnew.PCB_TARGET_T
PCB_ZONE_AREA_T = _pcbnew.PCB_ZONE_AREA_T
PCB_ITEM_LIST_T = _pcbnew.PCB_ITEM_LIST_T
PCB_NETINFO_T = _pcbnew.PCB_NETINFO_T
SCH_MARKER_T = _pcbnew.SCH_MARKER_T
SCH_NO_CONNECT_T = _pcbnew.SCH_NO_CONNECT_T
SCH_JUNCTION_T = _pcbnew.SCH_JUNCTION_T
SCH_TEXT_T = _pcbnew.SCH_TEXT_T
SCH_LABEL_T = _pcbnew.SCH_LABEL_T
SCH_GLOBAL_LABEL_T = _pcbnew.SCH_GLOBAL_LABEL_T
SCH_HIERARCHICAL_LABEL_T = _pcbnew.SCH_HIERARCHICAL_LABEL_T
SCH_BUS_WIRE_ENTRY_T = _pcbnew.SCH_BUS_WIRE_ENTRY_T
SCH_BUS_BUS_ENTRY_T = _pcbnew.SCH_BUS_BUS_ENTRY_T
SCH_LINE_T = _pcbnew.SCH_LINE_T
SCH_FIELD_T = _pcbnew.SCH_FIELD_T
SCH_COMPONENT_T = _pcbnew.SCH_COMPONENT_T
SCH_SHEET_PIN_T = _pcbnew.SCH_SHEET_PIN_T
SCH_SHEET_T = _pcbnew.SCH_SHEET_T
SCH_BITMAP_T = _pcbnew.SCH_BITMAP_T
SCH_FIELD_LOCATE_REFERENCE_T = _pcbnew.SCH_FIELD_LOCATE_REFERENCE_T
SCH_FIELD_LOCATE_VALUE_T = _pcbnew.SCH_FIELD_LOCATE_VALUE_T
SCH_FIELD_LOCATE_FOOTPRINT_T = _pcbnew.SCH_FIELD_LOCATE_FOOTPRINT_T
SCH_FIELD_LOCATE_DATASHEET_T = _pcbnew.SCH_FIELD_LOCATE_DATASHEET_T
SCH_SCREEN_T = _pcbnew.SCH_SCREEN_T
LIB_PART_T = _pcbnew.LIB_PART_T
LIB_ALIAS_T = _pcbnew.LIB_ALIAS_T
LIB_ARC_T = _pcbnew.LIB_ARC_T
LIB_CIRCLE_T = _pcbnew.LIB_CIRCLE_T
LIB_TEXT_T = _pcbnew.LIB_TEXT_T
LIB_RECTANGLE_T = _pcbnew.LIB_RECTANGLE_T
LIB_POLYLINE_T = _pcbnew.LIB_POLYLINE_T
LIB_BEZIER_T = _pcbnew.LIB_BEZIER_T
LIB_PIN_T = _pcbnew.LIB_PIN_T
LIB_FIELD_T = _pcbnew.LIB_FIELD_T
GERBER_LAYOUT_T = _pcbnew.GERBER_LAYOUT_T
GERBER_DRAW_ITEM_T = _pcbnew.GERBER_DRAW_ITEM_T
GERBER_IMAGE_LIST_T = _pcbnew.GERBER_IMAGE_LIST_T
GERBER_IMAGE_T = _pcbnew.GERBER_IMAGE_T
TYPE_PL_EDITOR_LAYOUT = _pcbnew.TYPE_PL_EDITOR_LAYOUT
SYMBOL_LIB_TABLE_T = _pcbnew.SYMBOL_LIB_TABLE_T
FP_LIB_TABLE_T = _pcbnew.FP_LIB_TABLE_T
PART_LIBS_T = _pcbnew.PART_LIBS_T
SEARCH_STACK_T = _pcbnew.SEARCH_STACK_T
CACHE_WRAPPER_T = _pcbnew.CACHE_WRAPPER_T
MAX_STRUCT_TYPE_ID = _pcbnew.MAX_STRUCT_TYPE_ID
NO_FILL = _pcbnew.NO_FILL
FILLED_SHAPE = _pcbnew.FILLED_SHAPE
FILLED_WITH_BG_BODYCOLOR = _pcbnew.FILLED_WITH_BG_BODYCOLOR
SEARCH_QUIT = _pcbnew.SEARCH_QUIT
SEARCH_CONTINUE = _pcbnew.SEARCH_CONTINUE
IS_CHANGED = _pcbnew.IS_CHANGED
IS_LINKED = _pcbnew.IS_LINKED
IN_EDIT = _pcbnew.IN_EDIT
IS_MOVED = _pcbnew.IS_MOVED
IS_NEW = _pcbnew.IS_NEW
IS_RESIZED = _pcbnew.IS_RESIZED
IS_DRAGGED = _pcbnew.IS_DRAGGED
IS_DELETED = _pcbnew.IS_DELETED
IS_WIRE_IMAGE = _pcbnew.IS_WIRE_IMAGE
STARTPOINT = _pcbnew.STARTPOINT
ENDPOINT = _pcbnew.ENDPOINT
SELECTED = _pcbnew.SELECTED
SELECTEDNODE = _pcbnew.SELECTEDNODE
STRUCT_DELETED = _pcbnew.STRUCT_DELETED
CANDIDATE = _pcbnew.CANDIDATE
SKIP_STRUCT = _pcbnew.SKIP_STRUCT
DO_NOT_DRAW = _pcbnew.DO_NOT_DRAW
IS_CANCELLED = _pcbnew.IS_CANCELLED
TRACK_LOCKED = _pcbnew.TRACK_LOCKED
TRACK_AR = _pcbnew.TRACK_AR
FLAG1 = _pcbnew.FLAG1
FLAG0 = _pcbnew.FLAG0
BEGIN_ONPAD = _pcbnew.BEGIN_ONPAD
END_ONPAD = _pcbnew.END_ONPAD
BUSY = _pcbnew.BUSY
HIGHLIGHTED = _pcbnew.HIGHLIGHTED
BRIGHTENED = _pcbnew.BRIGHTENED
DP_COUPLED = _pcbnew.DP_COUPLED
UR_TRANSIENT = _pcbnew.UR_TRANSIENT
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, timestamp_t aNewTimeStamp)"""
        return _pcbnew.EDA_ITEM_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(EDA_ITEM self) -> timestamp_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 IsType(self, aScanTypes):
        """IsType(EDA_ITEM self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.EDA_ITEM_IsType(self, aScanTypes)


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


    def GetMsgPanelInfo(self, aUnits, aList):
        """GetMsgPanelInfo(EDA_ITEM self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDA_ITEM_GetMsgPanelInfo(self, aUnits, 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 * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes)

    IterateForward = staticmethod(IterateForward)

    def Visit(self, inspector, testData, scanTypes):
        """Visit(EDA_ITEM self, INSPECTOR inspector, void * 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, aUnits):
        """GetSelectMenuText(EDA_ITEM self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.EDA_ITEM_GetSelectMenuText(self, aUnits)


    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)

    Sort = staticmethod(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 * 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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_EDA_RECT
    __del__ = lambda self: None

    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 GetSizeMax(self):
        """GetSizeMax(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetSizeMax(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 GetCenter(self):
        """GetCenter(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetCenter(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 GetTop(self):
        """GetTop(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetTop(self)


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


    def IsValid(self):
        """IsValid(EDA_RECT self) -> bool"""
        return _pcbnew.EDA_RECT_IsValid(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, EDA_RECT aRect, double aRot) -> bool
        Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2) -> bool
        """
        return _pcbnew.EDA_RECT_Intersects(self, *args)


    def ClosestPointTo(self, aPoint):
        """ClosestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
        return _pcbnew.EDA_RECT_ClosestPointTo(self, aPoint)


    def FarthestPointTo(self, aPoint):
        """FarthestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
        return _pcbnew.EDA_RECT_FarthestPointTo(self, aPoint)


    def IntersectsCircle(self, aCenter, aRadius):
        """IntersectsCircle(EDA_RECT self, wxPoint aCenter, int const aRadius) -> bool"""
        return _pcbnew.EDA_RECT_IntersectsCircle(self, aCenter, aRadius)


    def IntersectsCircleEdge(self, aCenter, aRadius, aWidth):
        """IntersectsCircleEdge(EDA_RECT self, wxPoint aCenter, int const aRadius, int const aWidth) -> bool"""
        return _pcbnew.EDA_RECT_IntersectsCircleEdge(self, aCenter, aRadius, aWidth)


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


    def getBOX2I(self):
        """getBOX2I(EDA_RECT self) -> BOX2I"""
        return _pcbnew.EDA_RECT_getBOX2I(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)

EDA_RECT_swigregister = _pcbnew.EDA_RECT_swigregister
EDA_RECT_swigregister(EDA_RECT)

EDA_PANNING_UP_KEY = _pcbnew.EDA_PANNING_UP_KEY
EDA_PANNING_DOWN_KEY = _pcbnew.EDA_PANNING_DOWN_KEY
EDA_PANNING_LEFT_KEY = _pcbnew.EDA_PANNING_LEFT_KEY
EDA_PANNING_RIGHT_KEY = _pcbnew.EDA_PANNING_RIGHT_KEY
EDA_ZOOM_IN_FROM_MOUSE = _pcbnew.EDA_ZOOM_IN_FROM_MOUSE
EDA_ZOOM_OUT_FROM_MOUSE = _pcbnew.EDA_ZOOM_OUT_FROM_MOUSE
EDA_ZOOM_CENTER_FROM_MOUSE = _pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE
ESC = _pcbnew.ESC
TEXT_ANGLE_HORIZ = _pcbnew.TEXT_ANGLE_HORIZ
TEXT_ANGLE_VERT = _pcbnew.TEXT_ANGLE_VERT

def KiROUND(v):
    """KiROUND(double v) -> int"""
    return _pcbnew.KiROUND(v)
INCHES = _pcbnew.INCHES
MILLIMETRES = _pcbnew.MILLIMETRES
UNSCALED_UNITS = _pcbnew.UNSCALED_UNITS
DEGREES = _pcbnew.DEGREES
PERCENT = _pcbnew.PERCENT
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 __builtin__.Exception:
            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 aSingleLine, wxWindow * aWindow) -> wxSize"""
    return _pcbnew.GetTextSize(aSingleLine, aWindow)

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

def SelectReferenceNumber(aTextEntry):
    """SelectReferenceNumber(wxTextEntry * aTextEntry)"""
    return _pcbnew.SelectReferenceNumber(aTextEntry)

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

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

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

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

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

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

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

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

def ExpandEnvVarSubstitutions(aString):
    """ExpandEnvVarSubstitutions(wxString aString) -> wxString"""
    return _pcbnew.ExpandEnvVarSubstitutions(aString)

def ResolveUriByEnvVars(aUri):
    """ResolveUriByEnvVars(wxString aUri) -> wxString"""
    return _pcbnew.ResolveUriByEnvVars(aUri)
class WX_FILENAME(_object):
    """Proxy of C++ WX_FILENAME class."""

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

    def __init__(self, aPath, aFilename):
        """__init__(WX_FILENAME self, wxString aPath, wxString aFilename) -> WX_FILENAME"""
        this = _pcbnew.new_WX_FILENAME(aPath, aFilename)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def SetFullName(self, aFileNameAndExtension):
        """SetFullName(WX_FILENAME self, wxString aFileNameAndExtension)"""
        return _pcbnew.WX_FILENAME_SetFullName(self, aFileNameAndExtension)


    def GetName(self):
        """GetName(WX_FILENAME self) -> wxString"""
        return _pcbnew.WX_FILENAME_GetName(self)


    def GetFullName(self):
        """GetFullName(WX_FILENAME self) -> wxString"""
        return _pcbnew.WX_FILENAME_GetFullName(self)


    def GetPath(self):
        """GetPath(WX_FILENAME self) -> wxString"""
        return _pcbnew.WX_FILENAME_GetPath(self)


    def GetFullPath(self):
        """GetFullPath(WX_FILENAME self) -> wxString"""
        return _pcbnew.WX_FILENAME_GetFullPath(self)


    def GetTimestamp(self):
        """GetTimestamp(WX_FILENAME self) -> long long"""
        return _pcbnew.WX_FILENAME_GetTimestamp(self)

    __swig_destroy__ = _pcbnew.delete_WX_FILENAME
    __del__ = lambda self: None
WX_FILENAME_swigregister = _pcbnew.WX_FILENAME_swigregister
WX_FILENAME_swigregister(WX_FILENAME)


def TimestampDir(aDirPath, aFilespec):
    """TimestampDir(wxString aDirPath, wxString aFilespec) -> long long"""
    return _pcbnew.TimestampDir(aDirPath, aFilespec)
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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_TITLE_BLOCK
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def GetComment4(self):
        """GetComment4(TITLE_BLOCK self) -> wxString"""
        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 COLOR4D(_object):
    """Proxy of C++ KIGFX::COLOR4D class."""

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

    def __init__(self, *args):
        """
        __init__(KIGFX::COLOR4D self) -> COLOR4D
        __init__(KIGFX::COLOR4D self, double aRed, double aGreen, double aBlue, double aAlpha) -> COLOR4D
        __init__(KIGFX::COLOR4D self, EDA_COLOR_T aColor) -> COLOR4D
        __init__(KIGFX::COLOR4D self, wxColour const & aColor) -> COLOR4D
        """
        this = _pcbnew.new_COLOR4D(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def SetFromWxString(self, aColorString):
        """SetFromWxString(COLOR4D self, wxString aColorString) -> bool"""
        return _pcbnew.COLOR4D_SetFromWxString(self, aColorString)


    def ToWxString(self, flags):
        """ToWxString(COLOR4D self, long flags) -> wxString"""
        return _pcbnew.COLOR4D_ToWxString(self, flags)


    def ToColour(self):
        """ToColour(COLOR4D self) -> wxColour"""
        return _pcbnew.COLOR4D_ToColour(self)


    def LegacyMix(self, aColor):
        """LegacyMix(COLOR4D self, COLOR4D aColor) -> COLOR4D"""
        return _pcbnew.COLOR4D_LegacyMix(self, aColor)


    def SetToLegacyHighlightColor(self):
        """SetToLegacyHighlightColor(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_SetToLegacyHighlightColor(self)


    def SetToNearestLegacyColor(self):
        """SetToNearestLegacyColor(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_SetToNearestLegacyColor(self)


    def AsLegacyColor(self):
        """AsLegacyColor(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_AsLegacyColor(self)


    def ToU32(self):
        """ToU32(COLOR4D self) -> unsigned int"""
        return _pcbnew.COLOR4D_ToU32(self)


    def FromU32(self, aPackedColor):
        """FromU32(COLOR4D self, unsigned int aPackedColor)"""
        return _pcbnew.COLOR4D_FromU32(self, aPackedColor)


    def GetNearestLegacyColor(aColor):
        """GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
        return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)

    GetNearestLegacyColor = staticmethod(GetNearestLegacyColor)

    def ToHSL(self, aOutHue, aOutSaturation, aOutValue):
        """ToHSL(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue)"""
        return _pcbnew.COLOR4D_ToHSL(self, aOutHue, aOutSaturation, aOutValue)


    def FromHSL(self, aInHue, aInSaturation, aInLightness):
        """FromHSL(COLOR4D self, double aInHue, double aInSaturation, double aInLightness)"""
        return _pcbnew.COLOR4D_FromHSL(self, aInHue, aInSaturation, aInLightness)


    def Brighten(self, aFactor):
        """Brighten(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Brighten(self, aFactor)


    def Darken(self, aFactor):
        """Darken(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Darken(self, aFactor)


    def Invert(self):
        """Invert(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_Invert(self)


    def Saturate(self, aFactor):
        """Saturate(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Saturate(self, aFactor)


    def Brightened(self, aFactor):
        """Brightened(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Brightened(self, aFactor)


    def Darkened(self, aFactor):
        """Darkened(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Darkened(self, aFactor)


    def WithAlpha(self, aAlpha):
        """WithAlpha(COLOR4D self, double aAlpha) -> COLOR4D"""
        return _pcbnew.COLOR4D_WithAlpha(self, aAlpha)


    def Inverted(self):
        """Inverted(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_Inverted(self)


    def GetBrightness(self):
        """GetBrightness(COLOR4D self) -> double"""
        return _pcbnew.COLOR4D_GetBrightness(self)


    def ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue=False):
        """
        ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue, bool aAlwaysDefineHue=False)
        ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue)
        """
        return _pcbnew.COLOR4D_ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue)


    def FromHSV(self, aInH, aInS, aInV):
        """FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
        return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)

    __swig_setmethods__["r"] = _pcbnew.COLOR4D_r_set
    __swig_getmethods__["r"] = _pcbnew.COLOR4D_r_get
    if _newclass:
        r = _swig_property(_pcbnew.COLOR4D_r_get, _pcbnew.COLOR4D_r_set)
    __swig_setmethods__["g"] = _pcbnew.COLOR4D_g_set
    __swig_getmethods__["g"] = _pcbnew.COLOR4D_g_get
    if _newclass:
        g = _swig_property(_pcbnew.COLOR4D_g_get, _pcbnew.COLOR4D_g_set)
    __swig_setmethods__["b"] = _pcbnew.COLOR4D_b_set
    __swig_getmethods__["b"] = _pcbnew.COLOR4D_b_get
    if _newclass:
        b = _swig_property(_pcbnew.COLOR4D_b_get, _pcbnew.COLOR4D_b_set)
    __swig_setmethods__["a"] = _pcbnew.COLOR4D_a_set
    __swig_getmethods__["a"] = _pcbnew.COLOR4D_a_get
    if _newclass:
        a = _swig_property(_pcbnew.COLOR4D_a_get, _pcbnew.COLOR4D_a_set)
    __swig_destroy__ = _pcbnew.delete_COLOR4D
    __del__ = lambda self: None
COLOR4D_swigregister = _pcbnew.COLOR4D_swigregister
COLOR4D_swigregister(COLOR4D)

def COLOR4D_GetNearestLegacyColor(aColor):
    """COLOR4D_GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
    return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
COLOR4D.UNSPECIFIED = _pcbnew.cvar.COLOR4D_UNSPECIFIED
COLOR4D.WHITE = _pcbnew.cvar.COLOR4D_WHITE
COLOR4D.BLACK = _pcbnew.cvar.COLOR4D_BLACK


def __eq__(lhs, rhs):
    """__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
    return _pcbnew.__eq__(lhs, rhs)

def __ne__(lhs, rhs):
    """__ne__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
    return _pcbnew.__ne__(lhs, rhs)

def __lshift__(aStream, aColor):
    """__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
    return _pcbnew.__lshift__(aStream, aColor)
class SETTINGS(_object):
    """Proxy of C++ SETTINGS class."""

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

    def __init__(self):
        """__init__(SETTINGS self) -> SETTINGS"""
        this = _pcbnew.new_SETTINGS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_SETTINGS
    __del__ = lambda self: None

    def SetConfigPrefix(self, aPrefix):
        """SetConfigPrefix(SETTINGS self, wxString aPrefix)"""
        return _pcbnew.SETTINGS_SetConfigPrefix(self, aPrefix)


    def GetConfigPrefix(self):
        """GetConfigPrefix(SETTINGS self) -> wxString"""
        return _pcbnew.SETTINGS_GetConfigPrefix(self)


    def Load(self, aConfig):
        """Load(SETTINGS self, wxConfigBase * aConfig)"""
        return _pcbnew.SETTINGS_Load(self, aConfig)


    def Save(self, aConfig):
        """Save(SETTINGS self, wxConfigBase * aConfig)"""
        return _pcbnew.SETTINGS_Save(self, aConfig)


    def Add(self, *args):
        """
        Add(SETTINGS self, wxString name, int * aPtr, int aDefaultValue)
        Add(SETTINGS self, wxString name, bool * aPtr, bool aDefaultValue)
        Add(SETTINGS self, wxString name, COLOR4D aPtr, COLOR4D aDefaultValue)
        Add(SETTINGS self, wxString name, COLOR4D aPtr, EDA_COLOR_T aDefaultValue)
        """
        return _pcbnew.SETTINGS_Add(self, *args)

SETTINGS_swigregister = _pcbnew.SETTINGS_swigregister
SETTINGS_swigregister(SETTINGS)

class COLORS_DESIGN_SETTINGS(SETTINGS):
    """Proxy of C++ COLORS_DESIGN_SETTINGS class."""

    __swig_setmethods__ = {}
    for _s in [SETTINGS]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, COLORS_DESIGN_SETTINGS, name, value)
    __swig_getmethods__ = {}
    for _s in [SETTINGS]:
        __swig_getmethods__.update(getattr(_s, '__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)

    def __init__(self, aFrameType):
        """__init__(COLORS_DESIGN_SETTINGS self, FRAME_T aFrameType) -> COLORS_DESIGN_SETTINGS"""
        this = _pcbnew.new_COLORS_DESIGN_SETTINGS(aFrameType)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_COLORS_DESIGN_SETTINGS
    __del__ = lambda self: None

    def Load(self, aConfig):
        """Load(COLORS_DESIGN_SETTINGS self, wxConfigBase * aConfig)"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_Load(self, aConfig)


    def Save(self, aConfig):
        """Save(COLORS_DESIGN_SETTINGS self, wxConfigBase * aConfig)"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_Save(self, aConfig)


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


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


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


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


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


    def SetLegacyMode(self, aMode):
        """SetLegacyMode(COLORS_DESIGN_SETTINGS self, bool aMode)"""
        return _pcbnew.COLORS_DESIGN_SETTINGS_SetLegacyMode(self, aMode)

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, int aScalingFactor) -> MARKER_BASE
        __init__(MARKER_BASE self, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, EDA_ITEM aItem, wxPoint aPos, EDA_ITEM bItem, wxPoint bPos, int aScalingFactor) -> MARKER_BASE
        __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos, int aScalingFactor) -> MARKER_BASE
        __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, int aScalingFactor) -> MARKER_BASE
        __init__(MARKER_BASE self, MARKER_BASE aMarker) -> MARKER_BASE
        """
        this = _pcbnew.new_MARKER_BASE(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MARKER_BASE
    __del__ = lambda self: None

    def MarkerScale(self):
        """MarkerScale(MARKER_BASE self) -> int"""
        return _pcbnew.MARKER_BASE_MarkerScale(self)


    def ShapeToPolygon(self, aPolygon):
        """ShapeToPolygon(MARKER_BASE self, SHAPE_LINE_CHAIN aPolygon)"""
        return _pcbnew.MARKER_BASE_ShapeToPolygon(self, aPolygon)


    def GetShapePolygon(self):
        """GetShapePolygon(MARKER_BASE self) -> VECTOR2I"""
        return _pcbnew.MARKER_BASE_GetShapePolygon(self)


    def GetShapePolygonCorner(self, aIdx):
        """GetShapePolygonCorner(MARKER_BASE self, int aIdx) -> VECTOR2I"""
        return _pcbnew.MARKER_BASE_GetShapePolygonCorner(self, aIdx)


    def GetShapePolygonCornerCount(self):
        """GetShapePolygonCornerCount(MARKER_BASE self) -> int"""
        return _pcbnew.MARKER_BASE_GetShapePolygonCornerCount(self)


    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, COLOR4D 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, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, EDA_ITEM aItem, wxPoint aPos, EDA_ITEM bItem=None, wxPoint bPos)
        SetData(MARKER_BASE self, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, EDA_ITEM aItem, wxPoint aPos, EDA_ITEM bItem=None)
        SetData(MARKER_BASE self, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, EDA_ITEM aItem, wxPoint aPos)
        SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos)
        SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText)
        SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos)
        """
        return _pcbnew.MARKER_BASE_SetData(self, *args)


    def SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos):
        """SetAuxiliaryData(MARKER_BASE self, wxString 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, aHitPosition):
        """HitTestMarker(MARKER_BASE self, wxPoint aHitPosition) -> bool"""
        return _pcbnew.MARKER_BASE_HitTestMarker(self, aHitPosition)


    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)

class UNIQUE_MUTEX(_object):
    """Proxy of C++ UNIQUE_MUTEX class."""

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

    def __init__(self, *args):
        """
        __init__(UNIQUE_MUTEX self) -> UNIQUE_MUTEX
        __init__(UNIQUE_MUTEX self, UNIQUE_MUTEX arg2) -> UNIQUE_MUTEX
        """
        this = _pcbnew.new_UNIQUE_MUTEX(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_UNIQUE_MUTEX
    __del__ = lambda self: None
UNIQUE_MUTEX_swigregister = _pcbnew.UNIQUE_MUTEX_swigregister
UNIQUE_MUTEX_swigregister(UNIQUE_MUTEX)

CTL_OMIT_HIDE = _pcbnew.CTL_OMIT_HIDE
GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT
GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER
GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT
GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP
GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER
GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM
FILLED = _pcbnew.FILLED
SKETCH = _pcbnew.SKETCH
DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT
DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE
class TEXT_EFFECTS(_object):
    """Proxy of C++ TEXT_EFFECTS class."""

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

    def __init__(self, aSetOfBits=0):
        """
        __init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS
        __init__(TEXT_EFFECTS self) -> TEXT_EFFECTS
        """
        this = _pcbnew.new_TEXT_EFFECTS(aSetOfBits)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_set
    __swig_getmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_get
    if _newclass:
        bits = _swig_property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set)
    __swig_setmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_set
    __swig_getmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_get
    if _newclass:
        hjustify = _swig_property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set)
    __swig_setmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_set
    __swig_getmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_get
    if _newclass:
        vjustify = _swig_property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set)
    __swig_setmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_set
    __swig_getmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_get
    if _newclass:
        size = _swig_property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set)
    __swig_setmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_set
    __swig_getmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_get
    if _newclass:
        penwidth = _swig_property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set)
    __swig_setmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_set
    __swig_getmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_get
    if _newclass:
        angle = _swig_property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set)
    __swig_setmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_set
    __swig_getmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_get
    if _newclass:
        pos = _swig_property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set)

    def Bit(self, *args):
        """
        Bit(TEXT_EFFECTS self, int aBit, bool aValue)
        Bit(TEXT_EFFECTS self, int aBit) -> bool
        """
        return _pcbnew.TEXT_EFFECTS_Bit(self, *args)

    __swig_destroy__ = _pcbnew.delete_TEXT_EFFECTS
    __del__ = lambda self: None
TEXT_EFFECTS_swigregister = _pcbnew.TEXT_EFFECTS_swigregister
TEXT_EFFECTS_swigregister(TEXT_EFFECTS)

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 text) -> EDA_TEXT
        __init__(EDA_TEXT self) -> EDA_TEXT
        """
        this = _pcbnew.new_EDA_TEXT(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_EDA_TEXT
    __del__ = lambda self: None

    def GetText(self):
        """GetText(EDA_TEXT self) -> wxString"""
        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 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 SetTextAngle(self, aAngle):
        """SetTextAngle(EDA_TEXT self, double aAngle)"""
        return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)


    def GetTextAngle(self):
        """GetTextAngle(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngle(self)


    def GetTextAngleDegrees(self):
        """GetTextAngleDegrees(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)


    def GetTextAngleRadians(self):
        """GetTextAngleRadians(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngleRadians(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 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 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 SetEffects(self, aSrc):
        """SetEffects(EDA_TEXT self, EDA_TEXT aSrc)"""
        return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)


    def SwapEffects(self, aTradingPartner):
        """SwapEffects(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
        return _pcbnew.EDA_TEXT_SwapEffects(self, aTradingPartner)


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


    def SetTextSize(self, aNewSize):
        """SetTextSize(EDA_TEXT self, wxSize aNewSize)"""
        return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize)


    def GetTextSize(self):
        """GetTextSize(EDA_TEXT self) -> wxSize"""
        return _pcbnew.EDA_TEXT_GetTextSize(self)


    def SetTextWidth(self, aWidth):
        """SetTextWidth(EDA_TEXT self, int aWidth)"""
        return _pcbnew.EDA_TEXT_SetTextWidth(self, aWidth)


    def GetTextWidth(self):
        """GetTextWidth(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetTextWidth(self)


    def SetTextHeight(self, aHeight):
        """SetTextHeight(EDA_TEXT self, int aHeight)"""
        return _pcbnew.EDA_TEXT_SetTextHeight(self, aHeight)


    def GetTextHeight(self):
        """GetTextHeight(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetTextHeight(self)


    def SetTextPos(self, aPoint):
        """SetTextPos(EDA_TEXT self, wxPoint aPoint)"""
        return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)


    def GetTextPos(self):
        """GetTextPos(EDA_TEXT self) -> wxPoint"""
        return _pcbnew.EDA_TEXT_GetTextPos(self)


    def SetTextX(self, aX):
        """SetTextX(EDA_TEXT self, int aX)"""
        return _pcbnew.EDA_TEXT_SetTextX(self, aX)


    def SetTextY(self, aY):
        """SetTextY(EDA_TEXT self, int aY)"""
        return _pcbnew.EDA_TEXT_SetTextY(self, aY)


    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, COLOR4D aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED, COLOR4D aAnchor_color)
        Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED)
        Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D 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 TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue):
        """TransformBoundingBoxWithClearanceToPolygon(EDA_TEXT self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue)"""
        return _pcbnew.EDA_TEXT_TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue)


    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, aThickness):
        """LenSize(EDA_TEXT self, wxString aLine, int aThickness) -> int"""
        return _pcbnew.EDA_TEXT_LenSize(self, aLine, aThickness)


    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 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)

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 __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)
        __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, intVector v)
        """
        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 pop(self):
        """pop(intVector self) -> std::vector< int >::value_type"""
        return _pcbnew.intVector_pop(self)


    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 swap(self, v):
        """swap(intVector self, intVector v)"""
        return _pcbnew.intVector_swap(self, v)


    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 clear(self):
        """clear(intVector self)"""
        return _pcbnew.intVector_clear(self)


    def get_allocator(self):
        """get_allocator(intVector self) -> std::vector< int >::allocator_type"""
        return _pcbnew.intVector_get_allocator(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 __builtin__.Exception:
            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 __builtin__.Exception:
            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 swap(self, v):
        """swap(str_utf8_Map self, str_utf8_Map v)"""
        return _pcbnew.str_utf8_Map_swap(self, v)


    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 clear(self):
        """clear(str_utf8_Map self)"""
        return _pcbnew.str_utf8_Map_clear(self)


    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 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 PCB_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 PCB_LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_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 PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)
        __setslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j, base_seqVect v)
        """
        return _pcbnew.base_seqVect___setslice__(self, *args)


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


    def __delitem__(self, *args):
        """
        __delitem__(base_seqVect self, std::vector< enum PCB_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 PCB_LAYER_ID >::difference_type i) -> std::vector< enum PCB_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 PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect___setitem__(self, *args)


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


    def append(self, x):
        """append(base_seqVect self, std::vector< enum PCB_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 PCB_LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect_size(self)


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


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


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


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


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


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


    def get_allocator(self):
        """get_allocator(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::allocator_type"""
        return _pcbnew.base_seqVect_get_allocator(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 PCB_LAYER_ID >::iterator pos) -> std::vector< enum PCB_LAYER_ID >::iterator
        erase(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator first, std::vector< enum PCB_LAYER_ID >::iterator last) -> std::vector< enum PCB_LAYER_ID >::iterator
        """
        return _pcbnew.base_seqVect_erase(self, *args)


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

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


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


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


    def assign(self, n, x):
        """assign(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n, std::vector< enum PCB_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 PCB_LAYER_ID >::size_type new_size)
        resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size, std::vector< enum PCB_LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect_resize(self, *args)


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


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


    def capacity(self):
        """capacity(base_seqVect self) -> std::vector< enum PCB_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={}    # the list of loaded footprint wizards

""" the list of not loaded python scripts
    (usually because there is a syntax error in python script)
    this is the python script full filenames list.
    filenames are separated by '\n'
"""
NOT_LOADED_WIZARDS=""

""" the list of paths used to search python scripts.
    Stored here to be displayed on request in Pcbnew
    paths are separated by '\n'
"""
PLUGIN_DIRECTORIES_SEARCH=""

""" the trace of errors during execution of footprint wizards scripts
"""
FULL_BACK_TRACE=""

def GetUnLoadableWizards():
    global NOT_LOADED_WIZARDS
    return NOT_LOADED_WIZARDS

def GetWizardsSearchPaths():
    global PLUGIN_DIRECTORIES_SEARCH
    return PLUGIN_DIRECTORIES_SEARCH

def GetWizardsBackTrace():
    global FULL_BACK_TRACE
    return FULL_BACK_TRACE


def LoadPluginModule(Dirname, ModuleName, FileName):
    """
    Load the plugin module named ModuleName located in the folder Dirname.
    The module can be either inside a file called FileName or a subdirectory
    called FileName that contains a __init__.py file.
    If this module cannot be loaded, its name is stored in failed_wizards_list
    and the error trace is stored in FULL_BACK_TRACE
    """
    import os
    import sys
    import traceback

    global NOT_LOADED_WIZARDS
    global FULL_BACK_TRACE

    try:  # If there is an error loading the script, skip it

        module_filename = os.path.join( Dirname, FileName )
        mtime = os.path.getmtime( module_filename )

        if ModuleName in KICAD_PLUGINS:
            plugin = KICAD_PLUGINS[ModuleName]

            if sys.version_info >= (3,4,0):
                import importlib
                mod = importlib.reload( plugin["ModuleName"] )
            elif sys.version_info >= (3,2,0):
                """
                TODO: This branch can be removed once the required python version is >=3.4
                """
                import imp
                mod = imp.reload( plugin["ModuleName"] )
            else:
                mod = reload( plugin["ModuleName"] )

        else:
            if sys.version_info >= (3,0,0):
                import importlib
                mod = importlib.import_module( ModuleName )
            else:
                mod = __import__( ModuleName, locals(), globals() )

        KICAD_PLUGINS[ModuleName]={ "filename":module_filename,
                                    "modification_time":mtime,
                                    "ModuleName":mod }

    except:
        if NOT_LOADED_WIZARDS != "" :
            NOT_LOADED_WIZARDS += "\n"
        NOT_LOADED_WIZARDS += module_filename
        FULL_BACK_TRACE += traceback.format_exc()


def LoadPlugins(bundlepath=None):
    """
    Initialise Scripting/Plugin python environment and load plugins.

    Arguments:
    bundlepath -- The path to the bundled scripts.
                  The bundled Plugins are relative to this path, in the
                  "plugins" subdirectory.
                WARNING: bundlepath must use '/' as path separator, and not '\'
                because it creates issues:
                \n and \r are seen as a escaped seq when passing this string to this method
                I am thinking this is due to the fact LoadPlugins is called from C++ code by
                PyRun_SimpleString()

    NOTE: These are all of the possible "default" search paths for kicad
          python scripts.  These paths will ONLY be added to the python
          search path ONLY IF they already exist.

        The Scripts bundled with the KiCad installation:
            <bundlepath>/
            <bundlepath>/plugins/

        The Scripts relative to the KiCad search path environment variable:
            [KICAD_PATH]/scripting/
            [KICAD_PATH]/scripting/plugins/

        The Scripts relative to the KiCad Users configuration:
            <kicad_config_path>/scripting/
            <kicad_config_path>/scripting/plugins/

        And on Linux ONLY, extra paths relative to the users home directory:
            ~/.kicad_plugins/
            ~/.kicad/scripting/
            ~/.kicad/scripting/plugins/
    """
    import os
    import sys
    import traceback
    import pcbnew

    if sys.version_info >= (3,3,0):
        import importlib
        importlib.invalidate_caches()

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

    """
    To be consistent with others paths, on windows, convert the unix '/' separator
    to the windows separator, although using '/' works
    """
    if sys.platform.startswith('win32'):
        bundlepath = bundlepath.replace("/","\\")

    if bundlepath:
        plugin_directories.append(bundlepath)
        plugin_directories.append(os.path.join(bundlepath, 'plugins'))

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

    if config_path:
        plugin_directories.append(os.path.join(config_path, 'scripting'))
        plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))

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

    global PLUGIN_DIRECTORIES_SEARCH
    PLUGIN_DIRECTORIES_SEARCH=""
    for plugins_dir in plugin_directories:    # save search path list for later use
        if PLUGIN_DIRECTORIES_SEARCH != "" :
            PLUGIN_DIRECTORIES_SEARCH += "\n"
        PLUGIN_DIRECTORIES_SEARCH += plugins_dir

    global FULL_BACK_TRACE
    FULL_BACK_TRACE=""          # clear any existing trace

    global NOT_LOADED_WIZARDS
    NOT_LOADED_WIZARDS = ""     # save not loaded wizards names list for later use

    global KICAD_PLUGINS

    for plugins_dir in plugin_directories:
        if not os.path.isdir( plugins_dir ):
            continue

        sys.path.append( plugins_dir )

        for module in os.listdir(plugins_dir):
            fullPath = os.path.join( plugins_dir, module )

            if os.path.isdir( fullPath ):
                if os.path.exists( os.path.join( fullPath, '__init__.py' ) ):
                    LoadPluginModule( plugins_dir, module, module )
                else:
                    if NOT_LOADED_WIZARDS != "" :
                        NOT_LOADED_WIZARDS += "\n"
                    NOT_LOADED_WIZARDS += 'Skip subdir ' + fullPath
                continue

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

            LoadPluginModule( plugins_dir, module[:-3], module )


class KiCadPlugin:
    def __init__(self):
        pass

    def register(self):
        import inspect
        import os

        if isinstance(self,FilePlugin):
            pass # register to file plugins in C++

        if isinstance(self,FootprintWizardPlugin):
            PYTHON_FOOTPRINT_WIZARD_LIST.register_wizard(self)
            return

        if isinstance(self,ActionPlugin):
            """
            Get path to .py or .pyc that has definition of plugin class.
            If path is binary but source also exists, assume definition is in source.
            """
            self.__plugin_path = inspect.getfile(self.__class__)
            if self.__plugin_path.endswith('.pyc') and os.path.isfile(self.__plugin_path[:-1]):
                self.__plugin_path = self.__plugin_path[:-1]
            self.__plugin_path = self.__plugin_path + '/' + self.__class__.__name__
            PYTHON_ACTION_PLUGINS.register_action(self)
            return

        return

    def deregister(self):
        if isinstance(self,FilePlugin):
            pass # deregister to file plugins in C++

        if isinstance(self,FootprintWizardPlugin):
            PYTHON_FOOTPRINT_WIZARD_LIST.deregister_wizard(self)
            return

        if isinstance(self,ActionPlugin):
            PYTHON_ACTION_PLUGINS.deregister_action(self)
            return

        return

    def GetPluginPath( self ):
        return self.__plugin_path


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


from math import ceil, floor, sqrt

uMM = "mm"              # Millimetres
uMils = "mils"          # Mils
uFloat = "float"        # Natural number units (dimensionless)
uInteger = "integer"    # Integer (no decimals, numeric, dimensionless)
uBool = "bool"          # Boolean value
uRadians = "radians"    # Angular units (radians)
uDegrees = "degrees"    # Angular units (degrees)
uPercent = "%"          # Percent (0% -> 100%)
uString = "string"      # Raw string

uNumeric = [uMM, uMils, uFloat, uInteger, uDegrees, uRadians, uPercent]                  # List of numeric types
uUnits   = [uMM, uMils, uFloat, uInteger, uBool, uDegrees, uRadians, uPercent, uString]  # List of allowable types

class FootprintWizardParameter(object):
    _true  = ['true','t','y','yes','on','1',1,]
    _false = ['false','f','n','no','off','0',0,'',None]

    _bools = _true + _false

    def __init__(self, page, name, units, default, **kwarg):
        self.page = page
        self.name = name
        self.hint = kwarg.get('hint','')               # Parameter hint (shown as mouse-over text)
        self.designator = kwarg.get('designator',' ')  # Parameter designator such as "e, D, p" (etc)

        if units.lower() in uUnits:
            self.units = units.lower()
        elif units.lower() == 'percent':
            self.units = uPercent
        elif type(units) in [list, tuple]:  # Convert a list of options into a single string
            self.units = ",".join([str(el).strip() for el in units])
        else:
            self.units = units

        self.multiple = int(kwarg.get('multiple',1))   # Check integer values are multiples of this number
        self.min_value = kwarg.get('min_value',None)   # Check numeric values are above or equal to this number
        self.max_value = kwarg.get('max_value',None)   # Check numeric values are below or equal to this number

        self.SetValue(default)
        self.default = self.raw_value  # Save value as default

    def ClearErrors(self):
        self.error_list = []

    def AddError(self, err, info=None):

        if err in self.error_list:  # prevent duplicate error messages
            return
        if info is not None:
            err = err + " (" + str(info) + ")"

        self.error_list.append(err)

    def Check(self, min_value=None, max_value=None, multiple=None, info=None):

        if min_value is None:
            min_value = self.min_value
        if max_value is None:
            max_value = self.max_value
        if multiple is None:
            multiple = self.multiple

        if self.units not in uUnits and ',' not in self.units:  # Allow either valid units or a list of strings
            self.AddError("type '{t}' unknown".format(t=self.units),info)
            self.AddError("Allowable types: " + str(self.units),info)

        if self.units in uNumeric:
            try:
                to_num = float(self.raw_value)

                if min_value is not None:  # Check minimum value if it is present
                    if to_num < min_value:
                        self.AddError("value '{v}' is below minimum ({m})".format(v=self.raw_value,m=min_value),info)

                if max_value is not None:  # Check maximum value if it is present
                    if to_num > max_value:
                        self.AddError("value '{v}' is above maximum ({m})".format(v=self.raw_value,m=max_value),info)

            except:
                self.AddError("value '{v}' is not of type '{t}'".format(v = self.raw_value, t=self.units),info)

        if self.units == uInteger:  # Perform integer specific checks
            try:
                to_int = int(self.raw_value)

                if multiple is not None and multiple > 1:
                    if (to_int % multiple) > 0:
                        self.AddError("value '{v}' is not a multiple of {m}".format(v=self.raw_value,m=multiple),info)
            except:
                self.AddError("value '{v}' is not an integer".format(v=self.raw_value),info)

        if self.units == uBool:  # Check that the value is of a correct boolean format
            if self.raw_value in [True,False] or str(self.raw_value).lower() in self._bools:
                pass
            else:
                self.AddError("value '{v}' is not a boolean value".format(v = self.raw_value),info)

    @property
    def value(self):  # Return the current value, converted to appropriate units (from string representation) if required
        v = str(self.raw_value)  # Enforce string type for known starting point

        if self.units == uInteger:  # Integer values
            return int(v)
        elif self.units in uNumeric:  # Any values that use floating points
            v = v.replace(",",".")  # Replace "," separators with "."
            v = float(v)

            if self.units == uMM: # Convert from millimetres to nanometres
                return FromMM(v)

            elif self.units == uMils:  # Convert from mils to nanometres
                return FromMils(v)

            else:  # Any other floating-point values
                return v

        elif self.units == uBool:
            if v.lower() in self._true:
                return True
            else:
                return False
        else:
            return v

    def DefaultValue(self):  # Reset the value of the parameter to its default
        self.raw_value = str(self.default)

    def SetValue(self, new_value):  # Update the value
        new_value = str(new_value)

        if len(new_value.strip()) == 0:
            if not self.units in [uString, uBool]:
                return  # Ignore empty values unless for strings or bools

        if self.units == uBool:  # Enforce the same boolean representation as is used in KiCad
            new_value = "1" if new_value.lower() in self._true else "0"
        elif self.units in uNumeric:
            new_value = new_value.replace(",", ".")  # Enforce decimal point separators
        elif ',' in self.units:  # Select from a list of values
            if new_value not in self.units.split(','):
                new_value = self.units.split(',')[0]

        self.raw_value = new_value

    def __str__(self):  # pretty-print the parameter

        s = self.name + ": " + str(self.raw_value)

        if self.units in [uMM, uMils, uPercent, uRadians, uDegrees]:
            s += self.units
        elif self.units == uBool:  # Special case for Boolean values
            s = self.name + ": {b}".format(b = "True" if self.value else "False")
        elif self.units == uString:
            s = self.name + ": '" + self.raw_value + "'"

        return s


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

    def defaults(self):
        self.module = None
        self.params = []  # List of added parameters that observes addition order

        self.name = "KiCad FP Wizard"
        self.description = "Undefined Footprint Wizard plugin"
        self.image = ""
        self.buildmessages = ""

    def AddParam(self, page, name, unit, default, **kwarg):

        if self.GetParam(page,name) is not None:  # Param already exists!
            return

        param = FootprintWizardParameter(page, name, unit, default, **kwarg)  # Create a new parameter
        self.params.append(param)

    @property
    def parameters(self):  # This is a helper function that returns a nested (unordered) dict of the VALUES of parameters
        pages = {}  # Page dict
        for p in self.params:
            if p.page not in pages:
                pages[p.page] = {}

            pages[p.page][p.name] = p.value  # Return the 'converted' value (convert from string to actual useful units)

        return pages

    @property
    def values(self):  # Same as above
        return self.parameters

    def ResetWizard(self):  # Reset all parameters to default values
        for p in self.params:
            p.DefaultValue()

    def GetName(self):  # Return the name of this wizard
        return self.name

    def GetImage(self):  # Return the filename of the preview image associated with this wizard
        return self.image

    def GetDescription(self):  # Return the description text
        return self.description

    def GetValue(self):
        raise NotImplementedError

    def GetReferencePrefix(self):
        return "REF"  # Default reference prefix for any footprint

    def GetParam(self, page, name):  # Grab a parameter
        for p in self.params:
            if p.page == page and p.name == name:
                return p

        return None

    def CheckParam(self, page, name, **kwarg):
        self.GetParam(page,name).Check(**kwarg)

    def AnyErrors(self):
        return any([len(p.error_list) > 0 for p in self.params])

    @property
    def pages(self):  # Return an (ordered) list of the available page names
        page_list = []
        for p in self.params:
            if p.page not in page_list:
                page_list.append(p.page)

        return page_list

    def GetNumParameterPages(self):  # Return the number of parameter pages
        return len(self.pages)

    def GetParameterPageName(self,page_n):  # Return the name of a page at a given index
        return self.pages[page_n]

    def GetParametersByPageName(self, page_name):  # Return a list of parameters on a given page
        params = []

        for p in self.params:
            if p.page == page_name:
                params.append(p)

        return params

    def GetParametersByPageIndex(self, page_index):  # Return an ordered list of parameters on a given page
        return self.GetParametersByPageName(self.GetParameterPageName(page_index))

    def GetParameterDesignators(self, page_index):  # Return a list of designators associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [p.designator for p in params]

    def GetParameterNames(self,page_index):  # Return the list of names associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [p.name for p in params]

    def GetParameterValues(self,page_index):  # Return the list of values associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.raw_value) for p in params]

    def GetParameterErrors(self,page_index):  # Return list of errors associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str("\n".join(p.error_list)) for p in params]

    def GetParameterTypes(self, page_index):  # Return list of units associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.units) for p in params]

    def GetParameterHints(self, page_index):  # Return a list of units associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.hint) for p in params]

    def GetParameterDesignators(self, page_index):  # Return a list of designators associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.designator) for p in params]

    def SetParameterValues(self, page_index, list_of_values):  # Update values on a given page

        params = self.GetParametersByPageIndex(page_index)

        for i, param in enumerate(params):
            if i >= len(list_of_values):
                break
            param.SetValue(list_of_values[i])

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

    def BuildFootprint(self):
        return

    def GetBuildMessages( self ):
        return self.buildmessages

    def Show(self):
        text  = "Footprint Wizard Name:        {name}\n".format(name=self.GetName())
        text += "Footprint Wizard Description: {desc}\n".format(desc=self.GetDescription())

        n_pages = self.GetNumParameterPages()

        text += "Pages: {n}\n".format(n=n_pages)

        for i in range(n_pages):
            name = self.GetParameterPageName(i)

            params = self.GetParametersByPageName(name)

            text += "{name}\n".format(name=name)

            for j in range(len(params)):
                text += ("\t{param}{err}\n".format(
                    param = str(params[j]),
                    err = ' *' if len(params[j].error_list) > 0 else ''
                    ))

        if self.AnyErrors():
            text += " * Errors exist for these parameters"

        return text

class ActionPlugin(KiCadPlugin, object):
    def __init__( self ):
        KiCadPlugin.__init__( self )
        self.icon_file_name = ""
        self.show_toolbar_button = False
        self.defaults()

    def defaults( self ):
        self.name = "Undefined Action plugin"
        self.category = "Undefined"
        self.description = ""

    def GetName( self ):
        return self.name

    def GetCategoryName( self ):
        return self.category

    def GetDescription( self ):
        return self.description

    def GetShowToolbarButton( self ):
        return self.show_toolbar_button

    def GetIconFileName( self ):
        return self.icon_file_name

    def Run(self):
        return


SH_RECT = _pcbnew.SH_RECT
SH_SEGMENT = _pcbnew.SH_SEGMENT
SH_LINE_CHAIN = _pcbnew.SH_LINE_CHAIN
SH_CIRCLE = _pcbnew.SH_CIRCLE
SH_SIMPLE = _pcbnew.SH_SIMPLE
SH_POLY_SET = _pcbnew.SH_POLY_SET
SH_COMPOUND = _pcbnew.SH_COMPOUND
SH_ARC = _pcbnew.SH_ARC
class SHAPE(_object):
    """Proxy of C++ SHAPE class."""

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

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

    def Type(self):
        """Type(SHAPE self) -> SHAPE_TYPE"""
        return _pcbnew.SHAPE_Type(self)


    def Clone(self):
        """Clone(SHAPE self) -> SHAPE"""
        return _pcbnew.SHAPE_Clone(self)


    def Collide(self, *args):
        """
        Collide(SHAPE self, VECTOR2I aP, int aClearance=0) -> bool
        Collide(SHAPE self, VECTOR2I aP) -> bool
        Collide(SHAPE self, SHAPE aShape, int aClearance, VECTOR2I aMTV) -> bool
        Collide(SHAPE self, SHAPE aShape, int aClearance=0) -> bool
        Collide(SHAPE self, SHAPE aShape) -> bool
        Collide(SHAPE self, SEG const & aSeg, int aClearance=0) -> bool
        Collide(SHAPE self, SEG const & aSeg) -> bool
        """
        return _pcbnew.SHAPE_Collide(self, *args)


    def BBox(self, aClearance=0):
        """
        BBox(SHAPE self, int aClearance=0) -> BOX2I const
        BBox(SHAPE self) -> BOX2I const
        """
        return _pcbnew.SHAPE_BBox(self, aClearance)


    def Centre(self):
        """Centre(SHAPE self) -> VECTOR2I"""
        return _pcbnew.SHAPE_Centre(self)


    def Move(self, aVector):
        """Move(SHAPE self, VECTOR2I aVector)"""
        return _pcbnew.SHAPE_Move(self, aVector)


    def IsSolid(self):
        """IsSolid(SHAPE self) -> bool"""
        return _pcbnew.SHAPE_IsSolid(self)


    def Parse(self, aStream):
        """Parse(SHAPE self, std::stringstream & aStream) -> bool"""
        return _pcbnew.SHAPE_Parse(self, aStream)


    def Format(self):
        """Format(SHAPE self) -> string"""
        return _pcbnew.SHAPE_Format(self)

SHAPE_swigregister = _pcbnew.SHAPE_swigregister
SHAPE_swigregister(SHAPE)


def CollideShapes(aA, aB, aClearance, aNeedMTV, aMTV):
    """CollideShapes(SHAPE aA, SHAPE aB, int aClearance, bool aNeedMTV, VECTOR2I aMTV) -> bool"""
    return _pcbnew.CollideShapes(aA, aB, aClearance, aNeedMTV, aMTV)
class VECTOR2I(_object):
    """Proxy of C++ VECTOR2<(int)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VECTOR2I, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VECTOR2I, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _pcbnew.VECTOR2I_x_set
    __swig_getmethods__["x"] = _pcbnew.VECTOR2I_x_get
    if _newclass:
        x = _swig_property(_pcbnew.VECTOR2I_x_get, _pcbnew.VECTOR2I_x_set)
    __swig_setmethods__["y"] = _pcbnew.VECTOR2I_y_set
    __swig_getmethods__["y"] = _pcbnew.VECTOR2I_y_get
    if _newclass:
        y = _swig_property(_pcbnew.VECTOR2I_y_get, _pcbnew.VECTOR2I_y_set)

    def __init__(self, *args):
        """
        __init__(VECTOR2<(int)> self) -> VECTOR2I
        __init__(VECTOR2<(int)> self, wxPoint aPoint) -> VECTOR2I
        __init__(VECTOR2<(int)> self, wxSize aSize) -> VECTOR2I
        __init__(VECTOR2<(int)> self, int x, int y) -> VECTOR2I
        """
        this = _pcbnew.new_VECTOR2I(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getWxPoint(self):
        """getWxPoint(VECTOR2I self) -> wxPoint"""
        return _pcbnew.VECTOR2I_getWxPoint(self)


    def EuclideanNorm(self):
        """EuclideanNorm(VECTOR2I self) -> int"""
        return _pcbnew.VECTOR2I_EuclideanNorm(self)


    def SquaredEuclideanNorm(self):
        """SquaredEuclideanNorm(VECTOR2I self) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_SquaredEuclideanNorm(self)


    def Perpendicular(self):
        """Perpendicular(VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR2I_Perpendicular(self)


    def Resize(self, aNewLength):
        """Resize(VECTOR2I self, int aNewLength) -> VECTOR2I"""
        return _pcbnew.VECTOR2I_Resize(self, aNewLength)


    def Angle(self):
        """Angle(VECTOR2I self) -> double"""
        return _pcbnew.VECTOR2I_Angle(self)


    def Rotate(self, aAngle):
        """Rotate(VECTOR2I self, double aAngle) -> VECTOR2I"""
        return _pcbnew.VECTOR2I_Rotate(self, aAngle)


    def Format(self):
        """Format(VECTOR2I self) -> string"""
        return _pcbnew.VECTOR2I_Format(self)


    def Cross(self, aVector):
        """Cross(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_Cross(self, aVector)


    def Dot(self, aVector):
        """Dot(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_Dot(self, aVector)


    def __add__(self, *args):
        """
        __add__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __add__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___add__(self, *args)


    def __iadd__(self, *args):
        """
        __iadd__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __iadd__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___iadd__(self, *args)


    def __sub__(self, *args):
        """
        __sub__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __sub__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___sub__(self, *args)


    def __isub__(self, *args):
        """
        __isub__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __isub__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___isub__(self, *args)


    def __neg__(self):
        """__neg__(VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR2I___neg__(self)


    def __mul__(self, *args):
        """
        __mul__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type
        __mul__(VECTOR2I self, int const & aFactor) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___mul__(self, *args)


    def __truediv__(self, *args):
        return _pcbnew.VECTOR2I___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, aVector):
        """__eq__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___eq__(self, aVector)


    def __ne__(self, aVector):
        """__ne__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___ne__(self, aVector)


    def __lt__(self, aVector):
        """__lt__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___lt__(self, aVector)


    def __le__(self, aVector):
        """__le__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___le__(self, aVector)


    def __gt__(self, aVector):
        """__gt__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___gt__(self, aVector)


    def __ge__(self, aVector):
        """__ge__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___ge__(self, aVector)

    __swig_destroy__ = _pcbnew.delete_VECTOR2I
    __del__ = lambda self: None
VECTOR2I_swigregister = _pcbnew.VECTOR2I_swigregister
VECTOR2I_swigregister(VECTOR2I)

class SHAPE_LINE_CHAIN(SHAPE):
    """Proxy of C++ SHAPE_LINE_CHAIN class."""

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

    def __init__(self, *args):
        """
        __init__(SHAPE_LINE_CHAIN self) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aShape) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, VECTOR2I aA, VECTOR2I aB) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, VECTOR2I aA, VECTOR2I aB, VECTOR2I aC) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, VECTOR2I aA, VECTOR2I aB, VECTOR2I aC, VECTOR2I aD) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, VECTOR2I aV, int aCount) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, ClipperLib::Path const & aPath) -> SHAPE_LINE_CHAIN
        """
        this = _pcbnew.new_SHAPE_LINE_CHAIN(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_SHAPE_LINE_CHAIN
    __del__ = lambda self: None

    def Clone(self):
        """Clone(SHAPE_LINE_CHAIN self) -> SHAPE"""
        return _pcbnew.SHAPE_LINE_CHAIN_Clone(self)


    def Clear(self):
        """Clear(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Clear(self)


    def SetClosed(self, aClosed):
        """SetClosed(SHAPE_LINE_CHAIN self, bool aClosed)"""
        return _pcbnew.SHAPE_LINE_CHAIN_SetClosed(self, aClosed)


    def IsClosed(self):
        """IsClosed(SHAPE_LINE_CHAIN self) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsClosed(self)


    def SegmentCount(self):
        """SegmentCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_SegmentCount(self)


    def PointCount(self):
        """PointCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointCount(self)


    def Segment(self, aIndex):
        """Segment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG"""
        return _pcbnew.SHAPE_LINE_CHAIN_Segment(self, aIndex)


    def CSegment(self, aIndex):
        """CSegment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG const"""
        return _pcbnew.SHAPE_LINE_CHAIN_CSegment(self, aIndex)


    def Point(self, aIndex):
        """Point(SHAPE_LINE_CHAIN self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_Point(self, aIndex)


    def CPoint(self, aIndex):
        """CPoint(SHAPE_LINE_CHAIN self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CPoint(self, aIndex)


    def CPoints(self):
        """CPoints(SHAPE_LINE_CHAIN self) -> std::vector< VECTOR2I,std::allocator< VECTOR2I > > const &"""
        return _pcbnew.SHAPE_LINE_CHAIN_CPoints(self)


    def LastPoint(self):
        """LastPoint(SHAPE_LINE_CHAIN self) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_LastPoint(self)


    def CLastPoint(self):
        """CLastPoint(SHAPE_LINE_CHAIN self) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CLastPoint(self)


    def BBox(self, aClearance=0):
        """
        BBox(SHAPE_LINE_CHAIN self, int aClearance=0) -> BOX2I const
        BBox(SHAPE_LINE_CHAIN self) -> BOX2I const
        """
        return _pcbnew.SHAPE_LINE_CHAIN_BBox(self, aClearance)


    def Collide(self, *args):
        """
        Collide(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aClearance=0) -> bool
        Collide(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> bool
        Collide(SHAPE_LINE_CHAIN self, SEG const & aSeg, int aClearance=0) -> bool
        Collide(SHAPE_LINE_CHAIN self, SEG const & aSeg) -> bool
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Collide(self, *args)


    def Distance(self, aP, aOutlineOnly=False):
        """
        Distance(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aOutlineOnly=False) -> int
        Distance(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Distance(self, aP, aOutlineOnly)


    def Reverse(self):
        """Reverse(SHAPE_LINE_CHAIN self) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Reverse(self)


    def Length(self):
        """Length(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Length(self)


    def Append(self, *args):
        """
        Append(SHAPE_LINE_CHAIN self, int aX, int aY, bool aAllowDuplication=False)
        Append(SHAPE_LINE_CHAIN self, int aX, int aY)
        Append(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aAllowDuplication=False)
        Append(SHAPE_LINE_CHAIN self, VECTOR2I aP)
        Append(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aOtherLine)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Append(self, *args)


    def Insert(self, aVertex, aP):
        """Insert(SHAPE_LINE_CHAIN self, int aVertex, VECTOR2I aP)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Insert(self, aVertex, aP)


    def Replace(self, *args):
        """
        Replace(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex, VECTOR2I aP)
        Replace(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex, SHAPE_LINE_CHAIN aLine)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Replace(self, *args)


    def Remove(self, *args):
        """
        Remove(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex)
        Remove(SHAPE_LINE_CHAIN self, int aIndex)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Remove(self, *args)


    def Split(self, aP):
        """Split(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Split(self, aP)


    def Find(self, aP):
        """Find(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Find(self, aP)


    def FindSegment(self, aP):
        """FindSegment(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_FindSegment(self, aP)


    def Slice(self, aStartIndex, aEndIndex=-1):
        """
        Slice(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex=-1) -> SHAPE_LINE_CHAIN
        Slice(SHAPE_LINE_CHAIN self, int aStartIndex) -> SHAPE_LINE_CHAIN
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Slice(self, aStartIndex, aEndIndex)


    def Intersects(self, aChain):
        """Intersects(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aChain) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_Intersects(self, aChain)


    def Intersect(self, *args):
        """
        Intersect(SHAPE_LINE_CHAIN self, SEG const & aSeg, SHAPE_LINE_CHAIN::INTERSECTIONS & aIp) -> int
        Intersect(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aChain, SHAPE_LINE_CHAIN::INTERSECTIONS & aIp) -> int
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Intersect(self, *args)


    def PathLength(self, aP):
        """PathLength(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PathLength(self, aP)


    def PointInside(self, aP):
        """PointInside(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointInside(self, aP)


    def PointOnEdge(self, aP):
        """PointOnEdge(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointOnEdge(self, aP)


    def EdgeContainingPoint(self, aP):
        """EdgeContainingPoint(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_EdgeContainingPoint(self, aP)


    def CheckClearance(self, aP, aDist):
        """CheckClearance(SHAPE_LINE_CHAIN self, VECTOR2I aP, int const aDist) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_CheckClearance(self, aP, aDist)


    def SelfIntersecting(self):
        """SelfIntersecting(SHAPE_LINE_CHAIN self) -> OPT< SHAPE_LINE_CHAIN::INTERSECTION > const"""
        return _pcbnew.SHAPE_LINE_CHAIN_SelfIntersecting(self)


    def Simplify(self):
        """Simplify(SHAPE_LINE_CHAIN self) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Simplify(self)


    def convertToClipper(self, aRequiredOrientation):
        """convertToClipper(SHAPE_LINE_CHAIN self, bool aRequiredOrientation) -> ClipperLib::Path"""
        return _pcbnew.SHAPE_LINE_CHAIN_convertToClipper(self, aRequiredOrientation)


    def NearestPoint(self, *args):
        """
        NearestPoint(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> VECTOR2I
        NearestPoint(SHAPE_LINE_CHAIN self, SEG const & aSeg, int & dist) -> VECTOR2I
        """
        return _pcbnew.SHAPE_LINE_CHAIN_NearestPoint(self, *args)


    def Format(self):
        """Format(SHAPE_LINE_CHAIN self) -> string"""
        return _pcbnew.SHAPE_LINE_CHAIN_Format(self)


    def Parse(self, aStream):
        """Parse(SHAPE_LINE_CHAIN self, std::stringstream & aStream) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_Parse(self, aStream)


    def __ne__(self, aRhs):
        """__ne__(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aRhs) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN___ne__(self, aRhs)


    def CompareGeometry(self, aOther):
        """CompareGeometry(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aOther) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_CompareGeometry(self, aOther)


    def Move(self, aVector):
        """Move(SHAPE_LINE_CHAIN self, VECTOR2I aVector)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Move(self, aVector)


    def Rotate(self, aAngle, aCenter):
        """Rotate(SHAPE_LINE_CHAIN self, double aAngle, VECTOR2I aCenter)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Rotate(self, aAngle, aCenter)


    def IsSolid(self):
        """IsSolid(SHAPE_LINE_CHAIN self) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsSolid(self)


    def PointAlong(self, aPathLength):
        """PointAlong(SHAPE_LINE_CHAIN self, int aPathLength) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointAlong(self, aPathLength)


    def Area(self):
        """Area(SHAPE_LINE_CHAIN self) -> double"""
        return _pcbnew.SHAPE_LINE_CHAIN_Area(self)

SHAPE_LINE_CHAIN_swigregister = _pcbnew.SHAPE_LINE_CHAIN_swigregister
SHAPE_LINE_CHAIN_swigregister(SHAPE_LINE_CHAIN)

class SHAPE_POLY_SET(SHAPE):
    """Proxy of C++ SHAPE_POLY_SET class."""

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

    def __init__(self, *args):
        """
        __init__(SHAPE_POLY_SET self) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_POLY_SET aOther, bool aDeepCopy=False) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_POLY_SET aOther) -> SHAPE_POLY_SET
        """
        this = _pcbnew.new_SHAPE_POLY_SET(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_SHAPE_POLY_SET
    __del__ = lambda self: None

    def GetRelativeIndices(self, aGlobalIdx, aRelativeIndices):
        """GetRelativeIndices(SHAPE_POLY_SET self, int aGlobalIdx, SHAPE_POLY_SET::VERTEX_INDEX * aRelativeIndices) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_GetRelativeIndices(self, aGlobalIdx, aRelativeIndices)


    def GetGlobalIndex(self, aRelativeIndices, aGlobalIdx):
        """GetGlobalIndex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aRelativeIndices, int & aGlobalIdx) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_GetGlobalIndex(self, aRelativeIndices, aGlobalIdx)


    def Clone(self):
        """Clone(SHAPE_POLY_SET self) -> SHAPE"""
        return _pcbnew.SHAPE_POLY_SET_Clone(self)


    def NewOutline(self):
        """NewOutline(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_NewOutline(self)


    def NewHole(self, aOutline=-1):
        """
        NewHole(SHAPE_POLY_SET self, int aOutline=-1) -> int
        NewHole(SHAPE_POLY_SET self) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_NewHole(self, aOutline)


    def AddOutline(self, aOutline):
        """AddOutline(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aOutline) -> int"""
        return _pcbnew.SHAPE_POLY_SET_AddOutline(self, aOutline)


    def AddHole(self, aHole, aOutline=-1):
        """
        AddHole(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aHole, int aOutline=-1) -> int
        AddHole(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aHole) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_AddHole(self, aHole, aOutline)


    def Append(self, *args):
        """
        Append(SHAPE_POLY_SET self, int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=False) -> int
        Append(SHAPE_POLY_SET self, int x, int y, int aOutline=-1, int aHole=-1) -> int
        Append(SHAPE_POLY_SET self, int x, int y, int aOutline=-1) -> int
        Append(SHAPE_POLY_SET self, int x, int y) -> int
        Append(SHAPE_POLY_SET self, SHAPE_POLY_SET aSet)
        Append(SHAPE_POLY_SET self, VECTOR2I aP, int aOutline=-1, int aHole=-1)
        Append(SHAPE_POLY_SET self, VECTOR2I aP, int aOutline=-1)
        Append(SHAPE_POLY_SET self, VECTOR2I aP)
        """
        return _pcbnew.SHAPE_POLY_SET_Append(self, *args)


    def InsertVertex(self, aGlobalIndex, aNewVertex):
        """InsertVertex(SHAPE_POLY_SET self, int aGlobalIndex, VECTOR2I aNewVertex)"""
        return _pcbnew.SHAPE_POLY_SET_InsertVertex(self, aGlobalIndex, aNewVertex)


    def Vertex(self, *args):
        """
        Vertex(SHAPE_POLY_SET self, int aIndex, int aOutline, int aHole) -> VECTOR2I
        Vertex(SHAPE_POLY_SET self, int aGlobalIndex) -> VECTOR2I
        Vertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aIndex) -> VECTOR2I
        """
        return _pcbnew.SHAPE_POLY_SET_Vertex(self, *args)


    def CVertex(self, *args):
        """
        CVertex(SHAPE_POLY_SET self, int aIndex, int aOutline, int aHole) -> VECTOR2I
        CVertex(SHAPE_POLY_SET self, int aGlobalIndex) -> VECTOR2I
        CVertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aIndex) -> VECTOR2I
        """
        return _pcbnew.SHAPE_POLY_SET_CVertex(self, *args)


    def GetNeighbourIndexes(self, aGlobalIndex, aPrevious, aNext):
        """GetNeighbourIndexes(SHAPE_POLY_SET self, int aGlobalIndex, int * aPrevious, int * aNext) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_GetNeighbourIndexes(self, aGlobalIndex, aPrevious, aNext)


    def IsPolygonSelfIntersecting(self, aPolygonIndex):
        """IsPolygonSelfIntersecting(SHAPE_POLY_SET self, int aPolygonIndex) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsPolygonSelfIntersecting(self, aPolygonIndex)


    def IsSelfIntersecting(self):
        """IsSelfIntersecting(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsSelfIntersecting(self)


    def TriangulatedPolyCount(self):
        """TriangulatedPolyCount(SHAPE_POLY_SET self) -> unsigned int"""
        return _pcbnew.SHAPE_POLY_SET_TriangulatedPolyCount(self)


    def OutlineCount(self):
        """OutlineCount(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_OutlineCount(self)


    def VertexCount(self, aOutline=-1, aHole=-1):
        """
        VertexCount(SHAPE_POLY_SET self, int aOutline=-1, int aHole=-1) -> int
        VertexCount(SHAPE_POLY_SET self, int aOutline=-1) -> int
        VertexCount(SHAPE_POLY_SET self) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_VertexCount(self, aOutline, aHole)


    def HoleCount(self, aOutline):
        """HoleCount(SHAPE_POLY_SET self, int aOutline) -> int"""
        return _pcbnew.SHAPE_POLY_SET_HoleCount(self, aOutline)


    def Outline(self, aIndex):
        """Outline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_Outline(self, aIndex)


    def Subset(self, aFirstPolygon, aLastPolygon):
        """Subset(SHAPE_POLY_SET self, int aFirstPolygon, int aLastPolygon) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_Subset(self, aFirstPolygon, aLastPolygon)


    def UnitSet(self, aPolygonIndex):
        """UnitSet(SHAPE_POLY_SET self, int aPolygonIndex) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_UnitSet(self, aPolygonIndex)


    def Hole(self, aOutline, aHole):
        """Hole(SHAPE_POLY_SET self, int aOutline, int aHole) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_Hole(self, aOutline, aHole)


    def Polygon(self, *args):
        """
        Polygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON
        Polygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON const &
        """
        return _pcbnew.SHAPE_POLY_SET_Polygon(self, *args)


    def TriangulatedPolygon(self, aIndex):
        """TriangulatedPolygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::TRIANGULATED_POLYGON const *"""
        return _pcbnew.SHAPE_POLY_SET_TriangulatedPolygon(self, aIndex)


    def COutline(self, aIndex):
        """COutline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_COutline(self, aIndex)


    def CHole(self, aOutline, aHole):
        """CHole(SHAPE_POLY_SET self, int aOutline, int aHole) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_CHole(self, aOutline, aHole)


    def CPolygon(self, aIndex):
        """CPolygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON const &"""
        return _pcbnew.SHAPE_POLY_SET_CPolygon(self, aIndex)


    def Iterate(self, *args):
        """
        Iterate(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::ITERATOR
        Iterate(SHAPE_POLY_SET self, int aFirst, int aLast) -> SHAPE_POLY_SET::ITERATOR
        Iterate(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::ITERATOR
        Iterate(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_Iterate(self, *args)


    def IterateWithHoles(self, *args):
        """
        IterateWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::ITERATOR
        IterateWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_IterateWithHoles(self, *args)


    def CIterate(self, *args):
        """
        CIterate(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterate(SHAPE_POLY_SET self, int aFirst, int aLast) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterate(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterate(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterate(self, *args)


    def CIterateWithHoles(self, *args):
        """
        CIterateWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterateWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateWithHoles(self, *args)


    def IterateFromVertexWithHoles(self, aGlobalIdx):
        """IterateFromVertexWithHoles(SHAPE_POLY_SET self, int aGlobalIdx) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.SHAPE_POLY_SET_IterateFromVertexWithHoles(self, aGlobalIdx)


    def CIterateSegments(self, *args):
        """
        CIterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        CIterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        CIterateSegments(SHAPE_POLY_SET self, int aPolygonIdx) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateSegments(self, *args)


    def IterateSegments(self, *args):
        """
        IterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegments(SHAPE_POLY_SET self, int aPolygonIdx) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegments(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_IterateSegments(self, *args)


    def IterateSegmentsWithHoles(self, *args):
        """
        IterateSegmentsWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegmentsWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_IterateSegmentsWithHoles(self, *args)


    def CIterateSegmentsWithHoles(self, aOutline):
        """CIterateSegmentsWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR"""
        return _pcbnew.SHAPE_POLY_SET_CIterateSegmentsWithHoles(self, aOutline)

    PM_FAST = _pcbnew.SHAPE_POLY_SET_PM_FAST
    PM_STRICTLY_SIMPLE = _pcbnew.SHAPE_POLY_SET_PM_STRICTLY_SIMPLE

    def BooleanAdd(self, *args):
        """
        BooleanAdd(SHAPE_POLY_SET self, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        BooleanAdd(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanAdd(self, *args)


    def BooleanSubtract(self, *args):
        """
        BooleanSubtract(SHAPE_POLY_SET self, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        BooleanSubtract(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanSubtract(self, *args)


    def BooleanIntersection(self, *args):
        """
        BooleanIntersection(SHAPE_POLY_SET self, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        BooleanIntersection(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanIntersection(self, *args)


    def Inflate(self, *args):
        """
        Inflate(SHAPE_POLY_SET self, int aFactor, int aCircleSegmentsCount, bool aPreseveCorners=False)
        Inflate(SHAPE_POLY_SET self, int aFactor, int aCircleSegmentsCount)
        Inflate(SHAPE_POLY_SET self, int aFactor, bool aPreseveCorners)
        """
        return _pcbnew.SHAPE_POLY_SET_Inflate(self, *args)


    def InflateWithLinkedHoles(self, aFactor, aCircleSegmentsCount, aFastMode):
        """InflateWithLinkedHoles(SHAPE_POLY_SET self, int aFactor, int aCircleSegmentsCount, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_InflateWithLinkedHoles(self, aFactor, aCircleSegmentsCount, aFastMode)


    def Fracture(self, aFastMode):
        """Fracture(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Fracture(self, aFastMode)


    def Unfracture(self, aFastMode):
        """Unfracture(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Unfracture(self, aFastMode)


    def HasHoles(self):
        """HasHoles(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_HasHoles(self)


    def HasTouchingHoles(self):
        """HasTouchingHoles(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_HasTouchingHoles(self)


    def Simplify(self, aFastMode):
        """Simplify(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Simplify(self, aFastMode)


    def NormalizeAreaOutlines(self):
        """NormalizeAreaOutlines(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_NormalizeAreaOutlines(self)


    def Format(self):
        """Format(SHAPE_POLY_SET self) -> string"""
        return _pcbnew.SHAPE_POLY_SET_Format(self)


    def Parse(self, aStream):
        """Parse(SHAPE_POLY_SET self, std::stringstream & aStream) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_Parse(self, aStream)


    def Move(self, aVector):
        """Move(SHAPE_POLY_SET self, VECTOR2I aVector)"""
        return _pcbnew.SHAPE_POLY_SET_Move(self, aVector)


    def Rotate(self, aAngle, aCenter):
        """Rotate(SHAPE_POLY_SET self, double aAngle, VECTOR2I aCenter)"""
        return _pcbnew.SHAPE_POLY_SET_Rotate(self, aAngle, aCenter)


    def IsSolid(self):
        """IsSolid(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsSolid(self)


    def BBox(self, aClearance=0):
        """
        BBox(SHAPE_POLY_SET self, int aClearance=0) -> BOX2I const
        BBox(SHAPE_POLY_SET self) -> BOX2I const
        """
        return _pcbnew.SHAPE_POLY_SET_BBox(self, aClearance)


    def PointOnEdge(self, aP):
        """PointOnEdge(SHAPE_POLY_SET self, VECTOR2I aP) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_PointOnEdge(self, aP)


    def Collide(self, *args):
        """
        Collide(SHAPE_POLY_SET self, VECTOR2I aP, int aClearance=0) -> bool
        Collide(SHAPE_POLY_SET self, VECTOR2I aP) -> bool
        Collide(SHAPE_POLY_SET self, SEG const & aSeg, int aClearance=0) -> bool
        Collide(SHAPE_POLY_SET self, SEG const & aSeg) -> bool
        """
        return _pcbnew.SHAPE_POLY_SET_Collide(self, *args)


    def CollideVertex(self, aPoint, aClosestVertex, aClearance=0):
        """
        CollideVertex(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX & aClosestVertex, int aClearance=0) -> bool
        CollideVertex(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX & aClosestVertex) -> bool
        """
        return _pcbnew.SHAPE_POLY_SET_CollideVertex(self, aPoint, aClosestVertex, aClearance)


    def CollideEdge(self, aPoint, aClosestVertex, aClearance=0):
        """
        CollideEdge(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX & aClosestVertex, int aClearance=0) -> bool
        CollideEdge(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX & aClosestVertex) -> bool
        """
        return _pcbnew.SHAPE_POLY_SET_CollideEdge(self, aPoint, aClosestVertex, aClearance)


    def Contains(self, aP, aSubpolyIndex=-1, aIgnoreHoles=False):
        """
        Contains(SHAPE_POLY_SET self, VECTOR2I aP, int aSubpolyIndex=-1, bool aIgnoreHoles=False) -> bool
        Contains(SHAPE_POLY_SET self, VECTOR2I aP, int aSubpolyIndex=-1) -> bool
        Contains(SHAPE_POLY_SET self, VECTOR2I aP) -> bool
        """
        return _pcbnew.SHAPE_POLY_SET_Contains(self, aP, aSubpolyIndex, aIgnoreHoles)


    def IsEmpty(self):
        """IsEmpty(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsEmpty(self)


    def RemoveVertex(self, *args):
        """
        RemoveVertex(SHAPE_POLY_SET self, int aGlobalIndex)
        RemoveVertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aRelativeIndices)
        """
        return _pcbnew.SHAPE_POLY_SET_RemoveVertex(self, *args)


    def RemoveAllContours(self):
        """RemoveAllContours(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_RemoveAllContours(self)


    def RemoveContour(self, aContourIdx, aPolygonIdx=-1):
        """
        RemoveContour(SHAPE_POLY_SET self, int aContourIdx, int aPolygonIdx=-1)
        RemoveContour(SHAPE_POLY_SET self, int aContourIdx)
        """
        return _pcbnew.SHAPE_POLY_SET_RemoveContour(self, aContourIdx, aPolygonIdx)


    def RemoveNullSegments(self):
        """RemoveNullSegments(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_RemoveNullSegments(self)


    def TotalVertices(self):
        """TotalVertices(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_TotalVertices(self)


    def DeletePolygon(self, aIdx):
        """DeletePolygon(SHAPE_POLY_SET self, int aIdx)"""
        return _pcbnew.SHAPE_POLY_SET_DeletePolygon(self, aIdx)


    def ChamferPolygon(self, aDistance, aIndex=0):
        """
        ChamferPolygon(SHAPE_POLY_SET self, unsigned int aDistance, int aIndex=0) -> SHAPE_POLY_SET::POLYGON
        ChamferPolygon(SHAPE_POLY_SET self, unsigned int aDistance) -> SHAPE_POLY_SET::POLYGON
        """
        return _pcbnew.SHAPE_POLY_SET_ChamferPolygon(self, aDistance, aIndex)


    def FilletPolygon(self, aRadius, aErrorMax, aIndex=0):
        """
        FilletPolygon(SHAPE_POLY_SET self, unsigned int aRadius, int aErrorMax, int aIndex=0) -> SHAPE_POLY_SET::POLYGON
        FilletPolygon(SHAPE_POLY_SET self, unsigned int aRadius, int aErrorMax) -> SHAPE_POLY_SET::POLYGON
        """
        return _pcbnew.SHAPE_POLY_SET_FilletPolygon(self, aRadius, aErrorMax, aIndex)


    def Chamfer(self, aDistance):
        """Chamfer(SHAPE_POLY_SET self, int aDistance) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_Chamfer(self, aDistance)


    def Fillet(self, aRadius, aErrorMax):
        """Fillet(SHAPE_POLY_SET self, int aRadius, int aErrorMax) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_Fillet(self, aRadius, aErrorMax)


    def DistanceToPolygon(self, *args):
        """
        DistanceToPolygon(SHAPE_POLY_SET self, VECTOR2I aPoint, int aIndex) -> int
        DistanceToPolygon(SHAPE_POLY_SET self, SEG aSegment, int aIndex, int aSegmentWidth=0) -> int
        DistanceToPolygon(SHAPE_POLY_SET self, SEG aSegment, int aIndex) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_DistanceToPolygon(self, *args)


    def Distance(self, *args):
        """
        Distance(SHAPE_POLY_SET self, VECTOR2I aPoint) -> int
        Distance(SHAPE_POLY_SET self, SEG const & aSegment, int aSegmentWidth=0) -> int
        Distance(SHAPE_POLY_SET self, SEG const & aSegment) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_Distance(self, *args)


    def IsVertexInHole(self, aGlobalIdx):
        """IsVertexInHole(SHAPE_POLY_SET self, int aGlobalIdx) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsVertexInHole(self, aGlobalIdx)


    def CacheTriangulation(self):
        """CacheTriangulation(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_CacheTriangulation(self)


    def IsTriangulationUpToDate(self):
        """IsTriangulationUpToDate(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsTriangulationUpToDate(self)


    def GetHash(self):
        """GetHash(SHAPE_POLY_SET self) -> MD5_HASH"""
        return _pcbnew.SHAPE_POLY_SET_GetHash(self)

SHAPE_POLY_SET_swigregister = _pcbnew.SHAPE_POLY_SET_swigregister
SHAPE_POLY_SET_swigregister(SHAPE_POLY_SET)


def IsUTF8(aString):
    """IsUTF8(char const * aString) -> bool"""
    return _pcbnew.IsUTF8(aString)
class UTF8(_object):
    """Proxy of C++ UTF8 class."""

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

    def __init__(self, *args):
        """
        __init__(UTF8 self, wxString 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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_UTF8
    __del__ = lambda self: None

    def c_str(self):
        """c_str(UTF8 self) -> char const *"""
        return _pcbnew.UTF8_c_str(self)


    def empty(self):
        """empty(UTF8 self) -> bool"""
        return _pcbnew.UTF8_empty(self)


    def find(self, *args):
        """
        find(UTF8 self, char c) -> std::string::size_type
        find(UTF8 self, char c, size_t & s) -> std::string::size_type
        """
        return _pcbnew.UTF8_find(self, *args)


    def clear(self):
        """clear(UTF8 self)"""
        return _pcbnew.UTF8_clear(self)


    def length(self):
        """length(UTF8 self) -> std::string::size_type"""
        return _pcbnew.UTF8_length(self)


    def size(self):
        """size(UTF8 self) -> std::string::size_type"""
        return _pcbnew.UTF8_size(self)


    def compare(self, s):
        """compare(UTF8 self, string s) -> int"""
        return _pcbnew.UTF8_compare(self, s)


    def __eq__(self, *args):
        """
        __eq__(UTF8 self, UTF8 rhs) -> bool
        __eq__(UTF8 self, string rhs) -> bool
        __eq__(UTF8 self, char const * s) -> bool
        """
        return _pcbnew.UTF8___eq__(self, *args)


    def find_first_of(self, str, pos=0):
        """
        find_first_of(UTF8 self, string str, std::string::size_type pos=0) -> std::string::size_type
        find_first_of(UTF8 self, string str) -> std::string::size_type
        """
        return _pcbnew.UTF8_find_first_of(self, str, pos)


    def __iadd__(self, *args):
        """
        __iadd__(UTF8 self, UTF8 str) -> UTF8
        __iadd__(UTF8 self, char ch) -> UTF8
        __iadd__(UTF8 self, char const * s) -> UTF8
        __iadd__(UTF8 self, unsigned int w_ch) -> UTF8
        """
        return _pcbnew.UTF8___iadd__(self, *args)

    npos = _pcbnew.UTF8_npos

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


    def utf8_to_string(self):
        """utf8_to_string(UTF8 self) -> string"""
        return _pcbnew.UTF8_utf8_to_string(self)


    def wx_str(self):
        """wx_str(UTF8 self) -> wxString"""
        return _pcbnew.UTF8_wx_str(self)


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


    def begin(self):
        """begin(UTF8 self) -> std::string::const_iterator"""
        return _pcbnew.UTF8_begin(self)


    def end(self):
        """end(UTF8 self) -> std::string::const_iterator"""
        return _pcbnew.UTF8_end(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 Mils2iu(mils):
    """Mils2iu(int mils) -> int"""
    return _pcbnew.Mils2iu(mils)

def Millimeter2iu(mm):
    """Millimeter2iu(double mm) -> int"""
    return _pcbnew.Millimeter2iu(mm)

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

def Iu2Mils(iu):
    """Iu2Mils(int iu) -> double"""
    return _pcbnew.Iu2Mils(iu)
class LIB_ID(_object):
    """Proxy of C++ LIB_ID class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LIB_ID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LIB_ID, name)
    __repr__ = _swig_repr
    ID_SCH = _pcbnew.LIB_ID_ID_SCH
    ID_PCB = _pcbnew.LIB_ID_ID_PCB

    def __init__(self, *args):
        """
        __init__(LIB_ID self) -> LIB_ID
        __init__(LIB_ID self, wxString aLibName, wxString aLibItemName, wxString aRevision) -> LIB_ID
        __init__(LIB_ID self, wxString aLibName, wxString aLibItemName) -> LIB_ID
        """
        this = _pcbnew.new_LIB_ID(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Parse(self, aId, aType, aFix=False):
        """
        Parse(LIB_ID self, UTF8 aId, LIB_ID::LIB_ID_TYPE aType, bool aFix=False) -> int
        Parse(LIB_ID self, UTF8 aId, LIB_ID::LIB_ID_TYPE aType) -> int
        """
        return _pcbnew.LIB_ID_Parse(self, aId, aType, aFix)


    def GetLibNickname(self):
        """GetLibNickname(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetLibNickname(self)


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


    def GetLibItemName(self):
        """GetLibItemName(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetLibItemName(self)


    def GetUniStringLibItemName(self):
        """GetUniStringLibItemName(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetUniStringLibItemName(self)


    def SetLibItemName(self, aLibItemName, aTestForRev=True):
        """
        SetLibItemName(LIB_ID self, UTF8 aLibItemName, bool aTestForRev=True) -> int
        SetLibItemName(LIB_ID self, UTF8 aLibItemName) -> int
        """
        return _pcbnew.LIB_ID_SetLibItemName(self, aLibItemName, aTestForRev)


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


    def GetRevision(self):
        """GetRevision(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetRevision(self)


    def GetLibItemNameAndRev(self):
        """GetLibItemNameAndRev(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetLibItemNameAndRev(self)


    def GetUniStringLibId(self):
        """GetUniStringLibId(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetUniStringLibId(self)


    def Format(*args):
        """
        Format() -> UTF8
        Format(UTF8 aLibNickname, UTF8 aLibItemName, UTF8 aRevision) -> UTF8
        Format(UTF8 aLibNickname, UTF8 aLibItemName) -> UTF8
        """
        return _pcbnew.LIB_ID_Format(*args)

    Format = staticmethod(Format)

    def IsValid(self):
        """IsValid(LIB_ID self) -> bool"""
        return _pcbnew.LIB_ID_IsValid(self)


    def IsLegacy(self):
        """IsLegacy(LIB_ID self) -> bool"""
        return _pcbnew.LIB_ID_IsLegacy(self)


    def clear(self):
        """clear(LIB_ID self)"""
        return _pcbnew.LIB_ID_clear(self)


    def empty(self):
        """empty(LIB_ID self) -> bool"""
        return _pcbnew.LIB_ID_empty(self)


    def compare(self, aLibId):
        """compare(LIB_ID self, LIB_ID aLibId) -> int"""
        return _pcbnew.LIB_ID_compare(self, aLibId)


    def __lt__(self, aLibId):
        """__lt__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___lt__(self, aLibId)


    def __gt__(self, aLibId):
        """__gt__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___gt__(self, aLibId)


    def __eq__(self, aLibId):
        """__eq__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___eq__(self, aLibId)


    def __ne__(self, aLibId):
        """__ne__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___ne__(self, aLibId)


    def HasIllegalChars(aLibItemName, aType):
        """HasIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType) -> int"""
        return _pcbnew.LIB_ID_HasIllegalChars(aLibItemName, aType)

    HasIllegalChars = staticmethod(HasIllegalChars)

    def FixIllegalChars(aLibItemName, aType, aLib=False):
        """
        FixIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType, bool aLib=False) -> UTF8
        FixIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType) -> UTF8
        """
        return _pcbnew.LIB_ID_FixIllegalChars(aLibItemName, aType, aLib)

    FixIllegalChars = staticmethod(FixIllegalChars)

    def FindIllegalLibNicknameChar(aNickname, aType):
        """FindIllegalLibNicknameChar(UTF8 aNickname, LIB_ID::LIB_ID_TYPE aType) -> unsigned int"""
        return _pcbnew.LIB_ID_FindIllegalLibNicknameChar(aNickname, aType)

    FindIllegalLibNicknameChar = staticmethod(FindIllegalLibNicknameChar)
    __swig_destroy__ = _pcbnew.delete_LIB_ID
    __del__ = lambda self: None
LIB_ID_swigregister = _pcbnew.LIB_ID_swigregister
LIB_ID_swigregister(LIB_ID)
IU_PER_MM = cvar.IU_PER_MM
IU_PER_MILS = cvar.IU_PER_MILS
MM_PER_IU = cvar.MM_PER_IU
ARC_LOW_DEF = cvar.ARC_LOW_DEF
ARC_HIGH_DEF = cvar.ARC_HIGH_DEF

def LIB_ID_Format(*args):
    """
    Format() -> UTF8
    Format(UTF8 aLibNickname, UTF8 aLibItemName, UTF8 aRevision) -> UTF8
    LIB_ID_Format(UTF8 aLibNickname, UTF8 aLibItemName) -> UTF8
    """
    return _pcbnew.LIB_ID_Format(*args)

def LIB_ID_HasIllegalChars(aLibItemName, aType):
    """LIB_ID_HasIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType) -> int"""
    return _pcbnew.LIB_ID_HasIllegalChars(aLibItemName, aType)

def LIB_ID_FixIllegalChars(aLibItemName, aType, aLib=False):
    """
    FixIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType, bool aLib=False) -> UTF8
    LIB_ID_FixIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType) -> UTF8
    """
    return _pcbnew.LIB_ID_FixIllegalChars(aLibItemName, aType, aLib)

def LIB_ID_FindIllegalLibNicknameChar(aNickname, aType):
    """LIB_ID_FindIllegalLibNicknameChar(UTF8 aNickname, LIB_ID::LIB_ID_TYPE aType) -> unsigned int"""
    return _pcbnew.LIB_ID_FindIllegalLibNicknameChar(aNickname, aType)

class BASE_SET(_object):
    """Proxy of C++ BASE_SET class."""

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

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

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_SEXP = _pcbnew.IO_MGR_KICAD_SEXP
    EAGLE = _pcbnew.IO_MGR_EAGLE
    PCAD = _pcbnew.IO_MGR_PCAD
    GEDA_PCB = _pcbnew.IO_MGR_GEDA_PCB
    FILE_TYPE_NONE = _pcbnew.IO_MGR_FILE_TYPE_NONE

    def PluginFind(aFileType):
        """PluginFind(IO_MGR::PCB_FILE_T aFileType) -> PLUGIN"""
        return _pcbnew.IO_MGR_PluginFind(aFileType)

    PluginFind = staticmethod(PluginFind)

    def PluginRelease(aPlugin):
        """PluginRelease(PLUGIN aPlugin)"""
        return _pcbnew.IO_MGR_PluginRelease(aPlugin)

    PluginRelease = staticmethod(PluginRelease)

    def ShowType(aFileType):
        """ShowType(IO_MGR::PCB_FILE_T aFileType) -> wxString"""
        return _pcbnew.IO_MGR_ShowType(aFileType)

    ShowType = staticmethod(ShowType)

    def EnumFromStr(aFileType):
        """EnumFromStr(wxString aFileType) -> IO_MGR::PCB_FILE_T"""
        return _pcbnew.IO_MGR_EnumFromStr(aFileType)

    EnumFromStr = staticmethod(EnumFromStr)

    def GetFileExtension(aFileType):
        """GetFileExtension(IO_MGR::PCB_FILE_T aFileType) -> wxString"""
        return _pcbnew.IO_MGR_GetFileExtension(aFileType)

    GetFileExtension = staticmethod(GetFileExtension)

    def GuessPluginTypeFromLibPath(aLibPath):
        """GuessPluginTypeFromLibPath(wxString aLibPath) -> IO_MGR::PCB_FILE_T"""
        return _pcbnew.IO_MGR_GuessPluginTypeFromLibPath(aLibPath)

    GuessPluginTypeFromLibPath = staticmethod(GuessPluginTypeFromLibPath)

    def Load(aFileType, aFileName, aAppendToMe=None, aProperties=None):
        """
        Load(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aAppendToMe=None, PROPERTIES const * aProperties=None) -> BOARD
        Load(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aAppendToMe=None) -> BOARD
        Load(IO_MGR::PCB_FILE_T aFileType, wxString aFileName) -> BOARD
        """
        return _pcbnew.IO_MGR_Load(aFileType, aFileName, aAppendToMe, aProperties)

    Load = staticmethod(Load)

    def Save(aFileType, aFileName, aBoard, aProperties=None):
        """
        Save(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)
        Save(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aBoard)
        """
        return _pcbnew.IO_MGR_Save(aFileType, aFileName, aBoard, aProperties)

    Save = staticmethod(Save)

    def __init__(self):
        """__init__(IO_MGR self) -> IO_MGR"""
        this = _pcbnew.new_IO_MGR()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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"""
    return _pcbnew.IO_MGR_ShowType(aFileType)

def IO_MGR_EnumFromStr(aFileType):
    """IO_MGR_EnumFromStr(wxString 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"""
    return _pcbnew.IO_MGR_GetFileExtension(aFileType)

def IO_MGR_GuessPluginTypeFromLibPath(aLibPath):
    """IO_MGR_GuessPluginTypeFromLibPath(wxString 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 aFileName, BOARD aAppendToMe=None, PROPERTIES const * aProperties=None) -> BOARD
    Load(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aAppendToMe=None) -> BOARD
    IO_MGR_Load(IO_MGR::PCB_FILE_T aFileType, wxString 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 aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)
    IO_MGR_Save(IO_MGR::PCB_FILE_T aFileType, wxString 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"""
        return _pcbnew.PLUGIN_PluginName(self)


    def GetFileExtension(self):
        """GetFileExtension(PLUGIN self) -> wxString"""
        return _pcbnew.PLUGIN_GetFileExtension(self)


    def Load(self, aFileName, aAppendToMe, aProperties=None):
        """
        Load(PLUGIN self, wxString aFileName, BOARD aAppendToMe, PROPERTIES const * aProperties=None) -> BOARD
        Load(PLUGIN self, wxString aFileName, BOARD aAppendToMe) -> BOARD
        """
        return _pcbnew.PLUGIN_Load(self, aFileName, aAppendToMe, aProperties)


    def Save(self, aFileName, aBoard, aProperties=None):
        """
        Save(PLUGIN self, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)
        Save(PLUGIN self, wxString aFileName, BOARD aBoard)
        """
        return _pcbnew.PLUGIN_Save(self, aFileName, aBoard, aProperties)


    def FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties=None):
        """
        FootprintEnumerate(PLUGIN self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts, PROPERTIES const * aProperties=None)
        FootprintEnumerate(PLUGIN self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts)
        """
        return _pcbnew.PLUGIN_FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties)


    def GetLibraryTimestamp(self, aLibraryPath):
        """GetLibraryTimestamp(PLUGIN self, wxString aLibraryPath) -> long long"""
        return _pcbnew.PLUGIN_GetLibraryTimestamp(self, aLibraryPath)


    def PrefetchLib(self, aLibraryPath, aProperties=None):
        """
        PrefetchLib(PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None)
        PrefetchLib(PLUGIN self, wxString aLibraryPath)
        """
        return _pcbnew.PLUGIN_PrefetchLib(self, aLibraryPath, aProperties)


    def FootprintLoad(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintLoad(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> MODULE
        FootprintLoad(PLUGIN self, wxString aLibraryPath, wxString aFootprintName) -> MODULE
        """
        return _pcbnew.PLUGIN_FootprintLoad(self, aLibraryPath, aFootprintName, aProperties)


    def GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        GetEnumeratedFootprint(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> MODULE
        GetEnumeratedFootprint(PLUGIN self, wxString aLibraryPath, wxString aFootprintName) -> MODULE
        """
        return _pcbnew.PLUGIN_GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintExists(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintExists(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> bool
        FootprintExists(PLUGIN self, wxString aLibraryPath, wxString aFootprintName) -> bool
        """
        return _pcbnew.PLUGIN_FootprintExists(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintSave(self, aLibraryPath, aFootprint, aProperties=None):
        """
        FootprintSave(PLUGIN self, wxString aLibraryPath, MODULE aFootprint, PROPERTIES const * aProperties=None)
        FootprintSave(PLUGIN self, wxString aLibraryPath, MODULE aFootprint)
        """
        return _pcbnew.PLUGIN_FootprintSave(self, aLibraryPath, aFootprint, aProperties)


    def FootprintDelete(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintDelete(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None)
        FootprintDelete(PLUGIN self, wxString aLibraryPath, wxString aFootprintName)
        """
        return _pcbnew.PLUGIN_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintLibCreate(self, aLibraryPath, aProperties=None):
        """
        FootprintLibCreate(PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None)
        FootprintLibCreate(PLUGIN self, wxString aLibraryPath)
        """
        return _pcbnew.PLUGIN_FootprintLibCreate(self, aLibraryPath, aProperties)


    def FootprintLibDelete(self, aLibraryPath, aProperties=None):
        """
        FootprintLibDelete(PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None) -> bool
        FootprintLibDelete(PLUGIN self, wxString aLibraryPath) -> bool
        """
        return _pcbnew.PLUGIN_FootprintLibDelete(self, aLibraryPath, aProperties)


    def IsFootprintLibWritable(self, aLibraryPath):
        """IsFootprintLibWritable(PLUGIN self, wxString 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

    def footprintPyEnumerate(self, aLibraryPath, aExitOnError):
        """footprintPyEnumerate(PLUGIN self, wxString aLibraryPath, bool aExitOnError) -> wxArrayString"""
        return _pcbnew.PLUGIN_footprintPyEnumerate(self, aLibraryPath, aExitOnError)


    def FootprintEnumerate(self, libname):
        return self.footprintPyEnumerate( libname, True )

PLUGIN_swigregister = _pcbnew.PLUGIN_swigregister
PLUGIN_swigregister(PLUGIN)

SEXPR_BOARD_FILE_VERSION = _pcbnew.SEXPR_BOARD_FILE_VERSION
CTL_STD_LAYER_NAMES = _pcbnew.CTL_STD_LAYER_NAMES
CTL_OMIT_NETS = _pcbnew.CTL_OMIT_NETS
CTL_OMIT_TSTAMPS = _pcbnew.CTL_OMIT_TSTAMPS
CTL_OMIT_INITIAL_COMMENTS = _pcbnew.CTL_OMIT_INITIAL_COMMENTS
CTL_OMIT_PATH = _pcbnew.CTL_OMIT_PATH
CTL_OMIT_AT = _pcbnew.CTL_OMIT_AT
CTL_FOR_CLIPBOARD = _pcbnew.CTL_FOR_CLIPBOARD
CTL_FOR_LIBRARY = _pcbnew.CTL_FOR_LIBRARY
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"""
        return _pcbnew.PCB_IO_PluginName(self)


    def GetFileExtension(self):
        """GetFileExtension(PCB_IO self) -> wxString"""
        return _pcbnew.PCB_IO_GetFileExtension(self)


    def Save(self, aFileName, aBoard, aProperties=None):
        """
        Save(PCB_IO self, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)
        Save(PCB_IO self, wxString aFileName, BOARD aBoard)
        """
        return _pcbnew.PCB_IO_Save(self, aFileName, aBoard, aProperties)


    def Load(self, aFileName, aAppendToMe, aProperties=None):
        """
        Load(PCB_IO self, wxString aFileName, BOARD aAppendToMe, PROPERTIES const * aProperties=None) -> BOARD
        Load(PCB_IO self, wxString aFileName, BOARD aAppendToMe) -> BOARD
        """
        return _pcbnew.PCB_IO_Load(self, aFileName, aAppendToMe, aProperties)


    def FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties=None):
        """
        FootprintEnumerate(PCB_IO self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts, PROPERTIES const * aProperties=None)
        FootprintEnumerate(PCB_IO self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts)
        """
        return _pcbnew.PCB_IO_FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties)


    def GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        GetEnumeratedFootprint(PCB_IO self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> MODULE
        GetEnumeratedFootprint(PCB_IO self, wxString aLibraryPath, wxString aFootprintName) -> MODULE
        """
        return _pcbnew.PCB_IO_GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintExists(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintExists(PCB_IO self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> bool
        FootprintExists(PCB_IO self, wxString aLibraryPath, wxString aFootprintName) -> bool
        """
        return _pcbnew.PCB_IO_FootprintExists(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintLoad(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintLoad(PCB_IO self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> MODULE
        FootprintLoad(PCB_IO self, wxString aLibraryPath, wxString aFootprintName) -> MODULE
        """
        return _pcbnew.PCB_IO_FootprintLoad(self, aLibraryPath, aFootprintName, aProperties)


    def FootprintSave(self, aLibraryPath, aFootprint, aProperties=None):
        """
        FootprintSave(PCB_IO self, wxString aLibraryPath, MODULE aFootprint, PROPERTIES const * aProperties=None)
        FootprintSave(PCB_IO self, wxString aLibraryPath, MODULE aFootprint)
        """
        return _pcbnew.PCB_IO_FootprintSave(self, aLibraryPath, aFootprint, aProperties)


    def FootprintDelete(self, aLibraryPath, aFootprintName, aProperties=None):
        """
        FootprintDelete(PCB_IO self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None)
        FootprintDelete(PCB_IO self, wxString aLibraryPath, wxString aFootprintName)
        """
        return _pcbnew.PCB_IO_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)


    def GetLibraryTimestamp(self, aLibraryPath):
        """GetLibraryTimestamp(PCB_IO self, wxString aLibraryPath) -> long long"""
        return _pcbnew.PCB_IO_GetLibraryTimestamp(self, aLibraryPath)


    def FootprintLibCreate(self, aLibraryPath, aProperties=None):
        """
        FootprintLibCreate(PCB_IO self, wxString aLibraryPath, PROPERTIES const * aProperties=None)
        FootprintLibCreate(PCB_IO self, wxString aLibraryPath)
        """
        return _pcbnew.PCB_IO_FootprintLibCreate(self, aLibraryPath, aProperties)


    def FootprintLibDelete(self, aLibraryPath, aProperties=None):
        """
        FootprintLibDelete(PCB_IO self, wxString aLibraryPath, PROPERTIES const * aProperties=None) -> bool
        FootprintLibDelete(PCB_IO self, wxString aLibraryPath) -> bool
        """
        return _pcbnew.PCB_IO_FootprintLibDelete(self, aLibraryPath, aProperties)


    def IsFootprintLibWritable(self, aLibraryPath):
        """IsFootprintLibWritable(PCB_IO self, wxString 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 __builtin__.Exception:
            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 aClipboardSourceInput) -> BOARD_ITEM"""
        return _pcbnew.PCB_IO_Parse(self, aClipboardSourceInput)

PCB_IO_swigregister = _pcbnew.PCB_IO_swigregister
PCB_IO_swigregister(PCB_IO)

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 __builtin__.Exception:
            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 aSuffix, PlotFormat aFormat, wxString 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 GetPlotFileName(self):
        """GetPlotFileName(PLOT_CONTROLLER self) -> wxString"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotFileName(self)


    def GetPlotDirName(self):
        """GetPlotDirName(PLOT_CONTROLLER self) -> wxString"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotDirName(self)


    def SetColorMode(self, arg2):
        """SetColorMode(PLOT_CONTROLLER self, bool arg2)"""
        return _pcbnew.PLOT_CONTROLLER_SetColorMode(self, arg2)


    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 __builtin__.Exception:
            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 IsSameAs(self, aPcbPlotParams, aCompareOnlySavedPrms):
        """IsSameAs(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams, bool aCompareOnlySavedPrms) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_IsSameAs(self, aPcbPlotParams, aCompareOnlySavedPrms)


    def SetColor(self, aVal):
        """SetColor(PCB_PLOT_PARAMS self, COLOR4D aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetColor(self, aVal)


    def GetColor(self):
        """GetColor(PCB_PLOT_PARAMS self) -> COLOR4D"""
        return _pcbnew.PCB_PLOT_PARAMS_GetColor(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 SetDXFPlotPolygonMode(self, aFlag):
        """SetDXFPlotPolygonMode(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDXFPlotPolygonMode(self, aFlag)


    def GetDXFPlotPolygonMode(self):
        """GetDXFPlotPolygonMode(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDXFPlotPolygonMode(self)


    def SetDXFPlotUnits(self, aUnit):
        """SetDXFPlotUnits(PCB_PLOT_PARAMS self, DXF_PLOTTER::DXF_UNITS aUnit)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDXFPlotUnits(self, aUnit)


    def GetDXFPlotUnits(self):
        """GetDXFPlotUnits(PCB_PLOT_PARAMS self) -> DXF_PLOTTER::DXF_UNITS"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDXFPlotUnits(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 SetUseGerberX2format(self, aUse):
        """SetUseGerberX2format(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberX2format(self, aUse)


    def GetUseGerberX2format(self):
        """GetUseGerberX2format(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberX2format(self)


    def SetIncludeGerberNetlistInfo(self, aUse):
        """SetIncludeGerberNetlistInfo(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetIncludeGerberNetlistInfo(self, aUse)


    def GetIncludeGerberNetlistInfo(self):
        """GetIncludeGerberNetlistInfo(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetIncludeGerberNetlistInfo(self)


    def SetCreateGerberJobFile(self, aCreate):
        """SetCreateGerberJobFile(PCB_PLOT_PARAMS self, bool aCreate)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetCreateGerberJobFile(self, aCreate)


    def GetCreateGerberJobFile(self):
        """GetCreateGerberJobFile(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetCreateGerberJobFile(self)


    def SetUseGerberProtelExtensions(self, aUse):
        """SetUseGerberProtelExtensions(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberProtelExtensions(self, aUse)


    def GetUseGerberProtelExtensions(self):
        """GetUseGerberProtelExtensions(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberProtelExtensions(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()

    GetGerberDefaultPrecision = staticmethod(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) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenDiameter(self)


    def SetHPGLPenDiameter(self, aValue):
        """SetHPGLPenDiameter(PCB_PLOT_PARAMS self, double 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 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)


        # add SetUseGerberAttributes() for compatibility with old python scripts
        # after renaming it to SetUseGerberX2format()
    def SetUseGerberAttributes( self, aUse ):
        return self.SetUseGerberX2format( aUse )

    __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()

PLOT_FORMAT_UNDEFINED = _pcbnew.PLOT_FORMAT_UNDEFINED
PLOT_FIRST_FORMAT = _pcbnew.PLOT_FIRST_FORMAT
PLOT_FORMAT_HPGL = _pcbnew.PLOT_FORMAT_HPGL
PLOT_FORMAT_GERBER = _pcbnew.PLOT_FORMAT_GERBER
PLOT_FORMAT_POST = _pcbnew.PLOT_FORMAT_POST
PLOT_FORMAT_DXF = _pcbnew.PLOT_FORMAT_DXF
PLOT_FORMAT_PDF = _pcbnew.PLOT_FORMAT_PDF
PLOT_FORMAT_SVG = _pcbnew.PLOT_FORMAT_SVG
PLOT_LAST_FORMAT = _pcbnew.PLOT_LAST_FORMAT
PLOTTEXTMODE_STROKE = _pcbnew.PLOTTEXTMODE_STROKE
PLOTTEXTMODE_NATIVE = _pcbnew.PLOTTEXTMODE_NATIVE
PLOTTEXTMODE_PHANTOM = _pcbnew.PLOTTEXTMODE_PHANTOM
PLOTTEXTMODE_DEFAULT = _pcbnew.PLOTTEXTMODE_DEFAULT
PLOTDASHTYPE_SOLID = _pcbnew.PLOTDASHTYPE_SOLID
PLOTDASHTYPE_DASH = _pcbnew.PLOTDASHTYPE_DASH
PLOTDASHTYPE_DOT = _pcbnew.PLOTDASHTYPE_DOT
PLOTDASHTYPE_DASHDOT = _pcbnew.PLOTDASHTYPE_DASHDOT
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
    DO_NOT_SET_LINE_WIDTH = _pcbnew.PLOTTER_DO_NOT_SET_LINE_WIDTH
    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, aNegative):
        """SetNegative(PLOTTER self, bool aNegative)"""
        return _pcbnew.PLOTTER_SetNegative(self, aNegative)


    def SetColorMode(self, aColorMode):
        """SetColorMode(PLOTTER self, bool aColorMode)"""
        return _pcbnew.PLOTTER_SetColorMode(self, aColorMode)


    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, aData=None):
        """
        SetCurrentLineWidth(PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(PLOTTER self, int width)
        """
        return _pcbnew.PLOTTER_SetCurrentLineWidth(self, width, aData)


    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, COLOR4D color)"""
        return _pcbnew.PLOTTER_SetColor(self, color)


    def SetDash(self, dashed):
        """SetDash(PLOTTER self, int dashed)"""
        return _pcbnew.PLOTTER_SetDash(self, dashed)


    def SetCreator(self, aCreator):
        """SetCreator(PLOTTER self, wxString aCreator)"""
        return _pcbnew.PLOTTER_SetCreator(self, aCreator)


    def SetTitle(self, aTitle):
        """SetTitle(PLOTTER self, wxString aTitle)"""
        return _pcbnew.PLOTTER_SetTitle(self, aTitle)


    def AddLineToHeader(self, aExtraString):
        """AddLineToHeader(PLOTTER self, wxString 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 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, void * aData=None)
        PlotPoly(PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill)
        PlotPoly(PLOTTER self, SHAPE_LINE_CHAIN aCornerList, FILL_T aFill, int aWidth, void * aData=None)
        PlotPoly(PLOTTER self, SHAPE_LINE_CHAIN aCornerList, FILL_T aFill, int aWidth)
        PlotPoly(PLOTTER self, SHAPE_LINE_CHAIN 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, aData):
        """ThickSegment(PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickSegment(self, start, end, width, tracemode, aData)


    def ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode, aData):
        """ThickArc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode, aData)


    def ThickRect(self, p1, p2, width, tracemode, aData):
        """ThickRect(PLOTTER self, wxPoint p1, wxPoint p2, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickRect(self, p1, p2, width, tracemode, aData)


    def ThickCircle(self, pos, diametre, width, tracemode, aData):
        """ThickCircle(PLOTTER self, wxPoint pos, int diametre, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickCircle(self, pos, diametre, width, tracemode, aData)


    def FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData):
        """FlashPadCircle(PLOTTER self, wxPoint aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData)


    def FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData):
        """FlashPadOval(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)


    def FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode, aData):
        """FlashPadRect(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)


    def FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData):
        """FlashPadRoundRect(PLOTTER self, wxPoint aPadPos, wxSize aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)


    def FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData):
        """FlashPadCustom(PLOTTER self, wxPoint aPadPos, wxSize aSize, SHAPE_POLY_SET aPolygons, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData):
        """FlashPadTrapez(PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False, aData=None):
        """
        Text(PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, void * aData=None)
        Text(PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, COLOR4D aColor, wxString 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, aData)

    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)


    def StartBlock(self, aData):
        """StartBlock(PLOTTER self, void * aData)"""
        return _pcbnew.PLOTTER_StartBlock(self, aData)


    def EndBlock(self, aData):
        """EndBlock(PLOTTER self, void * aData)"""
        return _pcbnew.PLOTTER_EndBlock(self, aData)

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 __builtin__.Exception:
            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()

    GetDefaultFileExtension = staticmethod(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, aData=None):
        """
        SetCurrentLineWidth(HPGL_PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(HPGL_PLOTTER self, int width)
        """
        return _pcbnew.HPGL_PLOTTER_SetCurrentLineWidth(self, width, aData)


    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, int dashed)"""
        return _pcbnew.HPGL_PLOTTER_SetDash(self, dashed)


    def SetColor(self, color):
        """SetColor(HPGL_PLOTTER self, COLOR4D 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 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, void * aData=None)
        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, aData):
        """ThickSegment(HPGL_PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_ThickSegment(self, start, end, width, tracemode, aData)


    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, aPadPos, aDiameter, aTraceMode, aData):
        """FlashPadCircle(HPGL_PLOTTER self, wxPoint aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData)


    def FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData):
        """FlashPadOval(HPGL_PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)


    def FlashPadRect(self, aPadPos, aSize, aOrient, aTraceMode, aData):
        """FlashPadRect(HPGL_PLOTTER self, wxPoint aPadPos, wxSize aSize, double aOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadRect(self, aPadPos, aSize, aOrient, aTraceMode, aData)


    def FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData):
        """FlashPadRoundRect(HPGL_PLOTTER self, wxPoint aPadPos, wxSize aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)


    def FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData):
        """FlashPadCustom(HPGL_PLOTTER self, wxPoint aPadPos, wxSize aSize, SHAPE_POLY_SET aPolygons, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData):
        """FlashPadTrapez(HPGL_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.HPGL_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)

    __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, aPadPos, aDiameter, aTraceMode, aData):
        """FlashPadCircle(PSLIKE_PLOTTER self, wxPoint aPadPos, int aDiameter, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData)


    def FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData):
        """FlashPadOval(PSLIKE_PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)


    def FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode, aData):
        """FlashPadRect(PSLIKE_PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)


    def FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData):
        """FlashPadRoundRect(PSLIKE_PLOTTER self, wxPoint aPadPos, wxSize aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)


    def FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData):
        """FlashPadCustom(PSLIKE_PLOTTER self, wxPoint aPadPos, wxSize aSize, SHAPE_POLY_SET aPolygons, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData):
        """FlashPadTrapez(PSLIKE_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.PSLIKE_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)


    def SetColor(self, color):
        """SetColor(PSLIKE_PLOTTER self, COLOR4D 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 __builtin__.Exception:
            self.this = this

    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.PS_PLOTTER_GetDefaultFileExtension()

    GetDefaultFileExtension = staticmethod(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, aData=None):
        """
        SetCurrentLineWidth(PS_PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(PS_PLOTTER self, int width)
        """
        return _pcbnew.PS_PLOTTER_SetCurrentLineWidth(self, width, aData)


    def SetDash(self, dashed):
        """SetDash(PS_PLOTTER self, int 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, void * aData=None)
        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, aData=None):
        """
        Text(PS_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, void * aData=None)
        Text(PS_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, COLOR4D aColor, wxString 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, aData)

    __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 __builtin__.Exception:
            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()

    GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)

    def OpenFile(self, aFullFilename):
        """OpenFile(PDF_PLOTTER self, wxString 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, aData=None):
        """
        SetCurrentLineWidth(PDF_PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(PDF_PLOTTER self, int width)
        """
        return _pcbnew.PDF_PLOTTER_SetCurrentLineWidth(self, width, aData)


    def SetDash(self, dashed):
        """SetDash(PDF_PLOTTER self, int 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, void * aData=None)
        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, aData=None):
        """
        Text(PDF_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, void * aData=None)
        Text(PDF_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, COLOR4D aColor, wxString 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, aData)


    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 __builtin__.Exception:
            self.this = this

    def GetDefaultFileExtension():
        """GetDefaultFileExtension() -> wxString"""
        return _pcbnew.SVG_PLOTTER_GetDefaultFileExtension()

    GetDefaultFileExtension = staticmethod(GetDefaultFileExtension)

    def GetPlotterType(self):
        """GetPlotterType(SVG_PLOTTER self) -> PlotFormat"""
        return _pcbnew.SVG_PLOTTER_GetPlotterType(self)


    def SetColor(self, color):
        """SetColor(SVG_PLOTTER self, COLOR4D 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, aData=None):
        """
        SetCurrentLineWidth(SVG_PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(SVG_PLOTTER self, int width)
        """
        return _pcbnew.SVG_PLOTTER_SetCurrentLineWidth(self, width, aData)


    def SetDash(self, dashed):
        """SetDash(SVG_PLOTTER self, int 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, void * aData=None)
        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 StartBlock(self, aData):
        """StartBlock(SVG_PLOTTER self, void * aData)"""
        return _pcbnew.SVG_PLOTTER_StartBlock(self, aData)


    def EndBlock(self, aData):
        """EndBlock(SVG_PLOTTER self, void * aData)"""
        return _pcbnew.SVG_PLOTTER_EndBlock(self, aData)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False, aData=None):
        """
        Text(SVG_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, void * aData=None)
        Text(SVG_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, COLOR4D aColor, wxString 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, aData)

    __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()

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__["m_Size"] = _pcbnew.APERTURE_m_Size_set
    __swig_getmethods__["m_Size"] = _pcbnew.APERTURE_m_Size_get
    if _newclass:
        m_Size = _swig_property(_pcbnew.APERTURE_m_Size_get, _pcbnew.APERTURE_m_Size_set)
    __swig_setmethods__["m_Type"] = _pcbnew.APERTURE_m_Type_set
    __swig_getmethods__["m_Type"] = _pcbnew.APERTURE_m_Type_get
    if _newclass:
        m_Type = _swig_property(_pcbnew.APERTURE_m_Type_get, _pcbnew.APERTURE_m_Type_set)
    __swig_setmethods__["m_DCode"] = _pcbnew.APERTURE_m_DCode_set
    __swig_getmethods__["m_DCode"] = _pcbnew.APERTURE_m_DCode_get
    if _newclass:
        m_DCode = _swig_property(_pcbnew.APERTURE_m_DCode_get, _pcbnew.APERTURE_m_DCode_set)
    __swig_setmethods__["m_ApertureAttribute"] = _pcbnew.APERTURE_m_ApertureAttribute_set
    __swig_getmethods__["m_ApertureAttribute"] = _pcbnew.APERTURE_m_ApertureAttribute_get
    if _newclass:
        m_ApertureAttribute = _swig_property(_pcbnew.APERTURE_m_ApertureAttribute_get, _pcbnew.APERTURE_m_ApertureAttribute_set)

    def __init__(self):
        """__init__(APERTURE self) -> APERTURE"""
        this = _pcbnew.new_APERTURE()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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 __builtin__.Exception:
            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()

    GetDefaultFileExtension = staticmethod(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, aData=None):
        """
        SetCurrentLineWidth(GERBER_PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(GERBER_PLOTTER self, int width)
        """
        return _pcbnew.GERBER_PLOTTER_SetCurrentLineWidth(self, width, aData)


    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, int dashed)"""
        return _pcbnew.GERBER_PLOTTER_SetDash(self, dashed)


    def SetColor(self, color):
        """SetColor(GERBER_PLOTTER self, COLOR4D 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 ThickSegment(self, start, end, width, tracemode, aData):
        """ThickSegment(GERBER_PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_ThickSegment(self, start, end, width, tracemode, aData)


    def ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode, aData):
        """ThickArc(GERBER_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode, aData)


    def ThickRect(self, p1, p2, width, tracemode, aData):
        """ThickRect(GERBER_PLOTTER self, wxPoint p1, wxPoint p2, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_ThickRect(self, p1, p2, width, tracemode, aData)


    def ThickCircle(self, pos, diametre, width, tracemode, aData):
        """ThickCircle(GERBER_PLOTTER self, wxPoint pos, int diametre, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_ThickCircle(self, pos, diametre, width, tracemode, aData)


    def PlotPoly(self, *args):
        """
        PlotPoly(GERBER_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth, void * aData=None)
        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 Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False, aData=None):
        """
        Text(GERBER_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, void * aData=None)
        Text(GERBER_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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(GERBER_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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.GERBER_PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed, aData)


    def FlashPadCircle(self, pos, diametre, trace_mode, aData):
        """FlashPadCircle(GERBER_PLOTTER self, wxPoint pos, int diametre, EDA_DRAW_MODE_T trace_mode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadCircle(self, pos, diametre, trace_mode, aData)


    def FlashPadOval(self, pos, size, orient, trace_mode, aData):
        """FlashPadOval(GERBER_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadOval(self, pos, size, orient, trace_mode, aData)


    def FlashPadRect(self, pos, size, orient, trace_mode, aData):
        """FlashPadRect(GERBER_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadRect(self, pos, size, orient, trace_mode, aData)


    def FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData):
        """FlashPadRoundRect(GERBER_PLOTTER self, wxPoint aPadPos, wxSize aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)


    def FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData):
        """FlashPadCustom(GERBER_PLOTTER self, wxPoint aPadPos, wxSize aSize, SHAPE_POLY_SET aPolygons, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData):
        """FlashPadTrapez(GERBER_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)


    def PlotGerberRegion(self, aCornerList, aData=None):
        """
        PlotGerberRegion(GERBER_PLOTTER self, wxPoint_Vector aCornerList, void * aData=None)
        PlotGerberRegion(GERBER_PLOTTER self, wxPoint_Vector aCornerList)
        """
        return _pcbnew.GERBER_PLOTTER_PlotGerberRegion(self, aCornerList, aData)


    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)


    def UseX2format(self, aEnable):
        """UseX2format(GERBER_PLOTTER self, bool aEnable)"""
        return _pcbnew.GERBER_PLOTTER_UseX2format(self, aEnable)


    def UseX2NetAttributes(self, aEnable):
        """UseX2NetAttributes(GERBER_PLOTTER self, bool aEnable)"""
        return _pcbnew.GERBER_PLOTTER_UseX2NetAttributes(self, aEnable)


    def StartBlock(self, aData):
        """StartBlock(GERBER_PLOTTER self, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_StartBlock(self, aData)


    def EndBlock(self, aData):
        """EndBlock(GERBER_PLOTTER self, void * aData)"""
        return _pcbnew.GERBER_PLOTTER_EndBlock(self, aData)

    __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 __builtin__.Exception:
            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()

    GetDefaultFileExtension = staticmethod(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, aData=None):
        """
        SetCurrentLineWidth(DXF_PLOTTER self, int width, void * aData=None)
        SetCurrentLineWidth(DXF_PLOTTER self, int width)
        """
        return _pcbnew.DXF_PLOTTER_SetCurrentLineWidth(self, width, aData)


    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, int dashed)"""
        return _pcbnew.DXF_PLOTTER_SetDash(self, dashed)


    def SetColor(self, color):
        """SetColor(DXF_PLOTTER self, COLOR4D 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, void * aData=None)
        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, aData):
        """ThickSegment(DXF_PLOTTER self, wxPoint start, wxPoint end, int width, EDA_DRAW_MODE_T tracemode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_ThickSegment(self, start, end, width, tracemode, aData)


    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, aData):
        """FlashPadCircle(DXF_PLOTTER self, wxPoint pos, int diametre, EDA_DRAW_MODE_T trace_mode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_FlashPadCircle(self, pos, diametre, trace_mode, aData)


    def FlashPadOval(self, pos, size, orient, trace_mode, aData):
        """FlashPadOval(DXF_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_FlashPadOval(self, pos, size, orient, trace_mode, aData)


    def FlashPadRect(self, pos, size, orient, trace_mode, aData):
        """FlashPadRect(DXF_PLOTTER self, wxPoint pos, wxSize size, double orient, EDA_DRAW_MODE_T trace_mode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_FlashPadRect(self, pos, size, orient, trace_mode, aData)


    def FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData):
        """FlashPadRoundRect(DXF_PLOTTER self, wxPoint aPadPos, wxSize aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)


    def FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData):
        """FlashPadCustom(DXF_PLOTTER self, wxPoint aPadPos, wxSize aSize, SHAPE_POLY_SET aPolygons, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPolygons, aTraceMode, aData)


    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData):
        """FlashPadTrapez(DXF_PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, EDA_DRAW_MODE_T aTraceMode, void * aData)"""
        return _pcbnew.DXF_PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)


    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed=False, aData=None):
        """
        Text(DXF_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, void * aData=None)
        Text(DXF_PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString 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, COLOR4D aColor, wxString 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, aData)

    DXF_UNIT_INCHES = _pcbnew.DXF_PLOTTER_DXF_UNIT_INCHES
    DXF_UNIT_MILLIMETERS = _pcbnew.DXF_PLOTTER_DXF_UNIT_MILLIMETERS

    def SetUnits(self, aUnit):
        """SetUnits(DXF_PLOTTER self, DXF_PLOTTER::DXF_UNITS aUnit)"""
        return _pcbnew.DXF_PLOTTER_SetUnits(self, aUnit)


    def GetUnits(self):
        """GetUnits(DXF_PLOTTER self) -> DXF_PLOTTER::DXF_UNITS"""
        return _pcbnew.DXF_PLOTTER_GetUnits(self)


    def GetUnitScaling(self):
        """GetUnitScaling(DXF_PLOTTER self) -> double"""
        return _pcbnew.DXF_PLOTTER_GetUnitScaling(self)


    def GetMeasurementDirective(self):
        """GetMeasurementDirective(DXF_PLOTTER self) -> unsigned int"""
        return _pcbnew.DXF_PLOTTER_GetMeasurementDirective(self)

    __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(*args):
    """
    PlotWorkSheet(PLOTTER plotter, TITLE_BLOCK aTitleBlock, PAGE_INFO const & aPageInfo, int aSheetNumber, int aNumberOfSheets, wxString aSheetDesc, wxString aFilename, COLOR4D aColor)
    PlotWorkSheet(PLOTTER plotter, TITLE_BLOCK aTitleBlock, PAGE_INFO const & aPageInfo, int aSheetNumber, int aNumberOfSheets, wxString aSheetDesc, wxString aFilename)
    """
    return _pcbnew.PlotWorkSheet(*args)

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)
    __swig_setmethods__["m_Hole_NotPlated"] = _pcbnew.DRILL_TOOL_m_Hole_NotPlated_set
    __swig_getmethods__["m_Hole_NotPlated"] = _pcbnew.DRILL_TOOL_m_Hole_NotPlated_get
    if _newclass:
        m_Hole_NotPlated = _swig_property(_pcbnew.DRILL_TOOL_m_Hole_NotPlated_get, _pcbnew.DRILL_TOOL_m_Hole_NotPlated_set)

    def __init__(self, aDiameter, a_NotPlated):
        """__init__(DRILL_TOOL self, int aDiameter, bool a_NotPlated) -> DRILL_TOOL"""
        this = _pcbnew.new_DRILL_TOOL(aDiameter, a_NotPlated)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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_ItemParent"] = _pcbnew.HOLE_INFO_m_ItemParent_set
    __swig_getmethods__["m_ItemParent"] = _pcbnew.HOLE_INFO_m_ItemParent_get
    if _newclass:
        m_ItemParent = _swig_property(_pcbnew.HOLE_INFO_m_ItemParent_get, _pcbnew.HOLE_INFO_m_ItemParent_set)
    __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 __builtin__.Exception:
            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 __builtin__.Exception:
            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 GENDRILL_WRITER_BASE(_object):
    """Proxy of C++ GENDRILL_WRITER_BASE class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    DECIMAL_FORMAT = _pcbnew.GENDRILL_WRITER_BASE_DECIMAL_FORMAT
    SUPPRESS_LEADING = _pcbnew.GENDRILL_WRITER_BASE_SUPPRESS_LEADING
    SUPPRESS_TRAILING = _pcbnew.GENDRILL_WRITER_BASE_SUPPRESS_TRAILING
    KEEP_ZEROS = _pcbnew.GENDRILL_WRITER_BASE_KEEP_ZEROS
    __swig_destroy__ = _pcbnew.delete_GENDRILL_WRITER_BASE
    __del__ = lambda self: None

    def SetMergeOption(self, aMerge):
        """SetMergeOption(GENDRILL_WRITER_BASE self, bool aMerge)"""
        return _pcbnew.GENDRILL_WRITER_BASE_SetMergeOption(self, aMerge)


    def GetOffset(self):
        """GetOffset(GENDRILL_WRITER_BASE self) -> wxPoint"""
        return _pcbnew.GENDRILL_WRITER_BASE_GetOffset(self)


    def SetPageInfo(self, aPageInfo):
        """SetPageInfo(GENDRILL_WRITER_BASE self, PAGE_INFO const * aPageInfo)"""
        return _pcbnew.GENDRILL_WRITER_BASE_SetPageInfo(self, aPageInfo)


    def SetMapFileFormat(self, aMapFmt):
        """SetMapFileFormat(GENDRILL_WRITER_BASE self, PlotFormat aMapFmt)"""
        return _pcbnew.GENDRILL_WRITER_BASE_SetMapFileFormat(self, aMapFmt)


    def CreateMapFilesSet(self, aPlotDirectory, aReporter=None):
        """
        CreateMapFilesSet(GENDRILL_WRITER_BASE self, wxString aPlotDirectory, REPORTER * aReporter=None)
        CreateMapFilesSet(GENDRILL_WRITER_BASE self, wxString aPlotDirectory)
        """
        return _pcbnew.GENDRILL_WRITER_BASE_CreateMapFilesSet(self, aPlotDirectory, aReporter)


    def GenDrillReportFile(self, aFullFileName):
        """GenDrillReportFile(GENDRILL_WRITER_BASE self, wxString aFullFileName) -> bool"""
        return _pcbnew.GENDRILL_WRITER_BASE_GenDrillReportFile(self, aFullFileName)

GENDRILL_WRITER_BASE_swigregister = _pcbnew.GENDRILL_WRITER_BASE_swigregister
GENDRILL_WRITER_BASE_swigregister(GENDRILL_WRITER_BASE)

class EXCELLON_WRITER(GENDRILL_WRITER_BASE):
    """Proxy of C++ EXCELLON_WRITER class."""

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

    def __init__(self, aPcb):
        """__init__(EXCELLON_WRITER self, BOARD aPcb) -> EXCELLON_WRITER"""
        this = _pcbnew.new_EXCELLON_WRITER(aPcb)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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 SetRouteModeForOvalHoles(self, aUseRouteModeForOvalHoles):
        """SetRouteModeForOvalHoles(EXCELLON_WRITER self, bool aUseRouteModeForOvalHoles)"""
        return _pcbnew.EXCELLON_WRITER_SetRouteModeForOvalHoles(self, aUseRouteModeForOvalHoles)


    def SetFormat(self, *args):
        """
        SetFormat(EXCELLON_WRITER self, bool aMetric, GENDRILL_WRITER_BASE::ZEROS_FMT aZerosFmt, int aLeftDigits=0, int aRightDigits=0)
        SetFormat(EXCELLON_WRITER self, bool aMetric, GENDRILL_WRITER_BASE::ZEROS_FMT aZerosFmt, int aLeftDigits=0)
        SetFormat(EXCELLON_WRITER self, bool aMetric, GENDRILL_WRITER_BASE::ZEROS_FMT aZerosFmt)
        SetFormat(EXCELLON_WRITER self, bool aMetric)
        """
        return _pcbnew.EXCELLON_WRITER_SetFormat(self, *args)


    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 CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter=None):
        """
        CreateDrillandMapFilesSet(EXCELLON_WRITER self, wxString aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER * aReporter=None)
        CreateDrillandMapFilesSet(EXCELLON_WRITER self, wxString aPlotDirectory, bool aGenDrill, bool aGenMap)
        """
        return _pcbnew.EXCELLON_WRITER_CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter)

EXCELLON_WRITER_swigregister = _pcbnew.EXCELLON_WRITER_swigregister
EXCELLON_WRITER_swigregister(EXCELLON_WRITER)

class GERBER_WRITER(GENDRILL_WRITER_BASE):
    """Proxy of C++ GERBER_WRITER class."""

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

    def __init__(self, aPcb):
        """__init__(GERBER_WRITER self, BOARD aPcb) -> GERBER_WRITER"""
        this = _pcbnew.new_GERBER_WRITER(aPcb)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_GERBER_WRITER
    __del__ = lambda self: None

    def SetFormat(self, aRightDigits=6):
        """
        SetFormat(GERBER_WRITER self, int aRightDigits=6)
        SetFormat(GERBER_WRITER self)
        """
        return _pcbnew.GERBER_WRITER_SetFormat(self, aRightDigits)


    def SetOptions(self, aOffset):
        """SetOptions(GERBER_WRITER self, wxPoint aOffset)"""
        return _pcbnew.GERBER_WRITER_SetOptions(self, aOffset)


    def CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter=None):
        """
        CreateDrillandMapFilesSet(GERBER_WRITER self, wxString aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER * aReporter=None)
        CreateDrillandMapFilesSet(GERBER_WRITER self, wxString aPlotDirectory, bool aGenDrill, bool aGenMap)
        """
        return _pcbnew.GERBER_WRITER_CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter)

GERBER_WRITER_swigregister = _pcbnew.GERBER_WRITER_swigregister
GERBER_WRITER_swigregister(GERBER_WRITER)

SIDE_NONE = _pcbnew.SIDE_NONE
SIDE_TOP = _pcbnew.SIDE_TOP
SIDE_BOTTOM = _pcbnew.SIDE_BOTTOM
SIDE_BOTH = _pcbnew.SIDE_BOTH
class JOBFILE_PARAMS(_object):
    """Proxy of C++ JOBFILE_PARAMS class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, JOBFILE_PARAMS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, JOBFILE_PARAMS, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_GerberFileList"] = _pcbnew.JOBFILE_PARAMS_m_GerberFileList_set
    __swig_getmethods__["m_GerberFileList"] = _pcbnew.JOBFILE_PARAMS_m_GerberFileList_get
    if _newclass:
        m_GerberFileList = _swig_property(_pcbnew.JOBFILE_PARAMS_m_GerberFileList_get, _pcbnew.JOBFILE_PARAMS_m_GerberFileList_set)
    __swig_setmethods__["m_LayerId"] = _pcbnew.JOBFILE_PARAMS_m_LayerId_set
    __swig_getmethods__["m_LayerId"] = _pcbnew.JOBFILE_PARAMS_m_LayerId_get
    if _newclass:
        m_LayerId = _swig_property(_pcbnew.JOBFILE_PARAMS_m_LayerId_get, _pcbnew.JOBFILE_PARAMS_m_LayerId_set)

    def __init__(self):
        """__init__(JOBFILE_PARAMS self) -> JOBFILE_PARAMS"""
        this = _pcbnew.new_JOBFILE_PARAMS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_JOBFILE_PARAMS
    __del__ = lambda self: None
JOBFILE_PARAMS_swigregister = _pcbnew.JOBFILE_PARAMS_swigregister
JOBFILE_PARAMS_swigregister(JOBFILE_PARAMS)

class GERBER_JOBFILE_WRITER(_object):
    """Proxy of C++ GERBER_JOBFILE_WRITER class."""

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

    def __init__(self, aPcb, aReporter=None):
        """
        __init__(GERBER_JOBFILE_WRITER self, BOARD aPcb, REPORTER * aReporter=None) -> GERBER_JOBFILE_WRITER
        __init__(GERBER_JOBFILE_WRITER self, BOARD aPcb) -> GERBER_JOBFILE_WRITER
        """
        this = _pcbnew.new_GERBER_JOBFILE_WRITER(aPcb, aReporter)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_GERBER_JOBFILE_WRITER
    __del__ = lambda self: None

    def AddGbrFile(self, aLayer, aFilename):
        """AddGbrFile(GERBER_JOBFILE_WRITER self, PCB_LAYER_ID aLayer, wxString aFilename)"""
        return _pcbnew.GERBER_JOBFILE_WRITER_AddGbrFile(self, aLayer, aFilename)


    def CreateJobFile(self, aFullFilename):
        """CreateJobFile(GERBER_JOBFILE_WRITER self, wxString aFullFilename) -> bool"""
        return _pcbnew.GERBER_JOBFILE_WRITER_CreateJobFile(self, aFullFilename)


    def WriteJSONJobFile(self, aFullFilename):
        """WriteJSONJobFile(GERBER_JOBFILE_WRITER self, wxString aFullFilename) -> bool"""
        return _pcbnew.GERBER_JOBFILE_WRITER_WriteJSONJobFile(self, aFullFilename)

GERBER_JOBFILE_WRITER_swigregister = _pcbnew.GERBER_JOBFILE_WRITER_swigregister
GERBER_JOBFILE_WRITER_swigregister(GERBER_JOBFILE_WRITER)

ROOM_FOR_KICADMANAGER = _pcbnew.ROOM_FOR_KICADMANAGER
ROOM_FOR_3D_VIEWER = _pcbnew.ROOM_FOR_3D_VIEWER
ROOM_FOR_PANEL_PREV_MODEL = _pcbnew.ROOM_FOR_PANEL_PREV_MODEL
DEFAULT_FILE_HISTORY_SIZE = _pcbnew.DEFAULT_FILE_HISTORY_SIZE
MAX_FILE_HISTORY_SIZE = _pcbnew.MAX_FILE_HISTORY_SIZE
ID_RUN_PCB = _pcbnew.ID_RUN_PCB
ID_RUN_PCB_MODULE_EDITOR = _pcbnew.ID_RUN_PCB_MODULE_EDITOR
ID_RUN_CVPCB = _pcbnew.ID_RUN_CVPCB
ID_RUN_LIBRARY = _pcbnew.ID_RUN_LIBRARY
ID_LOAD_PROJECT = _pcbnew.ID_LOAD_PROJECT
ID_APPEND_PROJECT = _pcbnew.ID_APPEND_PROJECT
ID_NEW_PROJECT = _pcbnew.ID_NEW_PROJECT
ID_NEW_PROJECT_FROM_TEMPLATE = _pcbnew.ID_NEW_PROJECT_FROM_TEMPLATE
ID_SAVE_PROJECT = _pcbnew.ID_SAVE_PROJECT
ID_SAVE_PROJECT_AS = _pcbnew.ID_SAVE_PROJECT_AS
ID_LOAD_FILE = _pcbnew.ID_LOAD_FILE
ID_APPEND_FILE = _pcbnew.ID_APPEND_FILE
ID_NEW_BOARD = _pcbnew.ID_NEW_BOARD
ID_SAVE_BOARD = _pcbnew.ID_SAVE_BOARD
ID_SAVE_BOARD_AS = _pcbnew.ID_SAVE_BOARD_AS
ID_AUTO_SAVE_TIMER = _pcbnew.ID_AUTO_SAVE_TIMER
ID_CONFIG_REQ = _pcbnew.ID_CONFIG_REQ
ID_CONFIG_SAVE = _pcbnew.ID_CONFIG_SAVE
ID_CONFIG_READ = _pcbnew.ID_CONFIG_READ
ID_FILE = _pcbnew.ID_FILE
ID_FILE1 = _pcbnew.ID_FILE1
ID_FILEMAX = _pcbnew.ID_FILEMAX
ID_MENU_CANVAS_LEGACY = _pcbnew.ID_MENU_CANVAS_LEGACY
ID_MENU_CANVAS_OPENGL = _pcbnew.ID_MENU_CANVAS_OPENGL
ID_MENU_CANVAS_CAIRO = _pcbnew.ID_MENU_CANVAS_CAIRO
ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST = _pcbnew.ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST
ID_PREFERENCES_CONFIGURE_PATHS = _pcbnew.ID_PREFERENCES_CONFIGURE_PATHS
ID_EDIT_SYMBOL_LIBRARY_TABLE = _pcbnew.ID_EDIT_SYMBOL_LIBRARY_TABLE
ID_EDIT_FOOTPRINT_LIBRARY_TABLE = _pcbnew.ID_EDIT_FOOTPRINT_LIBRARY_TABLE
ID_GEN_PLOT = _pcbnew.ID_GEN_PLOT
ID_GEN_PLOT_PS = _pcbnew.ID_GEN_PLOT_PS
ID_GEN_PLOT_HPGL = _pcbnew.ID_GEN_PLOT_HPGL
ID_GEN_PLOT_GERBER = _pcbnew.ID_GEN_PLOT_GERBER
ID_GEN_PLOT_SVG = _pcbnew.ID_GEN_PLOT_SVG
ID_GEN_PLOT_DXF = _pcbnew.ID_GEN_PLOT_DXF
ID_GEN_PLOT_PDF = _pcbnew.ID_GEN_PLOT_PDF
ID_GEN_COPY_SHEET_TO_CLIPBOARD = _pcbnew.ID_GEN_COPY_SHEET_TO_CLIPBOARD
ID_GEN_COPY_BLOCK_TO_CLIPBOARD = _pcbnew.ID_GEN_COPY_BLOCK_TO_CLIPBOARD
ID_GEN_EXPORT_FILE = _pcbnew.ID_GEN_EXPORT_FILE
ID_GEN_IMPORT_FILE = _pcbnew.ID_GEN_IMPORT_FILE
ID_EXIT = _pcbnew.ID_EXIT
ID_OPTIONS_SETUP = _pcbnew.ID_OPTIONS_SETUP
ID_H_TOOLBAR = _pcbnew.ID_H_TOOLBAR
ID_V_TOOLBAR = _pcbnew.ID_V_TOOLBAR
ID_OPT_TOOLBAR = _pcbnew.ID_OPT_TOOLBAR
ID_AUX_TOOLBAR = _pcbnew.ID_AUX_TOOLBAR
ID_EDIT = _pcbnew.ID_EDIT
ID_NO_TOOL_SELECTED = _pcbnew.ID_NO_TOOL_SELECTED
ID_ZOOM_SELECTION = _pcbnew.ID_ZOOM_SELECTION
ID_MENU_ZOOM_SELECTION = _pcbnew.ID_MENU_ZOOM_SELECTION
ID_SEL_BG_COLOR = _pcbnew.ID_SEL_BG_COLOR
ID_REPEAT_BUTT = _pcbnew.ID_REPEAT_BUTT
ID_LANGUAGE_CHOICE = _pcbnew.ID_LANGUAGE_CHOICE
ID_LANGUAGE_DEFAULT = _pcbnew.ID_LANGUAGE_DEFAULT
ID_LANGUAGE_ENGLISH = _pcbnew.ID_LANGUAGE_ENGLISH
ID_LANGUAGE_FRENCH = _pcbnew.ID_LANGUAGE_FRENCH
ID_LANGUAGE_FINNISH = _pcbnew.ID_LANGUAGE_FINNISH
ID_LANGUAGE_SPANISH = _pcbnew.ID_LANGUAGE_SPANISH
ID_LANGUAGE_GERMAN = _pcbnew.ID_LANGUAGE_GERMAN
ID_LANGUAGE_GREEK = _pcbnew.ID_LANGUAGE_GREEK
ID_LANGUAGE_RUSSIAN = _pcbnew.ID_LANGUAGE_RUSSIAN
ID_LANGUAGE_PORTUGUESE = _pcbnew.ID_LANGUAGE_PORTUGUESE
ID_LANGUAGE_ITALIAN = _pcbnew.ID_LANGUAGE_ITALIAN
ID_LANGUAGE_SLOVENIAN = _pcbnew.ID_LANGUAGE_SLOVENIAN
ID_LANGUAGE_SLOVAK = _pcbnew.ID_LANGUAGE_SLOVAK
ID_LANGUAGE_HUNGARIAN = _pcbnew.ID_LANGUAGE_HUNGARIAN
ID_LANGUAGE_POLISH = _pcbnew.ID_LANGUAGE_POLISH
ID_LANGUAGE_CZECH = _pcbnew.ID_LANGUAGE_CZECH
ID_LANGUAGE_KOREAN = _pcbnew.ID_LANGUAGE_KOREAN
ID_LANGUAGE_CATALAN = _pcbnew.ID_LANGUAGE_CATALAN
ID_LANGUAGE_CHINESE_SIMPLIFIED = _pcbnew.ID_LANGUAGE_CHINESE_SIMPLIFIED
ID_LANGUAGE_CHINESE_TRADITIONAL = _pcbnew.ID_LANGUAGE_CHINESE_TRADITIONAL
ID_LANGUAGE_DUTCH = _pcbnew.ID_LANGUAGE_DUTCH
ID_LANGUAGE_JAPANESE = _pcbnew.ID_LANGUAGE_JAPANESE
ID_LANGUAGE_BULGARIAN = _pcbnew.ID_LANGUAGE_BULGARIAN
ID_LANGUAGE_LITHUANIAN = _pcbnew.ID_LANGUAGE_LITHUANIAN
ID_LANGUAGE_CHOICE_END = _pcbnew.ID_LANGUAGE_CHOICE_END
ID_KICAD_SELECT_ICONS_OPTIONS = _pcbnew.ID_KICAD_SELECT_ICONS_OPTIONS
ID_KICAD_SELECT_ICONS_IN_MENUS = _pcbnew.ID_KICAD_SELECT_ICONS_IN_MENUS
ID_KICAD_SELECT_ICON_OPTIONS_END = _pcbnew.ID_KICAD_SELECT_ICON_OPTIONS_END
ID_SET_REPEAT_OPTION = _pcbnew.ID_SET_REPEAT_OPTION
ID_POPUP_GENERAL_START_RANGE = _pcbnew.ID_POPUP_GENERAL_START_RANGE
ID_POPUP_CANCEL_CURRENT_COMMAND = _pcbnew.ID_POPUP_CANCEL_CURRENT_COMMAND
ID_POPUP_CLOSE_CURRENT_TOOL = _pcbnew.ID_POPUP_CLOSE_CURRENT_TOOL
ID_POPUP_MOVE_BLOCK = _pcbnew.ID_POPUP_MOVE_BLOCK
ID_POPUP_MOVE_BLOCK_EXACT = _pcbnew.ID_POPUP_MOVE_BLOCK_EXACT
ID_POPUP_DRAG_BLOCK = _pcbnew.ID_POPUP_DRAG_BLOCK
ID_POPUP_COPY_BLOCK = _pcbnew.ID_POPUP_COPY_BLOCK
ID_POPUP_PASTE_BLOCK = _pcbnew.ID_POPUP_PASTE_BLOCK
ID_POPUP_CUT_BLOCK = _pcbnew.ID_POPUP_CUT_BLOCK
ID_POPUP_DUPLICATE_BLOCK = _pcbnew.ID_POPUP_DUPLICATE_BLOCK
ID_POPUP_ROTATE_BLOCK = _pcbnew.ID_POPUP_ROTATE_BLOCK
ID_POPUP_DELETE_BLOCK = _pcbnew.ID_POPUP_DELETE_BLOCK
ID_POPUP_FLIP_BLOCK = _pcbnew.ID_POPUP_FLIP_BLOCK
ID_POPUP_PLACE_BLOCK = _pcbnew.ID_POPUP_PLACE_BLOCK
ID_POPUP_ZOOM_BLOCK = _pcbnew.ID_POPUP_ZOOM_BLOCK
ID_POPUP_SELECT_ITEMS_BLOCK = _pcbnew.ID_POPUP_SELECT_ITEMS_BLOCK
ID_POPUP_MIRROR_X_BLOCK = _pcbnew.ID_POPUP_MIRROR_X_BLOCK
ID_POPUP_MIRROR_Y_BLOCK = _pcbnew.ID_POPUP_MIRROR_Y_BLOCK
ID_POPUP_OTHER_COMMANDS = _pcbnew.ID_POPUP_OTHER_COMMANDS
ID_POPUP_GENERAL_END_RANGE = _pcbnew.ID_POPUP_GENERAL_END_RANGE
ID_POPUP_ENTER_MENU = _pcbnew.ID_POPUP_ENTER_MENU
ID_ON_ZOOM_SELECT = _pcbnew.ID_ON_ZOOM_SELECT
ID_POPUP_ZOOM_START_RANGE = _pcbnew.ID_POPUP_ZOOM_START_RANGE
ID_POPUP_CANCEL = _pcbnew.ID_POPUP_CANCEL
ID_POPUP_ZOOM_IN = _pcbnew.ID_POPUP_ZOOM_IN
ID_POPUP_ZOOM_OUT = _pcbnew.ID_POPUP_ZOOM_OUT
ID_POPUP_ZOOM_SELECT = _pcbnew.ID_POPUP_ZOOM_SELECT
ID_POPUP_ZOOM_CENTER = _pcbnew.ID_POPUP_ZOOM_CENTER
ID_POPUP_ZOOM_PAGE = _pcbnew.ID_POPUP_ZOOM_PAGE
ID_POPUP_ZOOM_REDRAW = _pcbnew.ID_POPUP_ZOOM_REDRAW
ID_KEY_ZOOM_IN = _pcbnew.ID_KEY_ZOOM_IN
ID_KEY_ZOOM_OUT = _pcbnew.ID_KEY_ZOOM_OUT
ID_POPUP_ZOOM_LEVEL_START = _pcbnew.ID_POPUP_ZOOM_LEVEL_START
ID_POPUP_ZOOM_LEVEL_END = _pcbnew.ID_POPUP_ZOOM_LEVEL_END
ID_POPUP_ZOOM_END_RANGE = _pcbnew.ID_POPUP_ZOOM_END_RANGE
ID_ON_GRID_SELECT = _pcbnew.ID_ON_GRID_SELECT
ID_POPUP_GRID_PLUS = _pcbnew.ID_POPUP_GRID_PLUS
ID_POPUP_GRID_MOINS = _pcbnew.ID_POPUP_GRID_MOINS
ID_POPUP_GRID_SELECT = _pcbnew.ID_POPUP_GRID_SELECT
ID_POPUP_GRID_LEVEL_1000 = _pcbnew.ID_POPUP_GRID_LEVEL_1000
ID_POPUP_GRID_LEVEL_500 = _pcbnew.ID_POPUP_GRID_LEVEL_500
ID_POPUP_GRID_LEVEL_250 = _pcbnew.ID_POPUP_GRID_LEVEL_250
ID_POPUP_GRID_LEVEL_200 = _pcbnew.ID_POPUP_GRID_LEVEL_200
ID_POPUP_GRID_LEVEL_100 = _pcbnew.ID_POPUP_GRID_LEVEL_100
ID_POPUP_GRID_LEVEL_50 = _pcbnew.ID_POPUP_GRID_LEVEL_50
ID_POPUP_GRID_LEVEL_25 = _pcbnew.ID_POPUP_GRID_LEVEL_25
ID_POPUP_GRID_LEVEL_20 = _pcbnew.ID_POPUP_GRID_LEVEL_20
ID_POPUP_GRID_LEVEL_10 = _pcbnew.ID_POPUP_GRID_LEVEL_10
ID_POPUP_GRID_LEVEL_5 = _pcbnew.ID_POPUP_GRID_LEVEL_5
ID_POPUP_GRID_LEVEL_2 = _pcbnew.ID_POPUP_GRID_LEVEL_2
ID_POPUP_GRID_LEVEL_1 = _pcbnew.ID_POPUP_GRID_LEVEL_1
ID_POPUP_GRID_LEVEL_5MM = _pcbnew.ID_POPUP_GRID_LEVEL_5MM
ID_POPUP_GRID_LEVEL_2_5MM = _pcbnew.ID_POPUP_GRID_LEVEL_2_5MM
ID_POPUP_GRID_LEVEL_1MM = _pcbnew.ID_POPUP_GRID_LEVEL_1MM
ID_POPUP_GRID_LEVEL_0_5MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_5MM
ID_POPUP_GRID_LEVEL_0_25MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_25MM
ID_POPUP_GRID_LEVEL_0_2MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_2MM
ID_POPUP_GRID_LEVEL_0_1MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_1MM
ID_POPUP_GRID_LEVEL_0_0_5MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_0_5MM
ID_POPUP_GRID_LEVEL_0_0_25MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_0_25MM
ID_POPUP_GRID_LEVEL_0_0_1MM = _pcbnew.ID_POPUP_GRID_LEVEL_0_0_1MM
ID_POPUP_GRID_USER = _pcbnew.ID_POPUP_GRID_USER
ID_SHEET_SET = _pcbnew.ID_SHEET_SET
ID_COMPONENT_BUTT = _pcbnew.ID_COMPONENT_BUTT
ID_ZOOM_BEGIN = _pcbnew.ID_ZOOM_BEGIN
ID_ZOOM_IN = _pcbnew.ID_ZOOM_IN
ID_ZOOM_OUT = _pcbnew.ID_ZOOM_OUT
ID_ZOOM_PAGE = _pcbnew.ID_ZOOM_PAGE
ID_ZOOM_REDRAW = _pcbnew.ID_ZOOM_REDRAW
ID_VIEWER_ZOOM_IN = _pcbnew.ID_VIEWER_ZOOM_IN
ID_VIEWER_ZOOM_OUT = _pcbnew.ID_VIEWER_ZOOM_OUT
ID_VIEWER_ZOOM_PAGE = _pcbnew.ID_VIEWER_ZOOM_PAGE
ID_VIEWER_ZOOM_REDRAW = _pcbnew.ID_VIEWER_ZOOM_REDRAW
ID_OFFCENTER_ZOOM_IN = _pcbnew.ID_OFFCENTER_ZOOM_IN
ID_OFFCENTER_ZOOM_OUT = _pcbnew.ID_OFFCENTER_ZOOM_OUT
ID_ZOOM_END = _pcbnew.ID_ZOOM_END
ID_PAN_UP = _pcbnew.ID_PAN_UP
ID_PAN_DOWN = _pcbnew.ID_PAN_DOWN
ID_PAN_LEFT = _pcbnew.ID_PAN_LEFT
ID_PAN_RIGHT = _pcbnew.ID_PAN_RIGHT
ID_MOUSE_DOUBLECLICK = _pcbnew.ID_MOUSE_DOUBLECLICK
ID_GET_NETLIST = _pcbnew.ID_GET_NETLIST
ID_OPEN_CMP_TABLE = _pcbnew.ID_OPEN_CMP_TABLE
ID_GET_TOOLS = _pcbnew.ID_GET_TOOLS
ID_FIND_ITEMS = _pcbnew.ID_FIND_ITEMS
ID_EDA_SOCKET_EVENT_SERV = _pcbnew.ID_EDA_SOCKET_EVENT_SERV
ID_EDA_SOCKET_EVENT = _pcbnew.ID_EDA_SOCKET_EVENT
ID_TB_OPTIONS_SELECT_UNIT_MM = _pcbnew.ID_TB_OPTIONS_SELECT_UNIT_MM
ID_TB_OPTIONS_SELECT_UNIT_INCH = _pcbnew.ID_TB_OPTIONS_SELECT_UNIT_INCH
ID_TB_OPTIONS_SELECT_CURSOR = _pcbnew.ID_TB_OPTIONS_SELECT_CURSOR
ID_TB_OPTIONS_SHOW_POLAR_COORD = _pcbnew.ID_TB_OPTIONS_SHOW_POLAR_COORD
ID_TB_OPTIONS_SHOW_GRID = _pcbnew.ID_TB_OPTIONS_SHOW_GRID
ID_HELP_GET_INVOLVED = _pcbnew.ID_HELP_GET_INVOLVED
ID_TB_OPTIONS_SHOW_MODULE_TEXT_SKETCH = _pcbnew.ID_TB_OPTIONS_SHOW_MODULE_TEXT_SKETCH
ID_TB_OPTIONS_SHOW_MODULE_EDGE_SKETCH = _pcbnew.ID_TB_OPTIONS_SHOW_MODULE_EDGE_SKETCH
ID_TB_OPTIONS_SHOW_GRAPHIC_SKETCH = _pcbnew.ID_TB_OPTIONS_SHOW_GRAPHIC_SKETCH
ID_TB_OPTIONS_SHOW_PADS_SKETCH = _pcbnew.ID_TB_OPTIONS_SHOW_PADS_SKETCH
ID_DIALOG_ERC = _pcbnew.ID_DIALOG_ERC
ID_KICAD_MANAGER_START = _pcbnew.ID_KICAD_MANAGER_START
ID_KICAD_MANAGER_END = _pcbnew.ID_KICAD_MANAGER_END
ID_KICAD_3D_VIEWER_START = _pcbnew.ID_KICAD_3D_VIEWER_START
ID_KICAD_3D_VIEWER_END = _pcbnew.ID_KICAD_3D_VIEWER_END
ID_KICAD_PANEL_PREV_MODEL_START = _pcbnew.ID_KICAD_PANEL_PREV_MODEL_START
ID_KICAD_PANEL_PREV_MODEL_END = _pcbnew.ID_KICAD_PANEL_PREV_MODEL_END
ID_END_LIST = _pcbnew.ID_END_LIST

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(aFileName, aBoard):
    """SaveBoard(wxString aFileName, BOARD aBoard) -> bool"""
    return _pcbnew.SaveBoard(aFileName, aBoard)

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

def WindowZoom(xl, yl, width, height):
    """WindowZoom(int xl, int yl, int width, int height)"""
    return _pcbnew.WindowZoom(xl, yl, width, height)

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

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

def IsActionRunning():
    """IsActionRunning() -> bool"""
    return _pcbnew.IsActionRunning()
S_SEGMENT = _pcbnew.S_SEGMENT
S_RECT = _pcbnew.S_RECT
S_ARC = _pcbnew.S_ARC
S_CIRCLE = _pcbnew.S_CIRCLE
S_POLYGON = _pcbnew.S_POLYGON
S_CURVE = _pcbnew.S_CURVE
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_CONTAINER"""
        return _pcbnew.BOARD_ITEM_GetParent(self)


    def GetLayer(self):
        """GetLayer(BOARD_ITEM self) -> PCB_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, PCB_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, PCB_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 SetLocked(self, aLocked):
        """SetLocked(BOARD_ITEM self, bool aLocked)"""
        return _pcbnew.BOARD_ITEM_SetLocked(self, aLocked)


    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)

    ShowShape = staticmethod(ShowShape)

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


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


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


    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 ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(BOARD_ITEM self, int [] aLayers, int & aCount)"""
        return _pcbnew.BOARD_ITEM_ViewGetLayers(self, aLayers, aCount)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(BOARD_ITEM self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(BOARD_ITEM self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.BOARD_ITEM_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    def Cast(self):

        ct = self.GetClass()

        if ct=="PTEXT":
            return Cast_to_TEXTE_PCB(self)
        elif ct=="BOARD":
            return Cast_to_BOARD(self)
        elif ct=="DIMENSION":
            return Cast_to_DIMENSION(self)
        elif ct=="DRAWSEGMENT":
            return Cast_to_DRAWSEGMENT(self)
        elif ct=="MGRAPHIC":
            return Cast_to_EDGE_MODULE(self)
        elif ct=="MODULE":
            return Cast_to_MODULE(self)
        elif ct=="PAD":
            return Cast_to_D_PAD(self)
        elif ct=="MTEXT":
            return Cast_to_TEXTE_MODULE(self)
        elif ct=="VIA":
            return Cast_to_VIA(self)
        elif ct=="TRACK":
            return Cast_to_TRACK(self)
        elif ct=="PCB_TARGET":
            return Cast_to_PCB_TARGET(self)
        elif ct=="ZONE_CONTAINER":
            return Cast_to_ZONE_CONTAINER(self)
        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)

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, Python 2 way to implement an iterator
            return self.__next__()

        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 __builtin__.Exception:
            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_CONTAINER"""
        return _pcbnew.BOARD_ITEM_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(BOARD_ITEM_List self) -> PCB_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, PCB_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, PCB_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 SetLocked(self, aLocked):
        """SetLocked(BOARD_ITEM_List self, bool aLocked)"""
        return _pcbnew.BOARD_ITEM_List_SetLocked(self, aLocked)


    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, *args):
        """
        Move(BOARD_ITEM_List self, wxPoint aMoveVector)
        Move(BOARD_ITEM_List self, VECTOR2I aMoveVector)
        """
        return _pcbnew.BOARD_ITEM_List_Move(self, *args)


    def Rotate(self, *args):
        """
        Rotate(BOARD_ITEM_List self, wxPoint aRotCentre, double aAngle)
        Rotate(BOARD_ITEM_List self, VECTOR2I aRotCentre, double aAngle)
        """
        return _pcbnew.BOARD_ITEM_List_Rotate(self, *args)


    def Flip(self, *args):
        """
        Flip(BOARD_ITEM_List self, wxPoint aCentre)
        Flip(BOARD_ITEM_List self, VECTOR2I aCentre)
        """
        return _pcbnew.BOARD_ITEM_List_Flip(self, *args)


    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 ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(BOARD_ITEM_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.BOARD_ITEM_List_ViewGetLayers(self, aLayers, aCount)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(BOARD_ITEM_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(BOARD_ITEM_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.BOARD_ITEM_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    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, timestamp_t aNewTimeStamp)"""
        return _pcbnew.BOARD_ITEM_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(BOARD_ITEM_List self) -> timestamp_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 IsType(self, aScanTypes):
        """IsType(BOARD_ITEM_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsType(self, aScanTypes)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(BOARD_ITEM_List self, bool aEnable)"""
        return _pcbnew.BOARD_ITEM_List_SetForceVisible(self, aEnable)


    def GetMsgPanelInfo(self, aUnits, aList):
        """GetMsgPanelInfo(BOARD_ITEM_List self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.BOARD_ITEM_List_GetMsgPanelInfo(self, aUnits, 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 * 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 * 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, aUnits):
        """GetSelectMenuText(BOARD_ITEM_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetSelectMenuText(self, aUnits)


    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)


def Cast_to_BOARD_ITEM(base):
    """Cast_to_BOARD_ITEM(EDA_ITEM base) -> BOARD_ITEM"""
    return _pcbnew.Cast_to_BOARD_ITEM(base)

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

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

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

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

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

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

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

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

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

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

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

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

def Cast_to_PCB_TARGET(arg1):
    """Cast_to_PCB_TARGET(BOARD_ITEM arg1) -> PCB_TARGET"""
    return _pcbnew.Cast_to_PCB_TARGET(arg1)
ADD_INSERT = _pcbnew.ADD_INSERT
ADD_APPEND = _pcbnew.ADD_APPEND
class BOARD_ITEM_CONTAINER(BOARD_ITEM):
    """Proxy of C++ BOARD_ITEM_CONTAINER class."""

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

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

    def AddNative(self, aItem, aMode=ADD_INSERT):
        """
        AddNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)
        AddNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem)
        """
        return _pcbnew.BOARD_ITEM_CONTAINER_AddNative(self, aItem, aMode)


    def RemoveNative(self, aItem):
        """RemoveNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_RemoveNative(self, aItem)


    def DeleteNative(self, aItem):
        """DeleteNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_DeleteNative(self, aItem)


    def Add(self,item):
        """
        Add a BOARD_ITEM to this BOARD_ITEM_CONTAINER, clear the thisown to prevent
        python from deleting the object in the garbage collector
        Add(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)
        Add(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem)
        """
        item.thisown=0
        self.AddNative(item)

    def Remove(self,item):
        """
        Remove a BOARD_ITEM from this BOARD_ITEM_CONTAINER, set the thisdown flag so that
        the python wrapper owns the C++ BOARD_ITEM
        Remove(self, BOARD_ITEM)
        """
        self.RemoveNative(item)
        if (not IsActionRunning()):
            item.thisown=1

    def Delete(self,item):
        """
        Remove a BOARD_ITEM from this BOARD_ITEM_CONTAINER, set the thisdown flag so that
        the python wrapper does not owns the C++ BOARD_ITEM
        Delete(self, BOARD_ITEM)
        """
        item.thisown=0          # C++'s BOARD_ITEM_CONTAINER::Delete() will delete
        self.DeleteNative(item)
        item.this = None

BOARD_ITEM_CONTAINER_swigregister = _pcbnew.BOARD_ITEM_CONTAINER_swigregister
BOARD_ITEM_CONTAINER_swigregister(BOARD_ITEM_CONTAINER)

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

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

    ClassOf = staticmethod(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 SetNet(self, aNetInfo):
        """SetNet(BOARD_CONNECTED_ITEM self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetNet(self, aNetInfo)


    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 GetNetname(self):
        """GetNetname(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetname(self)


    def GetNetnameMsg(self):
        """GetNetnameMsg(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetnameMsg(self)


    def GetShortNetname(self):
        """GetShortNetname(BOARD_CONNECTED_ITEM self) -> wxString"""
        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) -> std::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)


    def SetLocalRatsnestVisible(self, aVisible):
        """SetLocalRatsnestVisible(BOARD_CONNECTED_ITEM self, bool aVisible)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetLocalRatsnestVisible(self, aVisible)


    def GetLocalRatsnestVisible(self):
        """GetLocalRatsnestVisible(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetLocalRatsnestVisible(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)

DEFAULT_SILK_LINE_WIDTH = _pcbnew.DEFAULT_SILK_LINE_WIDTH
DEFAULT_COPPER_LINE_WIDTH = _pcbnew.DEFAULT_COPPER_LINE_WIDTH
DEFAULT_EDGE_WIDTH = _pcbnew.DEFAULT_EDGE_WIDTH
DEFAULT_COURTYARD_WIDTH = _pcbnew.DEFAULT_COURTYARD_WIDTH
DEFAULT_LINE_WIDTH = _pcbnew.DEFAULT_LINE_WIDTH
DEFAULT_SILK_TEXT_SIZE = _pcbnew.DEFAULT_SILK_TEXT_SIZE
DEFAULT_COPPER_TEXT_SIZE = _pcbnew.DEFAULT_COPPER_TEXT_SIZE
DEFAULT_TEXT_SIZE = _pcbnew.DEFAULT_TEXT_SIZE
DEFAULT_SILK_TEXT_WIDTH = _pcbnew.DEFAULT_SILK_TEXT_WIDTH
DEFAULT_COPPER_TEXT_WIDTH = _pcbnew.DEFAULT_COPPER_TEXT_WIDTH
DEFAULT_TEXT_WIDTH = _pcbnew.DEFAULT_TEXT_WIDTH
DEFAULT_BOARD_THICKNESS_MM = _pcbnew.DEFAULT_BOARD_THICKNESS_MM
DEFAULT_PCB_EDGE_THICKNESS = _pcbnew.DEFAULT_PCB_EDGE_THICKNESS
DEFAULT_SOLDERMASK_CLEARANCE = _pcbnew.DEFAULT_SOLDERMASK_CLEARANCE
DEFAULT_SOLDERMASK_MIN_WIDTH = _pcbnew.DEFAULT_SOLDERMASK_MIN_WIDTH
DEFAULT_SOLDERPASTE_CLEARANCE = _pcbnew.DEFAULT_SOLDERPASTE_CLEARANCE
DEFAULT_SOLDERPASTE_RATIO = _pcbnew.DEFAULT_SOLDERPASTE_RATIO
DEFAULT_CUSTOMTRACKWIDTH = _pcbnew.DEFAULT_CUSTOMTRACKWIDTH
DEFAULT_CUSTOMDPAIRWIDTH = _pcbnew.DEFAULT_CUSTOMDPAIRWIDTH
DEFAULT_CUSTOMDPAIRGAP = _pcbnew.DEFAULT_CUSTOMDPAIRGAP
DEFAULT_CUSTOMDPAIRVIAGAP = _pcbnew.DEFAULT_CUSTOMDPAIRVIAGAP
DEFAULT_TRACKMINWIDTH = _pcbnew.DEFAULT_TRACKMINWIDTH
DEFAULT_VIASMINSIZE = _pcbnew.DEFAULT_VIASMINSIZE
DEFAULT_VIASMINDRILL = _pcbnew.DEFAULT_VIASMINDRILL
DEFAULT_MICROVIASMINSIZE = _pcbnew.DEFAULT_MICROVIASMINSIZE
DEFAULT_MICROVIASMINDRILL = _pcbnew.DEFAULT_MICROVIASMINDRILL
DEFAULT_HOLETOHOLEMIN = _pcbnew.DEFAULT_HOLETOHOLEMIN
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 __builtin__.Exception:
            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 DIFF_PAIR_DIMENSION(_object):
    """Proxy of C++ DIFF_PAIR_DIMENSION class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DIFF_PAIR_DIMENSION, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DIFF_PAIR_DIMENSION, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Width"] = _pcbnew.DIFF_PAIR_DIMENSION_m_Width_set
    __swig_getmethods__["m_Width"] = _pcbnew.DIFF_PAIR_DIMENSION_m_Width_get
    if _newclass:
        m_Width = _swig_property(_pcbnew.DIFF_PAIR_DIMENSION_m_Width_get, _pcbnew.DIFF_PAIR_DIMENSION_m_Width_set)
    __swig_setmethods__["m_Gap"] = _pcbnew.DIFF_PAIR_DIMENSION_m_Gap_set
    __swig_getmethods__["m_Gap"] = _pcbnew.DIFF_PAIR_DIMENSION_m_Gap_get
    if _newclass:
        m_Gap = _swig_property(_pcbnew.DIFF_PAIR_DIMENSION_m_Gap_get, _pcbnew.DIFF_PAIR_DIMENSION_m_Gap_set)
    __swig_setmethods__["m_ViaGap"] = _pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_set
    __swig_getmethods__["m_ViaGap"] = _pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_get
    if _newclass:
        m_ViaGap = _swig_property(_pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_get, _pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_set)

    def __init__(self, *args):
        """
        __init__(DIFF_PAIR_DIMENSION self) -> DIFF_PAIR_DIMENSION
        __init__(DIFF_PAIR_DIMENSION self, int aWidth, int aGap, int aViaGap) -> DIFF_PAIR_DIMENSION
        """
        this = _pcbnew.new_DIFF_PAIR_DIMENSION(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, aOther):
        """__eq__(DIFF_PAIR_DIMENSION self, DIFF_PAIR_DIMENSION aOther) -> bool"""
        return _pcbnew.DIFF_PAIR_DIMENSION___eq__(self, aOther)


    def __lt__(self, aOther):
        """__lt__(DIFF_PAIR_DIMENSION self, DIFF_PAIR_DIMENSION aOther) -> bool"""
        return _pcbnew.DIFF_PAIR_DIMENSION___lt__(self, aOther)

    __swig_destroy__ = _pcbnew.delete_DIFF_PAIR_DIMENSION
    __del__ = lambda self: None
DIFF_PAIR_DIMENSION_swigregister = _pcbnew.DIFF_PAIR_DIMENSION_swigregister
DIFF_PAIR_DIMENSION_swigregister(DIFF_PAIR_DIMENSION)

LAYER_CLASS_SILK = _pcbnew.LAYER_CLASS_SILK
LAYER_CLASS_COPPER = _pcbnew.LAYER_CLASS_COPPER
LAYER_CLASS_EDGES = _pcbnew.LAYER_CLASS_EDGES
LAYER_CLASS_COURTYARD = _pcbnew.LAYER_CLASS_COURTYARD
LAYER_CLASS_OTHERS = _pcbnew.LAYER_CLASS_OTHERS
LAYER_CLASS_COUNT = _pcbnew.LAYER_CLASS_COUNT
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_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_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_DiffPairDimensionsList"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_set
    __swig_getmethods__["m_DiffPairDimensionsList"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_get
    if _newclass:
        m_DiffPairDimensionsList = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_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_RequireCourtyards"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RequireCourtyards_set
    __swig_getmethods__["m_RequireCourtyards"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_RequireCourtyards_get
    if _newclass:
        m_RequireCourtyards = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RequireCourtyards_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RequireCourtyards_set)
    __swig_setmethods__["m_ProhibitOverlappingCourtyards"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ProhibitOverlappingCourtyards_set
    __swig_getmethods__["m_ProhibitOverlappingCourtyards"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_ProhibitOverlappingCourtyards_get
    if _newclass:
        m_ProhibitOverlappingCourtyards = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ProhibitOverlappingCourtyards_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ProhibitOverlappingCourtyards_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_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_HoleToHoleMin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_set
    __swig_getmethods__["m_HoleToHoleMin"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_get
    if _newclass:
        m_HoleToHoleMin = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_set)
    __swig_setmethods__["m_LineThickness"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_set
    __swig_getmethods__["m_LineThickness"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_get
    if _newclass:
        m_LineThickness = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_set)
    __swig_setmethods__["m_TextSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_set
    __swig_getmethods__["m_TextSize"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_get
    if _newclass:
        m_TextSize = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_set)
    __swig_setmethods__["m_TextThickness"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_set
    __swig_getmethods__["m_TextThickness"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_get
    if _newclass:
        m_TextThickness = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_set)
    __swig_setmethods__["m_TextItalic"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_set
    __swig_getmethods__["m_TextItalic"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_get
    if _newclass:
        m_TextItalic = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_set)
    __swig_setmethods__["m_TextUpright"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_set
    __swig_getmethods__["m_TextUpright"] = _pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_get
    if _newclass:
        m_TextUpright = _swig_property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_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 __builtin__.Exception:
            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"""
        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 UseNetClassDiffPair(self):
        """UseNetClassDiffPair(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassDiffPair(self)


    def SetCurrentNetClass(self, aNetClassName):
        """SetCurrentNetClass(BOARD_DESIGN_SETTINGS self, wxString 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 GetDiffPairIndex(self):
        """GetDiffPairIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDiffPairIndex(self)


    def SetDiffPairIndex(self, aIndex):
        """SetDiffPairIndex(BOARD_DESIGN_SETTINGS self, unsigned int aIndex)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetDiffPairIndex(self, aIndex)


    def SetCustomDiffPairWidth(self, aWidth):
        """SetCustomDiffPairWidth(BOARD_DESIGN_SETTINGS self, int aWidth)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomDiffPairWidth(self, aWidth)


    def GetCustomDiffPairWidth(self):
        """GetCustomDiffPairWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomDiffPairWidth(self)


    def SetCustomDiffPairGap(self, aGap):
        """SetCustomDiffPairGap(BOARD_DESIGN_SETTINGS self, int aGap)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomDiffPairGap(self, aGap)


    def GetCustomDiffPairGap(self):
        """GetCustomDiffPairGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomDiffPairGap(self)


    def SetCustomDiffPairViaGap(self, aGap):
        """SetCustomDiffPairViaGap(BOARD_DESIGN_SETTINGS self, int aGap)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomDiffPairViaGap(self, aGap)


    def GetCustomDiffPairViaGap(self):
        """GetCustomDiffPairViaGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomDiffPairViaGap(self)


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


    def GetCurrentDiffPairWidth(self):
        """GetCurrentDiffPairWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentDiffPairWidth(self)


    def GetCurrentDiffPairGap(self):
        """GetCurrentDiffPairGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentDiffPairGap(self)


    def GetCurrentDiffPairViaGap(self):
        """GetCurrentDiffPairViaGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentDiffPairViaGap(self)


    def SetMinHoleSeparation(self, aDistance):
        """SetMinHoleSeparation(BOARD_DESIGN_SETTINGS self, int aDistance)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetMinHoleSeparation(self, aDistance)


    def SetRequireCourtyardDefinitions(self, aRequire):
        """SetRequireCourtyardDefinitions(BOARD_DESIGN_SETTINGS self, bool aRequire)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetRequireCourtyardDefinitions(self, aRequire)


    def SetProhibitOverlappingCourtyards(self, aProhibit):
        """SetProhibitOverlappingCourtyards(BOARD_DESIGN_SETTINGS self, bool aProhibit)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetProhibitOverlappingCourtyards(self, aProhibit)


    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, PCB_LAYER_ID aLayerId) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_IsLayerVisible(self, aLayerId)


    def SetLayerVisibility(self, aLayerId, aNewState):
        """SetLayerVisibility(BOARD_DESIGN_SETTINGS self, PCB_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, GAL_LAYER_ID aElementCategory) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_IsElementVisible(self, aElementCategory)


    def SetElementVisibility(self, aElementCategory, aNewState):
        """SetElementVisibility(BOARD_DESIGN_SETTINGS self, GAL_LAYER_ID 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, PCB_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, aBoard, aResult):
        """AppendConfigs(BOARD_DESIGN_SETTINGS self, BOARD aBoard, PARAM_CFG_ARRAY * aResult)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_AppendConfigs(self, aBoard, 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)


    def GetLineThickness(self, aLayer):
        """GetLineThickness(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetLineThickness(self, aLayer)


    def GetTextSize(self, aLayer):
        """GetTextSize(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> wxSize"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextSize(self, aLayer)


    def GetTextThickness(self, aLayer):
        """GetTextThickness(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextThickness(self, aLayer)


    def GetTextItalic(self, aLayer):
        """GetTextItalic(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextItalic(self, aLayer)


    def GetTextUpright(self, aLayer):
        """GetTextUpright(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextUpright(self, aLayer)


    def GetLayerClass(self, aLayer):
        """GetLayerClass(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetLayerClass(self, aLayer)

    __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)

class CN_DISJOINT_NET_ENTRY(_object):
    """Proxy of C++ CN_DISJOINT_NET_ENTRY class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CN_DISJOINT_NET_ENTRY, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CN_DISJOINT_NET_ENTRY, name)
    __repr__ = _swig_repr
    __swig_setmethods__["net"] = _pcbnew.CN_DISJOINT_NET_ENTRY_net_set
    __swig_getmethods__["net"] = _pcbnew.CN_DISJOINT_NET_ENTRY_net_get
    if _newclass:
        net = _swig_property(_pcbnew.CN_DISJOINT_NET_ENTRY_net_get, _pcbnew.CN_DISJOINT_NET_ENTRY_net_set)
    __swig_setmethods__["a"] = _pcbnew.CN_DISJOINT_NET_ENTRY_a_set
    __swig_getmethods__["a"] = _pcbnew.CN_DISJOINT_NET_ENTRY_a_get
    if _newclass:
        a = _swig_property(_pcbnew.CN_DISJOINT_NET_ENTRY_a_get, _pcbnew.CN_DISJOINT_NET_ENTRY_a_set)
    __swig_setmethods__["b"] = _pcbnew.CN_DISJOINT_NET_ENTRY_b_set
    __swig_getmethods__["b"] = _pcbnew.CN_DISJOINT_NET_ENTRY_b_get
    if _newclass:
        b = _swig_property(_pcbnew.CN_DISJOINT_NET_ENTRY_b_get, _pcbnew.CN_DISJOINT_NET_ENTRY_b_set)
    __swig_setmethods__["anchorA"] = _pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_set
    __swig_getmethods__["anchorA"] = _pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_get
    if _newclass:
        anchorA = _swig_property(_pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_get, _pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_set)
    __swig_setmethods__["anchorB"] = _pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_set
    __swig_getmethods__["anchorB"] = _pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_get
    if _newclass:
        anchorB = _swig_property(_pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_get, _pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_set)

    def __init__(self):
        """__init__(CN_DISJOINT_NET_ENTRY self) -> CN_DISJOINT_NET_ENTRY"""
        this = _pcbnew.new_CN_DISJOINT_NET_ENTRY()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_CN_DISJOINT_NET_ENTRY
    __del__ = lambda self: None
CN_DISJOINT_NET_ENTRY_swigregister = _pcbnew.CN_DISJOINT_NET_ENTRY_swigregister
CN_DISJOINT_NET_ENTRY_swigregister(CN_DISJOINT_NET_ENTRY)

class CN_ZONE_ISOLATED_ISLAND_LIST(_object):
    """Proxy of C++ CN_ZONE_ISOLATED_ISLAND_LIST class."""

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

    def __init__(self, aZone):
        """__init__(CN_ZONE_ISOLATED_ISLAND_LIST self, ZONE_CONTAINER aZone) -> CN_ZONE_ISOLATED_ISLAND_LIST"""
        this = _pcbnew.new_CN_ZONE_ISOLATED_ISLAND_LIST(aZone)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["m_zone"] = _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_set
    __swig_getmethods__["m_zone"] = _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_get
    if _newclass:
        m_zone = _swig_property(_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_get, _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_set)
    __swig_setmethods__["m_islands"] = _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_set
    __swig_getmethods__["m_islands"] = _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_get
    if _newclass:
        m_islands = _swig_property(_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_get, _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_set)
    __swig_destroy__ = _pcbnew.delete_CN_ZONE_ISOLATED_ISLAND_LIST
    __del__ = lambda self: None
CN_ZONE_ISOLATED_ISLAND_LIST_swigregister = _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_swigregister
CN_ZONE_ISOLATED_ISLAND_LIST_swigregister(CN_ZONE_ISOLATED_ISLAND_LIST)

class RN_DYNAMIC_LINE(_object):
    """Proxy of C++ RN_DYNAMIC_LINE class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RN_DYNAMIC_LINE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RN_DYNAMIC_LINE, name)
    __repr__ = _swig_repr
    __swig_setmethods__["netCode"] = _pcbnew.RN_DYNAMIC_LINE_netCode_set
    __swig_getmethods__["netCode"] = _pcbnew.RN_DYNAMIC_LINE_netCode_get
    if _newclass:
        netCode = _swig_property(_pcbnew.RN_DYNAMIC_LINE_netCode_get, _pcbnew.RN_DYNAMIC_LINE_netCode_set)
    __swig_setmethods__["a"] = _pcbnew.RN_DYNAMIC_LINE_a_set
    __swig_getmethods__["a"] = _pcbnew.RN_DYNAMIC_LINE_a_get
    if _newclass:
        a = _swig_property(_pcbnew.RN_DYNAMIC_LINE_a_get, _pcbnew.RN_DYNAMIC_LINE_a_set)
    __swig_setmethods__["b"] = _pcbnew.RN_DYNAMIC_LINE_b_set
    __swig_getmethods__["b"] = _pcbnew.RN_DYNAMIC_LINE_b_get
    if _newclass:
        b = _swig_property(_pcbnew.RN_DYNAMIC_LINE_b_get, _pcbnew.RN_DYNAMIC_LINE_b_set)

    def __init__(self):
        """__init__(RN_DYNAMIC_LINE self) -> RN_DYNAMIC_LINE"""
        this = _pcbnew.new_RN_DYNAMIC_LINE()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_RN_DYNAMIC_LINE
    __del__ = lambda self: None
RN_DYNAMIC_LINE_swigregister = _pcbnew.RN_DYNAMIC_LINE_swigregister
RN_DYNAMIC_LINE_swigregister(RN_DYNAMIC_LINE)

class CONNECTIVITY_DATA(_object):
    """Proxy of C++ CONNECTIVITY_DATA class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CONNECTIVITY_DATA, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CONNECTIVITY_DATA, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pcbnew.delete_CONNECTIVITY_DATA
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(CONNECTIVITY_DATA self) -> CONNECTIVITY_DATA
        __init__(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems) -> CONNECTIVITY_DATA
        """
        this = _pcbnew.new_CONNECTIVITY_DATA(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Build(self, *args):
        """
        Build(CONNECTIVITY_DATA self, BOARD aBoard)
        Build(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)
        """
        return _pcbnew.CONNECTIVITY_DATA_Build(self, *args)


    def Add(self, aItem):
        """Add(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Add(self, aItem)


    def Remove(self, aItem):
        """Remove(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Remove(self, aItem)


    def Update(self, aItem):
        """Update(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Update(self, aItem)


    def Clear(self):
        """Clear(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_Clear(self)


    def GetNetCount(self):
        """GetNetCount(CONNECTIVITY_DATA self) -> int"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetCount(self)


    def GetRatsnestForNet(self, aNet):
        """GetRatsnestForNet(CONNECTIVITY_DATA self, int aNet) -> RN_NET *"""
        return _pcbnew.CONNECTIVITY_DATA_GetRatsnestForNet(self, aNet)


    def PropagateNets(self):
        """PropagateNets(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_PropagateNets(self)


    def CheckConnectivity(self, aReport):
        """CheckConnectivity(CONNECTIVITY_DATA self, std::vector< CN_DISJOINT_NET_ENTRY,std::allocator< CN_DISJOINT_NET_ENTRY > > & aReport) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_CheckConnectivity(self, aReport)


    def FindIsolatedCopperIslands(self, *args):
        """
        FindIsolatedCopperIslands(CONNECTIVITY_DATA self, ZONE_CONTAINER aZone, intVector aIslands)
        FindIsolatedCopperIslands(CONNECTIVITY_DATA self, std::vector< CN_ZONE_ISOLATED_ISLAND_LIST,std::allocator< CN_ZONE_ISOLATED_ISLAND_LIST > > & aZones)
        """
        return _pcbnew.CONNECTIVITY_DATA_FindIsolatedCopperIslands(self, *args)


    def RecalculateRatsnest(self, aCommit=None):
        """
        RecalculateRatsnest(CONNECTIVITY_DATA self, BOARD_COMMIT * aCommit=None)
        RecalculateRatsnest(CONNECTIVITY_DATA self)
        """
        return _pcbnew.CONNECTIVITY_DATA_RecalculateRatsnest(self, aCommit)


    def GetUnconnectedCount(self):
        """GetUnconnectedCount(CONNECTIVITY_DATA self) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedCount(self)


    def GetNodeCount(self, aNet=-1):
        """
        GetNodeCount(CONNECTIVITY_DATA self, int aNet=-1) -> unsigned int
        GetNodeCount(CONNECTIVITY_DATA self) -> unsigned int
        """
        return _pcbnew.CONNECTIVITY_DATA_GetNodeCount(self, aNet)


    def GetPadCount(self, aNet=-1):
        """
        GetPadCount(CONNECTIVITY_DATA self, int aNet=-1) -> unsigned int
        GetPadCount(CONNECTIVITY_DATA self) -> unsigned int
        """
        return _pcbnew.CONNECTIVITY_DATA_GetPadCount(self, aNet)


    def GetConnectedTracks(self, aItem):
        """GetConnectedTracks(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem) -> TRACKS"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedTracks(self, aItem)


    def GetConnectedPads(self, *args):
        """
        GetConnectedPads(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem) -> D_PADS
        GetConnectedPads(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, std::set< D_PAD *,std::less< D_PAD * >,std::allocator< D_PAD * > > * pads) -> void const
        """
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedPads(self, *args)


    def GetUnconnectedEdges(self, aEdges):
        """GetUnconnectedEdges(CONNECTIVITY_DATA self, std::vector< CN_EDGE,std::allocator< CN_EDGE > > & aEdges)"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedEdges(self, aEdges)


    def ClearDynamicRatsnest(self):
        """ClearDynamicRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_ClearDynamicRatsnest(self)


    def HideDynamicRatsnest(self):
        """HideDynamicRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_HideDynamicRatsnest(self)


    def ComputeDynamicRatsnest(self, aItems):
        """ComputeDynamicRatsnest(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)"""
        return _pcbnew.CONNECTIVITY_DATA_ComputeDynamicRatsnest(self, aItems)


    def GetDynamicRatsnest(self):
        """GetDynamicRatsnest(CONNECTIVITY_DATA self) -> std::vector< RN_DYNAMIC_LINE,std::allocator< RN_DYNAMIC_LINE > > const &"""
        return _pcbnew.CONNECTIVITY_DATA_GetDynamicRatsnest(self)


    def GetConnectedItems(self, *args):
        """
        GetConnectedItems(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, VECTOR2I aAnchor, KICAD_T [] aTypes) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const
        GetConnectedItems(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, KICAD_T const [] aTypes, bool aIgnoreNetcodes=False) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const
        GetConnectedItems(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, KICAD_T const [] aTypes) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const
        """
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedItems(self, *args)


    def GetNetItems(self, aNetCode, aTypes):
        """GetNetItems(CONNECTIVITY_DATA self, int aNetCode, KICAD_T const [] aTypes) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetItems(self, aNetCode, aTypes)


    def NearestUnconnectedTargets(self, aRef, aPos, aMaxCount=-1):
        """
        NearestUnconnectedTargets(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aRef, VECTOR2I aPos, int aMaxCount=-1) -> std::vector< VECTOR2I,std::allocator< VECTOR2I > > const
        NearestUnconnectedTargets(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aRef, VECTOR2I aPos) -> std::vector< VECTOR2I,std::allocator< VECTOR2I > > const
        """
        return _pcbnew.CONNECTIVITY_DATA_NearestUnconnectedTargets(self, aRef, aPos, aMaxCount)


    def BlockRatsnestItems(self, aItems):
        """BlockRatsnestItems(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)"""
        return _pcbnew.CONNECTIVITY_DATA_BlockRatsnestItems(self, aItems)


    def GetConnectivityAlgo(self):
        """GetConnectivityAlgo(CONNECTIVITY_DATA self) -> std::shared_ptr< CN_CONNECTIVITY_ALGO >"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectivityAlgo(self)


    def GetLock(self):
        """GetLock(CONNECTIVITY_DATA self) -> std::mutex &"""
        return _pcbnew.CONNECTIVITY_DATA_GetLock(self)


    def MarkItemNetAsDirty(self, aItem):
        """MarkItemNetAsDirty(CONNECTIVITY_DATA self, BOARD_ITEM aItem)"""
        return _pcbnew.CONNECTIVITY_DATA_MarkItemNetAsDirty(self, aItem)


    def SetProgressReporter(self, aReporter):
        """SetProgressReporter(CONNECTIVITY_DATA self, PROGRESS_REPORTER * aReporter)"""
        return _pcbnew.CONNECTIVITY_DATA_SetProgressReporter(self, aReporter)

CONNECTIVITY_DATA_swigregister = _pcbnew.CONNECTIVITY_DATA_swigregister
CONNECTIVITY_DATA_swigregister(CONNECTIVITY_DATA)

PAD_SHAPE_CIRCLE = _pcbnew.PAD_SHAPE_CIRCLE
PAD_SHAPE_RECT = _pcbnew.PAD_SHAPE_RECT
PAD_SHAPE_OVAL = _pcbnew.PAD_SHAPE_OVAL
PAD_SHAPE_TRAPEZOID = _pcbnew.PAD_SHAPE_TRAPEZOID
PAD_SHAPE_ROUNDRECT = _pcbnew.PAD_SHAPE_ROUNDRECT
PAD_SHAPE_CUSTOM = _pcbnew.PAD_SHAPE_CUSTOM
PAD_DRILL_SHAPE_CIRCLE = _pcbnew.PAD_DRILL_SHAPE_CIRCLE
PAD_DRILL_SHAPE_OBLONG = _pcbnew.PAD_DRILL_SHAPE_OBLONG
PAD_ATTRIB_STANDARD = _pcbnew.PAD_ATTRIB_STANDARD
PAD_ATTRIB_SMD = _pcbnew.PAD_ATTRIB_SMD
PAD_ATTRIB_CONN = _pcbnew.PAD_ATTRIB_CONN
PAD_ATTRIB_HOLE_NOT_PLATED = _pcbnew.PAD_ATTRIB_HOLE_NOT_PLATED
CUST_PAD_SHAPE_IN_ZONE_OUTLINE = _pcbnew.CUST_PAD_SHAPE_IN_ZONE_OUTLINE
CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL = _pcbnew.CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL
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_NoNetMarkColor"] = _pcbnew.PAD_DRAWINFO_m_NoNetMarkColor_set
    __swig_getmethods__["m_NoNetMarkColor"] = _pcbnew.PAD_DRAWINFO_m_NoNetMarkColor_get
    if _newclass:
        m_NoNetMarkColor = _swig_property(_pcbnew.PAD_DRAWINFO_m_NoNetMarkColor_get, _pcbnew.PAD_DRAWINFO_m_NoNetMarkColor_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 __builtin__.Exception:
            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 PAD_CS_PRIMITIVE(_object):
    """Proxy of C++ PAD_CS_PRIMITIVE class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PAD_CS_PRIMITIVE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PAD_CS_PRIMITIVE, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Shape"] = _pcbnew.PAD_CS_PRIMITIVE_m_Shape_set
    __swig_getmethods__["m_Shape"] = _pcbnew.PAD_CS_PRIMITIVE_m_Shape_get
    if _newclass:
        m_Shape = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_Shape_get, _pcbnew.PAD_CS_PRIMITIVE_m_Shape_set)
    __swig_setmethods__["m_Thickness"] = _pcbnew.PAD_CS_PRIMITIVE_m_Thickness_set
    __swig_getmethods__["m_Thickness"] = _pcbnew.PAD_CS_PRIMITIVE_m_Thickness_get
    if _newclass:
        m_Thickness = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_Thickness_get, _pcbnew.PAD_CS_PRIMITIVE_m_Thickness_set)
    __swig_setmethods__["m_Radius"] = _pcbnew.PAD_CS_PRIMITIVE_m_Radius_set
    __swig_getmethods__["m_Radius"] = _pcbnew.PAD_CS_PRIMITIVE_m_Radius_get
    if _newclass:
        m_Radius = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_Radius_get, _pcbnew.PAD_CS_PRIMITIVE_m_Radius_set)
    __swig_setmethods__["m_ArcAngle"] = _pcbnew.PAD_CS_PRIMITIVE_m_ArcAngle_set
    __swig_getmethods__["m_ArcAngle"] = _pcbnew.PAD_CS_PRIMITIVE_m_ArcAngle_get
    if _newclass:
        m_ArcAngle = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_ArcAngle_get, _pcbnew.PAD_CS_PRIMITIVE_m_ArcAngle_set)
    __swig_setmethods__["m_Start"] = _pcbnew.PAD_CS_PRIMITIVE_m_Start_set
    __swig_getmethods__["m_Start"] = _pcbnew.PAD_CS_PRIMITIVE_m_Start_get
    if _newclass:
        m_Start = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_Start_get, _pcbnew.PAD_CS_PRIMITIVE_m_Start_set)
    __swig_setmethods__["m_End"] = _pcbnew.PAD_CS_PRIMITIVE_m_End_set
    __swig_getmethods__["m_End"] = _pcbnew.PAD_CS_PRIMITIVE_m_End_get
    if _newclass:
        m_End = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_End_get, _pcbnew.PAD_CS_PRIMITIVE_m_End_set)
    __swig_setmethods__["m_Poly"] = _pcbnew.PAD_CS_PRIMITIVE_m_Poly_set
    __swig_getmethods__["m_Poly"] = _pcbnew.PAD_CS_PRIMITIVE_m_Poly_get
    if _newclass:
        m_Poly = _swig_property(_pcbnew.PAD_CS_PRIMITIVE_m_Poly_get, _pcbnew.PAD_CS_PRIMITIVE_m_Poly_set)

    def __init__(self, aShape):
        """__init__(PAD_CS_PRIMITIVE self, STROKE_T aShape) -> PAD_CS_PRIMITIVE"""
        this = _pcbnew.new_PAD_CS_PRIMITIVE(aShape)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetCenter(self):
        """GetCenter(PAD_CS_PRIMITIVE self) -> wxPoint"""
        return _pcbnew.PAD_CS_PRIMITIVE_GetCenter(self)


    def GetArcStart(self):
        """GetArcStart(PAD_CS_PRIMITIVE self) -> wxPoint"""
        return _pcbnew.PAD_CS_PRIMITIVE_GetArcStart(self)


    def Move(self, aMoveVector):
        """Move(PAD_CS_PRIMITIVE self, wxPoint aMoveVector)"""
        return _pcbnew.PAD_CS_PRIMITIVE_Move(self, aMoveVector)


    def ExportTo(self, *args):
        """
        ExportTo(PAD_CS_PRIMITIVE self, DRAWSEGMENT aTarget)
        ExportTo(PAD_CS_PRIMITIVE self, EDGE_MODULE aTarget)
        """
        return _pcbnew.PAD_CS_PRIMITIVE_ExportTo(self, *args)

    __swig_destroy__ = _pcbnew.delete_PAD_CS_PRIMITIVE
    __del__ = lambda self: None
PAD_CS_PRIMITIVE_swigregister = _pcbnew.PAD_CS_PRIMITIVE_swigregister
PAD_CS_PRIMITIVE_swigregister(PAD_CS_PRIMITIVE)

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 __builtin__.Exception:
            self.this = this

    def StandardMask():
        """StandardMask() -> LSET"""
        return _pcbnew.D_PAD_StandardMask()

    StandardMask = staticmethod(StandardMask)

    def SMDMask():
        """SMDMask() -> LSET"""
        return _pcbnew.D_PAD_SMDMask()

    SMDMask = staticmethod(SMDMask)

    def ConnSMDMask():
        """ConnSMDMask() -> LSET"""
        return _pcbnew.D_PAD_ConnSMDMask()

    ConnSMDMask = staticmethod(ConnSMDMask)

    def UnplatedHoleMask():
        """UnplatedHoleMask() -> LSET"""
        return _pcbnew.D_PAD_UnplatedHoleMask()

    UnplatedHoleMask = staticmethod(UnplatedHoleMask)

    def ApertureMask():
        """ApertureMask() -> LSET"""
        return _pcbnew.D_PAD_ApertureMask()

    ApertureMask = staticmethod(ApertureMask)

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

    ClassOf = staticmethod(ClassOf)

    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 ImportSettingsFromMaster(self, aMasterPad):
        """ImportSettingsFromMaster(D_PAD self, D_PAD aMasterPad)"""
        return _pcbnew.D_PAD_ImportSettingsFromMaster(self, aMasterPad)


    def IsFlipped(self):
        """IsFlipped(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_IsFlipped(self)


    def SetName(self, aName):
        """SetName(D_PAD self, wxString aName)"""
        return _pcbnew.D_PAD_SetName(self, aName)


    def GetName(self):
        """GetName(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_GetName(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 GetAnchorPadShape(self):
        """GetAnchorPadShape(D_PAD self) -> PAD_SHAPE_T"""
        return _pcbnew.D_PAD_GetAnchorPadShape(self)


    def GetCustomShapeInZoneOpt(self):
        """GetCustomShapeInZoneOpt(D_PAD self) -> CUST_PAD_SHAPE_IN_ZONE"""
        return _pcbnew.D_PAD_GetCustomShapeInZoneOpt(self)


    def SetCustomShapeInZoneOpt(self, aOption):
        """SetCustomShapeInZoneOpt(D_PAD self, CUST_PAD_SHAPE_IN_ZONE aOption)"""
        return _pcbnew.D_PAD_SetCustomShapeInZoneOpt(self, aOption)


    def SetAnchorPadShape(self, aShape):
        """SetAnchorPadShape(D_PAD self, PAD_SHAPE_T aShape)"""
        return _pcbnew.D_PAD_SetAnchorPadShape(self, aShape)


    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 AddPrimitive(self, *args):
        """
        AddPrimitive(D_PAD self, SHAPE_POLY_SET aPoly, int aThickness)
        AddPrimitive(D_PAD self, wxPoint_Vector aPoly, int aThickness)
        AddPrimitive(D_PAD self, wxPoint aStart, wxPoint aEnd, int aThickness)
        AddPrimitive(D_PAD self, wxPoint aCenter, int aRadius, int aThickness)
        AddPrimitive(D_PAD self, wxPoint aCenter, wxPoint aStart, int aArcAngle, int aThickness)
        """
        return _pcbnew.D_PAD_AddPrimitive(self, *args)


    def GetBestAnchorPosition(self, aPos):
        """GetBestAnchorPosition(D_PAD self, VECTOR2I aPos) -> bool"""
        return _pcbnew.D_PAD_GetBestAnchorPosition(self, aPos)


    def MergePrimitivesAsPolygon(self, *args):
        """
        MergePrimitivesAsPolygon(D_PAD self, SHAPE_POLY_SET aMergedPolygon=None, int aCircleToSegmentsCount) -> bool
        MergePrimitivesAsPolygon(D_PAD self, SHAPE_POLY_SET aMergedPolygon=None) -> bool
        MergePrimitivesAsPolygon(D_PAD self) -> bool
        """
        return _pcbnew.D_PAD_MergePrimitivesAsPolygon(self, *args)


    def DeletePrimitivesList(self):
        """DeletePrimitivesList(D_PAD self)"""
        return _pcbnew.D_PAD_DeletePrimitivesList(self)


    def CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation):
        """CustomShapeAsPolygonToBoardPosition(D_PAD self, SHAPE_POLY_SET aMergedPolygon, wxPoint aPosition, double aRotation)"""
        return _pcbnew.D_PAD_CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation)


    def GetPrimitives(self):
        """GetPrimitives(D_PAD self) -> std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const &"""
        return _pcbnew.D_PAD_GetPrimitives(self)


    def GetCustomShapeAsPolygon(self):
        """GetCustomShapeAsPolygon(D_PAD self) -> SHAPE_POLY_SET"""
        return _pcbnew.D_PAD_GetCustomShapeAsPolygon(self)


    def Flip(self, aCentre):
        """Flip(D_PAD self, wxPoint aCentre)"""
        return _pcbnew.D_PAD_Flip(self, aCentre)


    def FlipPrimitives(self):
        """FlipPrimitives(D_PAD self)"""
        return _pcbnew.D_PAD_FlipPrimitives(self)


    def MirrorXPrimitives(self, aX):
        """MirrorXPrimitives(D_PAD self, int aX)"""
        return _pcbnew.D_PAD_MirrorXPrimitives(self, aX)


    def SetPrimitives(self, aPrimitivesList):
        """SetPrimitives(D_PAD self, std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const & aPrimitivesList) -> bool"""
        return _pcbnew.D_PAD_SetPrimitives(self, aPrimitivesList)


    def AddPrimitives(self, aPrimitivesList):
        """AddPrimitives(D_PAD self, std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const & aPrimitivesList) -> bool"""
        return _pcbnew.D_PAD_AddPrimitives(self, aPrimitivesList)


    def SetOrientation(self, aAngle):
        """SetOrientation(D_PAD self, double aAngle)"""
        return _pcbnew.D_PAD_SetOrientation(self, aAngle)


    def SetOrientationDegrees(self, aOrientation):
        """SetOrientationDegrees(D_PAD self, double aOrientation)"""
        return _pcbnew.D_PAD_SetOrientationDegrees(self, aOrientation)


    def GetOrientation(self):
        """GetOrientation(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientation(self)


    def GetOrientationDegrees(self):
        """GetOrientationDegrees(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientationDegrees(self)


    def GetOrientationRadians(self):
        """GetOrientationRadians(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientationRadians(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 IsAperturePad(self):
        """IsAperturePad(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_IsAperturePad(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, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(D_PAD self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(D_PAD self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.D_PAD_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    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 GetRoundRectCornerRadius(self, *args):
        """
        GetRoundRectCornerRadius(D_PAD self) -> int
        GetRoundRectCornerRadius(D_PAD self, wxSize aSize) -> int
        """
        return _pcbnew.D_PAD_GetRoundRectCornerRadius(self, *args)


    def SetRoundRectCornerRadius(self, aRadius):
        """SetRoundRectCornerRadius(D_PAD self, double aRadius)"""
        return _pcbnew.D_PAD_SetRoundRectCornerRadius(self, aRadius)


    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 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 GetRoundRectRadiusRatio(self):
        """GetRoundRectRadiusRatio(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetRoundRectRadiusRatio(self)


    def SetRoundRectRadiusRatio(self, aRadiusScale):
        """SetRoundRectRadiusRatio(D_PAD self, double aRadiusScale)"""
        return _pcbnew.D_PAD_SetRoundRectRadiusRatio(self, aRadiusScale)


    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, aUnits, aList):
        """GetMsgPanelInfo(D_PAD self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.D_PAD_GetMsgPanelInfo(self, aUnits, aList)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(D_PAD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.D_PAD_IsOnLayer(self, aLayer)


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


    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)

    Compare = staticmethod(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, aUnits):
        """GetSelectMenuText(D_PAD self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.D_PAD_GetSelectMenuText(self, aUnits)


    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 PadShouldBeNPTH(self):
        """PadShouldBeNPTH(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_PadShouldBeNPTH(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, aView):
        """ViewGetLOD(D_PAD self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.D_PAD_ViewGetLOD(self, aLayer, aView)


    def ViewBBox(self):
        """ViewBBox(D_PAD self) -> BOX2I const"""
        return _pcbnew.D_PAD_ViewBBox(self)


    def CopyNetlistSettings(self, aPad, aCopyLocalSettings):
        """CopyNetlistSettings(D_PAD self, D_PAD aPad, bool aCopyLocalSettings)"""
        return _pcbnew.D_PAD_CopyNetlistSettings(self, aPad, aCopyLocalSettings)


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



        # SetPadName() is the old name for D_PAD::SetName()
        # define it for compatibility
    def SetPadName(self, aName):
        return self.SetName(aName)

    # GetPadName() is the old name for D_PAD::GetName()
    # define it for compatibility
    def GetPadName(self):
        return self.GetName()


    __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_ApertureMask():
    """D_PAD_ApertureMask() -> LSET"""
    return _pcbnew.D_PAD_ApertureMask()

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)

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, Python 2 way to implement an iterator
            return self.__next__()

        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 __builtin__.Exception:
            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 ApertureMask(self):
        """ApertureMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_ApertureMask(self)


    def ClassOf(self, aItem):
        """ClassOf(PAD_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_List_ClassOf(self, aItem)


    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 ImportSettingsFromMaster(self, aMasterPad):
        """ImportSettingsFromMaster(PAD_List self, D_PAD aMasterPad)"""
        return _pcbnew.PAD_List_ImportSettingsFromMaster(self, aMasterPad)


    def IsFlipped(self):
        """IsFlipped(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsFlipped(self)


    def SetName(self, aName):
        """SetName(PAD_List self, wxString aName)"""
        return _pcbnew.PAD_List_SetName(self, aName)


    def GetName(self):
        """GetName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetName(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 GetAnchorPadShape(self):
        """GetAnchorPadShape(PAD_List self) -> PAD_SHAPE_T"""
        return _pcbnew.PAD_List_GetAnchorPadShape(self)


    def GetCustomShapeInZoneOpt(self):
        """GetCustomShapeInZoneOpt(PAD_List self) -> CUST_PAD_SHAPE_IN_ZONE"""
        return _pcbnew.PAD_List_GetCustomShapeInZoneOpt(self)


    def SetCustomShapeInZoneOpt(self, aOption):
        """SetCustomShapeInZoneOpt(PAD_List self, CUST_PAD_SHAPE_IN_ZONE aOption)"""
        return _pcbnew.PAD_List_SetCustomShapeInZoneOpt(self, aOption)


    def SetAnchorPadShape(self, aShape):
        """SetAnchorPadShape(PAD_List self, PAD_SHAPE_T aShape)"""
        return _pcbnew.PAD_List_SetAnchorPadShape(self, aShape)


    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 AddPrimitive(self, *args):
        """
        AddPrimitive(PAD_List self, SHAPE_POLY_SET aPoly, int aThickness)
        AddPrimitive(PAD_List self, wxPoint_Vector aPoly, int aThickness)
        AddPrimitive(PAD_List self, wxPoint aStart, wxPoint aEnd, int aThickness)
        AddPrimitive(PAD_List self, wxPoint aCenter, int aRadius, int aThickness)
        AddPrimitive(PAD_List self, wxPoint aCenter, wxPoint aStart, int aArcAngle, int aThickness)
        """
        return _pcbnew.PAD_List_AddPrimitive(self, *args)


    def GetBestAnchorPosition(self, aPos):
        """GetBestAnchorPosition(PAD_List self, VECTOR2I aPos) -> bool"""
        return _pcbnew.PAD_List_GetBestAnchorPosition(self, aPos)


    def MergePrimitivesAsPolygon(self, *args):
        """
        MergePrimitivesAsPolygon(PAD_List self, SHAPE_POLY_SET aMergedPolygon=None, int aCircleToSegmentsCount) -> bool
        MergePrimitivesAsPolygon(PAD_List self, SHAPE_POLY_SET aMergedPolygon=None) -> bool
        MergePrimitivesAsPolygon(PAD_List self) -> bool
        """
        return _pcbnew.PAD_List_MergePrimitivesAsPolygon(self, *args)


    def DeletePrimitivesList(self):
        """DeletePrimitivesList(PAD_List self)"""
        return _pcbnew.PAD_List_DeletePrimitivesList(self)


    def CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation):
        """CustomShapeAsPolygonToBoardPosition(PAD_List self, SHAPE_POLY_SET aMergedPolygon, wxPoint aPosition, double aRotation)"""
        return _pcbnew.PAD_List_CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation)


    def GetPrimitives(self):
        """GetPrimitives(PAD_List self) -> std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const &"""
        return _pcbnew.PAD_List_GetPrimitives(self)


    def GetCustomShapeAsPolygon(self):
        """GetCustomShapeAsPolygon(PAD_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.PAD_List_GetCustomShapeAsPolygon(self)


    def Flip(self, aCentre):
        """Flip(PAD_List self, wxPoint aCentre)"""
        return _pcbnew.PAD_List_Flip(self, aCentre)


    def FlipPrimitives(self):
        """FlipPrimitives(PAD_List self)"""
        return _pcbnew.PAD_List_FlipPrimitives(self)


    def MirrorXPrimitives(self, aX):
        """MirrorXPrimitives(PAD_List self, int aX)"""
        return _pcbnew.PAD_List_MirrorXPrimitives(self, aX)


    def SetPrimitives(self, aPrimitivesList):
        """SetPrimitives(PAD_List self, std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const & aPrimitivesList) -> bool"""
        return _pcbnew.PAD_List_SetPrimitives(self, aPrimitivesList)


    def AddPrimitives(self, aPrimitivesList):
        """AddPrimitives(PAD_List self, std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const & aPrimitivesList) -> bool"""
        return _pcbnew.PAD_List_AddPrimitives(self, aPrimitivesList)


    def SetOrientation(self, aAngle):
        """SetOrientation(PAD_List self, double aAngle)"""
        return _pcbnew.PAD_List_SetOrientation(self, aAngle)


    def SetOrientationDegrees(self, aOrientation):
        """SetOrientationDegrees(PAD_List self, double aOrientation)"""
        return _pcbnew.PAD_List_SetOrientationDegrees(self, aOrientation)


    def GetOrientation(self):
        """GetOrientation(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientation(self)


    def GetOrientationDegrees(self):
        """GetOrientationDegrees(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientationDegrees(self)


    def GetOrientationRadians(self):
        """GetOrientationRadians(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientationRadians(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 IsAperturePad(self):
        """IsAperturePad(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsAperturePad(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, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(PAD_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(PAD_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.PAD_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    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 GetRoundRectCornerRadius(self, *args):
        """
        GetRoundRectCornerRadius(PAD_List self) -> int
        GetRoundRectCornerRadius(PAD_List self, wxSize aSize) -> int
        """
        return _pcbnew.PAD_List_GetRoundRectCornerRadius(self, *args)


    def SetRoundRectCornerRadius(self, aRadius):
        """SetRoundRectCornerRadius(PAD_List self, double aRadius)"""
        return _pcbnew.PAD_List_SetRoundRectCornerRadius(self, aRadius)


    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 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 GetRoundRectRadiusRatio(self):
        """GetRoundRectRadiusRatio(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetRoundRectRadiusRatio(self)


    def SetRoundRectRadiusRatio(self, aRadiusScale):
        """SetRoundRectRadiusRatio(PAD_List self, double aRadiusScale)"""
        return _pcbnew.PAD_List_SetRoundRectRadiusRatio(self, aRadiusScale)


    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, aUnits, aList):
        """GetMsgPanelInfo(PAD_List self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PAD_List_GetMsgPanelInfo(self, aUnits, aList)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(PAD_List self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PAD_List_IsOnLayer(self, aLayer)


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


    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, aUnits):
        """GetSelectMenuText(PAD_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.PAD_List_GetSelectMenuText(self, aUnits)


    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 PadShouldBeNPTH(self):
        """PadShouldBeNPTH(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_PadShouldBeNPTH(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, aView):
        """ViewGetLOD(PAD_List self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.PAD_List_ViewGetLOD(self, aLayer, aView)


    def ViewBBox(self):
        """ViewBBox(PAD_List self) -> BOX2I const"""
        return _pcbnew.PAD_List_ViewBBox(self)


    def CopyNetlistSettings(self, aPad, aCopyLocalSettings):
        """CopyNetlistSettings(PAD_List self, D_PAD aPad, bool aCopyLocalSettings)"""
        return _pcbnew.PAD_List_CopyNetlistSettings(self, aPad, aCopyLocalSettings)


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


    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 SetNet(self, aNetInfo):
        """SetNet(PAD_List self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.PAD_List_SetNet(self, aNetInfo)


    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 GetNetname(self):
        """GetNetname(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetname(self)


    def GetNetnameMsg(self):
        """GetNetnameMsg(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetnameMsg(self)


    def GetShortNetname(self):
        """GetShortNetname(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetShortNetname(self)


    def GetNetClass(self):
        """GetNetClass(PAD_List self) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.PAD_List_GetNetClass(self)


    def GetNetClassName(self):
        """GetNetClassName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetClassName(self)


    def SetLocalRatsnestVisible(self, aVisible):
        """SetLocalRatsnestVisible(PAD_List self, bool aVisible)"""
        return _pcbnew.PAD_List_SetLocalRatsnestVisible(self, aVisible)


    def GetLocalRatsnestVisible(self):
        """GetLocalRatsnestVisible(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_GetLocalRatsnestVisible(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) -> PCB_LAYER_ID"""
        return _pcbnew.PAD_List_GetLayer(self)


    def SetLayer(self, aLayer):
        """SetLayer(PAD_List self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PAD_List_SetLayer(self, aLayer)


    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 SetLocked(self, aLocked):
        """SetLocked(PAD_List self, bool aLocked)"""
        return _pcbnew.PAD_List_SetLocked(self, aLocked)


    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 Type(self):
        """Type(PAD_List self) -> KICAD_T"""
        return _pcbnew.PAD_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(PAD_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.PAD_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(PAD_List self) -> timestamp_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 IsType(self, aScanTypes):
        """IsType(PAD_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PAD_List_IsType(self, aScanTypes)


    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 * 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 * 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)

VIA_THROUGH = _pcbnew.VIA_THROUGH
VIA_BLIND_BURIED = _pcbnew.VIA_BLIND_BURIED
VIA_MICROVIA = _pcbnew.VIA_MICROVIA
VIA_NOT_DEFINED = _pcbnew.VIA_NOT_DEFINED
UNDEFINED_DRILL_DIAMETER = _pcbnew.UNDEFINED_DRILL_DIAMETER
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)

    ClassOf = staticmethod(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, aParent, idtype=PCB_TRACE_T):
        """
        __init__(TRACK self, BOARD_ITEM aParent, KICAD_T idtype=PCB_TRACE_T) -> TRACK
        __init__(TRACK self, BOARD_ITEM aParent) -> TRACK
        """
        this = _pcbnew.new_TRACK(aParent, idtype)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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 IsLocked(self):
        """IsLocked(TRACK self) -> bool"""
        return _pcbnew.TRACK_IsLocked(self)


    def SetLocked(self, aLocked):
        """SetLocked(TRACK self, bool aLocked)"""
        return _pcbnew.TRACK_SetLocked(self, aLocked)


    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, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(TRACK self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(TRACK self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.TRACK_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    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, aUnits, aList):
        """GetMsgPanelInfo(TRACK self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TRACK_GetMsgPanelInfo(self, aUnits, aList)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(TRACK self, INSPECTOR inspector, void * 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, PCB_LAYER_ID aLayer=UNDEFINED_LAYER) -> 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, aUnits):
        """GetSelectMenuText(TRACK self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TRACK_GetSelectMenuText(self, aUnits)


    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, aView):
        """ViewGetLOD(TRACK self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.TRACK_ViewGetLOD(self, aLayer, aView)


    def ViewBBox(self):
        """ViewBBox(TRACK self) -> BOX2I const"""
        return _pcbnew.TRACK_ViewBBox(self)


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

    __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 __builtin__.Exception:
            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, aUnits):
        """GetSelectMenuText(SEGZONE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.SEGZONE_GetSelectMenuText(self, aUnits)


    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 __builtin__.Exception:
            self.this = this

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

    ClassOf = staticmethod(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, PCB_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, PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)"""
        return _pcbnew.VIA_SetLayerPair(self, aTopLayer, aBottomLayer)


    def SetBottomLayer(self, aLayer):
        """SetBottomLayer(VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.VIA_SetBottomLayer(self, aLayer)


    def SetTopLayer(self, aLayer):
        """SetTopLayer(VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.VIA_SetTopLayer(self, aLayer)


    def LayerPair(self, top_layer, bottom_layer):
        """LayerPair(VIA self, PCB_LAYER_ID * top_layer, PCB_LAYER_ID * bottom_layer)"""
        return _pcbnew.VIA_LayerPair(self, top_layer, bottom_layer)


    def TopLayer(self):
        """TopLayer(VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.VIA_TopLayer(self)


    def BottomLayer(self):
        """BottomLayer(VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.VIA_BottomLayer(self)


    def SanitizeLayers(self):
        """SanitizeLayers(VIA self)"""
        return _pcbnew.VIA_SanitizeLayers(self)


    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, aUnits):
        """GetSelectMenuText(VIA self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.VIA_GetSelectMenuText(self, aUnits)


    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 ViewGetLOD(self, aLayer, aView):
        """ViewGetLOD(VIA self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.VIA_ViewGetLOD(self, aLayer, aView)


    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)


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

    __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)

def GetFirstTrack(aTrk, aStopPoint=None):
    """
    GetFirstTrack(TRACK aTrk, TRACK aStopPoint=None) -> TRACK
    GetFirstTrack(TRACK aTrk) -> TRACK
    """
    return _pcbnew.GetFirstTrack(aTrk, aStopPoint)
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, Python 2 way to implement an iterator
            return self.__next__()

        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 __builtin__.Exception:
            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 IsLocked(self):
        """IsLocked(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsLocked(self)


    def SetLocked(self, aLocked):
        """SetLocked(TRACK_List self, bool aLocked)"""
        return _pcbnew.TRACK_List_SetLocked(self, aLocked)


    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, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(TRACK_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(TRACK_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.TRACK_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    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, aUnits, aList):
        """GetMsgPanelInfo(TRACK_List self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TRACK_List_GetMsgPanelInfo(self, aUnits, aList)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(TRACK_List self, INSPECTOR inspector, void * 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, PCB_LAYER_ID aLayer=UNDEFINED_LAYER) -> 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, aUnits):
        """GetSelectMenuText(TRACK_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TRACK_List_GetSelectMenuText(self, aUnits)


    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, aView):
        """ViewGetLOD(TRACK_List self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.TRACK_List_ViewGetLOD(self, aLayer, aView)


    def ViewBBox(self):
        """ViewBBox(TRACK_List self) -> BOX2I const"""
        return _pcbnew.TRACK_List_ViewBBox(self)


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


    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 SetNet(self, aNetInfo):
        """SetNet(TRACK_List self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.TRACK_List_SetNet(self, aNetInfo)


    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 GetNetname(self):
        """GetNetname(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetname(self)


    def GetNetnameMsg(self):
        """GetNetnameMsg(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetnameMsg(self)


    def GetShortNetname(self):
        """GetShortNetname(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetShortNetname(self)


    def GetNetClass(self):
        """GetNetClass(TRACK_List self) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.TRACK_List_GetNetClass(self)


    def GetNetClassName(self):
        """GetNetClassName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetClassName(self)


    def SetLocalRatsnestVisible(self, aVisible):
        """SetLocalRatsnestVisible(TRACK_List self, bool aVisible)"""
        return _pcbnew.TRACK_List_SetLocalRatsnestVisible(self, aVisible)


    def GetLocalRatsnestVisible(self):
        """GetLocalRatsnestVisible(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_GetLocalRatsnestVisible(self)


    def GetCenter(self):
        """GetCenter(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetCenter(self)


    def GetParent(self):
        """GetParent(TRACK_List self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.TRACK_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(TRACK_List self) -> PCB_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, PCB_LAYER_ID aLayer)"""
        return _pcbnew.TRACK_List_SetLayer(self, aLayer)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(TRACK_List self, PCB_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 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 Type(self):
        """Type(TRACK_List self) -> KICAD_T"""
        return _pcbnew.TRACK_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(TRACK_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.TRACK_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(TRACK_List self) -> timestamp_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 IsType(self, aScanTypes):
        """IsType(TRACK_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.TRACK_List_IsType(self, aScanTypes)


    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 * 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)

TRACK_List_swigregister = _pcbnew.TRACK_List_swigregister
TRACK_List_swigregister(TRACK_List)

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
    NO_HATCH = _pcbnew.ZONE_CONTAINER_NO_HATCH
    DIAGONAL_FULL = _pcbnew.ZONE_CONTAINER_DIAGONAL_FULL
    DIAGONAL_EDGE = _pcbnew.ZONE_CONTAINER_DIAGONAL_EDGE

    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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_ZONE_CONTAINER
    __del__ = lambda self: None

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

    ClassOf = staticmethod(ClassOf)

    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 GetMsgPanelInfo(self, aUnits, aList):
        """GetMsgPanelInfo(ZONE_CONTAINER self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.ZONE_CONTAINER_GetMsgPanelInfo(self, aUnits, aList)


    def SetLayerSet(self, aLayerSet):
        """SetLayerSet(ZONE_CONTAINER self, LSET aLayerSet)"""
        return _pcbnew.ZONE_CONTAINER_SetLayerSet(self, aLayerSet)


    def GetLayerSet(self):
        """GetLayerSet(ZONE_CONTAINER self) -> LSET"""
        return _pcbnew.ZONE_CONTAINER_GetLayerSet(self)


    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 IsOnCopperLayer(self):
        """IsOnCopperLayer(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsOnCopperLayer(self)


    def CommonLayerExists(self, aLayerSet):
        """CommonLayerExists(ZONE_CONTAINER self, LSET aLayerSet) -> bool"""
        return _pcbnew.ZONE_CONTAINER_CommonLayerExists(self, aLayerSet)


    def SetLayer(self, aLayer):
        """SetLayer(ZONE_CONTAINER self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.ZONE_CONTAINER_SetLayer(self, aLayer)


    def GetLayer(self):
        """GetLayer(ZONE_CONTAINER self) -> PCB_LAYER_ID"""
        return _pcbnew.ZONE_CONTAINER_GetLayer(self)


    def IsOnLayer(self, arg2):
        """IsOnLayer(ZONE_CONTAINER self, PCB_LAYER_ID arg2) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsOnLayer(self, arg2)


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


    def SetFillMode(self, aFillMode):
        """SetFillMode(ZONE_CONTAINER self, ZONE_FILL_MODE aFillMode)"""
        return _pcbnew.ZONE_CONTAINER_SetFillMode(self, aFillMode)


    def GetFillMode(self):
        """GetFillMode(ZONE_CONTAINER self) -> ZONE_FILL_MODE"""
        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, int aAccuracy)
        """
        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) -> ZONE_SEGMENT_FILL
        FillSegments(ZONE_CONTAINER self) -> ZONE_SEGMENT_FILL const &
        """
        return _pcbnew.ZONE_CONTAINER_FillSegments(self, *args)


    def Outline(self, *args):
        """
        Outline(ZONE_CONTAINER self) -> SHAPE_POLY_SET
        Outline(ZONE_CONTAINER self) -> SHAPE_POLY_SET
        """
        return _pcbnew.ZONE_CONTAINER_Outline(self, *args)


    def SetOutline(self, aOutline):
        """SetOutline(ZONE_CONTAINER self, SHAPE_POLY_SET 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 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 TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.ZONE_CONTAINER_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    def HitTestForCorner(self, *args):
        """
        HitTestForCorner(ZONE_CONTAINER self, wxPoint refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX & aCornerHit) -> bool
        HitTestForCorner(ZONE_CONTAINER self, wxPoint refPos, int aAccuracy) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_HitTestForCorner(self, *args)


    def HitTestForEdge(self, *args):
        """
        HitTestForEdge(ZONE_CONTAINER self, wxPoint refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX & aCornerHit) -> bool
        HitTestForEdge(ZONE_CONTAINER self, wxPoint refPos, int aAccuracy) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_HitTestForEdge(self, *args)


    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 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 Iterate(self):
        """Iterate(ZONE_CONTAINER self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_CONTAINER_Iterate(self)


    def IterateWithHoles(self):
        """IterateWithHoles(ZONE_CONTAINER self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_CONTAINER_IterateWithHoles(self)


    def CIterateWithHoles(self):
        """CIterateWithHoles(ZONE_CONTAINER self) -> SHAPE_POLY_SET::CONST_ITERATOR"""
        return _pcbnew.ZONE_CONTAINER_CIterateWithHoles(self)


    def RemoveAllContours(self):
        """RemoveAllContours(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_RemoveAllContours(self)


    def GetCornerPosition(self, aCornerIndex):
        """GetCornerPosition(ZONE_CONTAINER self, int aCornerIndex) -> VECTOR2I"""
        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 NewHole(self):
        """NewHole(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_NewHole(self)


    def AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication=False):
        """
        AppendCorner(ZONE_CONTAINER self, wxPoint aPosition, int aHoleIdx, bool aAllowDuplication=False) -> bool
        AppendCorner(ZONE_CONTAINER self, wxPoint aPosition, int aHoleIdx) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication)


    def GetHatchStyle(self):
        """GetHatchStyle(ZONE_CONTAINER self) -> ZONE_CONTAINER::HATCH_STYLE"""
        return _pcbnew.ZONE_CONTAINER_GetHatchStyle(self)


    def SetHatchStyle(self, aStyle):
        """SetHatchStyle(ZONE_CONTAINER self, ZONE_CONTAINER::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"""
        return _pcbnew.ZONE_CONTAINER_GetFilledPolysList(self)


    def CacheTriangulation(self):
        """CacheTriangulation(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_CacheTriangulation(self)


    def SetFilledPolysList(self, aPolysList):
        """SetFilledPolysList(ZONE_CONTAINER self, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_CONTAINER_SetFilledPolysList(self, aPolysList)


    def SetRawPolysList(self, aPolysList):
        """SetRawPolysList(ZONE_CONTAINER self, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_CONTAINER_SetRawPolysList(self, aPolysList)


    def BuildSmoothedPoly(self, aSmoothedPoly):
        """BuildSmoothedPoly(ZONE_CONTAINER self, SHAPE_POLY_SET aSmoothedPoly) -> bool"""
        return _pcbnew.ZONE_CONTAINER_BuildSmoothedPoly(self, aSmoothedPoly)


    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, *args):
        """
        AddPolygon(ZONE_CONTAINER self, wxPoint_Vector aPolygon)
        AddPolygon(ZONE_CONTAINER self, SHAPE_LINE_CHAIN aPolygon)
        """
        return _pcbnew.ZONE_CONTAINER_AddPolygon(self, *args)


    def SetFillSegments(self, aSegments):
        """SetFillSegments(ZONE_CONTAINER self, ZONE_SEGMENT_FILL const & aSegments)"""
        return _pcbnew.ZONE_CONTAINER_SetFillSegments(self, aSegments)


    def RawPolysList(self):
        """RawPolysList(ZONE_CONTAINER self) -> SHAPE_POLY_SET"""
        return _pcbnew.ZONE_CONTAINER_RawPolysList(self)


    def GetSelectMenuText(self, aUnits):
        """GetSelectMenuText(ZONE_CONTAINER self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetSelectMenuText(self, aUnits)


    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)


    def GetHatchPitch(self):
        """GetHatchPitch(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetHatchPitch(self)


    def GetDefaultHatchPitch():
        """GetDefaultHatchPitch() -> int"""
        return _pcbnew.ZONE_CONTAINER_GetDefaultHatchPitch()

    GetDefaultHatchPitch = staticmethod(GetDefaultHatchPitch)

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


    def SetHatchPitch(self, aPitch):
        """SetHatchPitch(ZONE_CONTAINER self, int aPitch)"""
        return _pcbnew.ZONE_CONTAINER_SetHatchPitch(self, aPitch)


    def UnHatch(self):
        """UnHatch(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_UnHatch(self)


    def Hatch(self):
        """Hatch(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_Hatch(self)


    def GetHatchLines(self):
        """GetHatchLines(ZONE_CONTAINER self) -> std::vector< SEG,std::allocator< SEG > > const &"""
        return _pcbnew.ZONE_CONTAINER_GetHatchLines(self)


    def GetHV45(self):
        """GetHV45(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetHV45(self)


    def SetHV45(self, aConstrain):
        """SetHV45(ZONE_CONTAINER self, bool aConstrain)"""
        return _pcbnew.ZONE_CONTAINER_SetHV45(self, aConstrain)


    def GetHashValue(self):
        """GetHashValue(ZONE_CONTAINER self) -> MD5_HASH"""
        return _pcbnew.ZONE_CONTAINER_GetHashValue(self)


    def BuildHashValue(self):
        """BuildHashValue(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_BuildHashValue(self)


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

ZONE_CONTAINER_swigregister = _pcbnew.ZONE_CONTAINER_swigregister
ZONE_CONTAINER_swigregister(ZONE_CONTAINER)

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

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

ZONE_THERMAL_RELIEF_GAP_MIL = _pcbnew.ZONE_THERMAL_RELIEF_GAP_MIL
ZONE_THERMAL_RELIEF_COPPER_WIDTH_MIL = _pcbnew.ZONE_THERMAL_RELIEF_COPPER_WIDTH_MIL
ZONE_THICKNESS_MIL = _pcbnew.ZONE_THICKNESS_MIL
ZONE_THICKNESS_MIN_VALUE_MIL = _pcbnew.ZONE_THICKNESS_MIN_VALUE_MIL
ZONE_CLEARANCE_MIL = _pcbnew.ZONE_CLEARANCE_MIL
ZONE_CLEARANCE_MAX_VALUE_MIL = _pcbnew.ZONE_CLEARANCE_MAX_VALUE_MIL
ZONE_EXPORT_VALUES = _pcbnew.ZONE_EXPORT_VALUES
PAD_ZONE_CONN_INHERITED = _pcbnew.PAD_ZONE_CONN_INHERITED
PAD_ZONE_CONN_NONE = _pcbnew.PAD_ZONE_CONN_NONE
PAD_ZONE_CONN_THERMAL = _pcbnew.PAD_ZONE_CONN_THERMAL
PAD_ZONE_CONN_FULL = _pcbnew.PAD_ZONE_CONN_FULL
PAD_ZONE_CONN_THT_THERMAL = _pcbnew.PAD_ZONE_CONN_THT_THERMAL

def InvokeNonCopperZonesEditor(aParent, aSettings):
    """InvokeNonCopperZonesEditor(PCB_BASE_FRAME * aParent, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeNonCopperZonesEditor(aParent, aSettings)

def InvokeCopperZonesEditor(aCaller, aSettings):
    """InvokeCopperZonesEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeCopperZonesEditor(aCaller, aSettings)

def InvokeKeepoutAreaEditor(aCaller, aSettings):
    """InvokeKeepoutAreaEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeKeepoutAreaEditor(aCaller, aSettings)
class ZONE_FILLER(_object):
    """Proxy of C++ ZONE_FILLER class."""

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

    def __init__(self, aBoard, aCommit=None):
        """
        __init__(ZONE_FILLER self, BOARD aBoard, COMMIT * aCommit=None) -> ZONE_FILLER
        __init__(ZONE_FILLER self, BOARD aBoard) -> ZONE_FILLER
        """
        this = _pcbnew.new_ZONE_FILLER(aBoard, aCommit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_ZONE_FILLER
    __del__ = lambda self: None

    def SetProgressReporter(self, *args):
        """
        SetProgressReporter(ZONE_FILLER self, WX_PROGRESS_REPORTER * aReporter)
        SetProgressReporter(ZONE_FILLER self, std::unique_ptr< WX_PROGRESS_REPORTER > && aReporter)
        """
        return _pcbnew.ZONE_FILLER_SetProgressReporter(self, *args)


    def Fill(self, aZones, aCheck=False):
        """
        Fill(ZONE_FILLER self, ZONE_CONTAINERS aZones, bool aCheck=False) -> bool
        Fill(ZONE_FILLER self, ZONE_CONTAINERS aZones) -> bool
        """
        return _pcbnew.ZONE_FILLER_Fill(self, aZones, aCheck)

ZONE_FILLER_swigregister = _pcbnew.ZONE_FILLER_swigregister
ZONE_FILLER_swigregister(ZONE_FILLER)

ZFM_POLYGONS = _pcbnew.ZFM_POLYGONS
ZFM_SEGMENTS = _pcbnew.ZFM_SEGMENTS
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_UNDEFINED = _pcbnew.ZONE_SETTINGS_SMOOTHING_UNDEFINED
    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_Layers"] = _pcbnew.ZONE_SETTINGS_m_Layers_set
    __swig_getmethods__["m_Layers"] = _pcbnew.ZONE_SETTINGS_m_Layers_get
    if _newclass:
        m_Layers = _swig_property(_pcbnew.ZONE_SETTINGS_m_Layers_get, _pcbnew.ZONE_SETTINGS_m_Layers_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 __builtin__.Exception:
            self.this = this

    def __lshift__(self, aSource):
        """__lshift__(ZONE_SETTINGS self, ZONE_CONTAINER aSource) -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS___lshift__(self, aSource)


    def SetupLayersList(self, aList, aFrame, aShowCopper):
        """SetupLayersList(ZONE_SETTINGS self, wxDataViewListCtrl * aList, PCB_BASE_FRAME * aFrame, bool aShowCopper)"""
        return _pcbnew.ZONE_SETTINGS_SetupLayersList(self, aList, aFrame, aShowCopper)


    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 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 __builtin__.Exception:
            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)

    ClassOf = staticmethod(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 SetTextAngle(self, aAngle):
        """SetTextAngle(TEXTE_PCB self, double aAngle)"""
        return _pcbnew.TEXTE_PCB_SetTextAngle(self, aAngle)


    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 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, aUnits, aList):
        """GetMsgPanelInfo(TEXTE_PCB self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TEXTE_PCB_GetMsgPanelInfo(self, aUnits, 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 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, aUnits):
        """GetSelectMenuText(TEXTE_PCB self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TEXTE_PCB_GetSelectMenuText(self, aUnits)


    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)


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

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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_DIMENSION
    __del__ = lambda self: None

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

    ClassOf = staticmethod(ClassOf)

    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, PCB_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):
        """AdjustDimensionDetails(DIMENSION self)"""
        return _pcbnew.DIMENSION_AdjustDimensionDetails(self)


    def GetUnits(self, aUnits, aUseMils):
        """GetUnits(DIMENSION self, EDA_UNITS_T & aUnits, bool & aUseMils)"""
        return _pcbnew.DIMENSION_GetUnits(self, aUnits, aUseMils)


    def SetUnits(self, aUnits, aUseMils):
        """SetUnits(DIMENSION self, EDA_UNITS_T aUnits, bool aUseMils)"""
        return _pcbnew.DIMENSION_SetUnits(self, aUnits, aUseMils)


    def SetText(self, NewText):
        """SetText(DIMENSION self, wxString NewText)"""
        return _pcbnew.DIMENSION_SetText(self, NewText)


    def GetText(self):
        """GetText(DIMENSION self) -> wxString"""
        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 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, aUnits, aList):
        """GetMsgPanelInfo(DIMENSION self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.DIMENSION_GetMsgPanelInfo(self, aUnits, 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, aUnits):
        """GetSelectMenuText(DIMENSION self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.DIMENSION_GetSelectMenuText(self, aUnits)


    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)


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

DIMENSION_swigregister = _pcbnew.DIMENSION_swigregister
DIMENSION_swigregister(DIMENSION)

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

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, aParent=None, idtype=PCB_LINE_T):
        """
        __init__(DRAWSEGMENT self, BOARD_ITEM aParent=None, KICAD_T idtype=PCB_LINE_T) -> DRAWSEGMENT
        __init__(DRAWSEGMENT self, BOARD_ITEM aParent=None) -> DRAWSEGMENT
        __init__(DRAWSEGMENT self) -> DRAWSEGMENT
        """
        this = _pcbnew.new_DRAWSEGMENT(aParent, idtype)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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)

    ClassOf = staticmethod(ClassOf)

    def IsPolygonFilled(self):
        """IsPolygonFilled(DRAWSEGMENT self) -> bool"""
        return _pcbnew.DRAWSEGMENT_IsPolygonFilled(self)


    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 BuildPolyPointsList(self):
        """BuildPolyPointsList(DRAWSEGMENT self) -> wxPoint_Vector"""
        return _pcbnew.DRAWSEGMENT_BuildPolyPointsList(self)


    def GetPointCount(self):
        """GetPointCount(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetPointCount(self)


    def GetPolyShape(self, *args):
        """
        GetPolyShape(DRAWSEGMENT self) -> SHAPE_POLY_SET
        GetPolyShape(DRAWSEGMENT self) -> SHAPE_POLY_SET
        """
        return _pcbnew.DRAWSEGMENT_GetPolyShape(self, *args)


    def IsPolyShapeValid(self):
        """IsPolyShapeValid(DRAWSEGMENT self) -> bool"""
        return _pcbnew.DRAWSEGMENT_IsPolyShapeValid(self)


    def SetPolyShape(self, aShape):
        """SetPolyShape(DRAWSEGMENT self, SHAPE_POLY_SET aShape)"""
        return _pcbnew.DRAWSEGMENT_SetPolyShape(self, aShape)


    def SetBezierPoints(self, aPoints):
        """SetBezierPoints(DRAWSEGMENT self, wxPoint_Vector aPoints)"""
        return _pcbnew.DRAWSEGMENT_SetBezierPoints(self, aPoints)


    def RebuildBezierToSegmentsPointsList(self, aMinSegLen):
        """RebuildBezierToSegmentsPointsList(DRAWSEGMENT self, int aMinSegLen)"""
        return _pcbnew.DRAWSEGMENT_RebuildBezierToSegmentsPointsList(self, aMinSegLen)


    def SetPolyPoints(self, aPoints):
        """SetPolyPoints(DRAWSEGMENT self, wxPoint_Vector aPoints)"""
        return _pcbnew.DRAWSEGMENT_SetPolyPoints(self, aPoints)


    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, aUnits, aList):
        """GetMsgPanelInfo(DRAWSEGMENT self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.DRAWSEGMENT_GetMsgPanelInfo(self, aUnits, 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, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(DRAWSEGMENT self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(DRAWSEGMENT self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.DRAWSEGMENT_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    def GetSelectMenuText(self, aUnits):
        """GetSelectMenuText(DRAWSEGMENT self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.DRAWSEGMENT_GetSelectMenuText(self, aUnits)


    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 ViewBBox(self):
        """ViewBBox(DRAWSEGMENT self) -> BOX2I const"""
        return _pcbnew.DRAWSEGMENT_ViewBBox(self)


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


    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)

MARKER_SHAPE_POINT_COUNT = _pcbnew.MARKER_SHAPE_POINT_COUNT
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, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, BOARD_ITEM aItem, wxPoint aPos, BOARD_ITEM bItem=None, wxPoint bPos) -> MARKER_PCB
        __init__(MARKER_PCB self, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, BOARD_ITEM aItem, wxPoint aPos, BOARD_ITEM bItem=None) -> MARKER_PCB
        __init__(MARKER_PCB self, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, BOARD_ITEM aItem, wxPoint aPos) -> MARKER_PCB
        __init__(MARKER_PCB self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos) -> MARKER_PCB
        __init__(MARKER_PCB self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText) -> MARKER_PCB
        __init__(MARKER_PCB self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos) -> MARKER_PCB
        """
        this = _pcbnew.new_MARKER_PCB(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MARKER_PCB
    __del__ = lambda self: None

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

    ClassOf = staticmethod(ClassOf)

    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 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, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.MARKER_PCB_IsOnLayer(self, aLayer)


    def GetMsgPanelInfo(self, aUnits, aList):
        """GetMsgPanelInfo(MARKER_PCB self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MARKER_PCB_GetMsgPanelInfo(self, aUnits, aList)


    def GetSelectMenuText(self, aUnits):
        """GetSelectMenuText(MARKER_PCB self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.MARKER_PCB_GetSelectMenuText(self, aUnits)


    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 GetBoundingBox(self):
        """GetBoundingBox(MARKER_PCB self) -> EDA_RECT"""
        return _pcbnew.MARKER_PCB_GetBoundingBox(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)

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

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, PCB_LAYER_ID aLayer, wxPoint aPos, int aSize, int aWidth) -> PCB_TARGET
        """
        this = _pcbnew.new_PCB_TARGET(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PCB_TARGET
    __del__ = lambda self: None

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

    ClassOf = staticmethod(ClassOf)

    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 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, aUnits):
        """GetSelectMenuText(PCB_TARGET self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.PCB_TARGET_GetSelectMenuText(self, aUnits)


    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)


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

PCB_TARGET_swigregister = _pcbnew.PCB_TARGET_swigregister
PCB_TARGET_swigregister(PCB_TARGET)

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

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 __builtin__.Exception:
            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)

    ClassOf = staticmethod(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 SetTextAngle(self, aAngle):
        """SetTextAngle(TEXTE_MODULE self, double aAngle)"""
        return _pcbnew.TEXTE_MODULE_SetTextAngle(self, aAngle)


    def KeepUpright(self, aOldOrientation, aNewOrientation):
        """KeepUpright(TEXTE_MODULE self, double aOldOrientation, double aNewOrientation)"""
        return _pcbnew.TEXTE_MODULE_KeepUpright(self, aOldOrientation, aNewOrientation)


    def IsKeepUpright(self):
        """IsKeepUpright(TEXTE_MODULE self) -> bool"""
        return _pcbnew.TEXTE_MODULE_IsKeepUpright(self)


    def SetKeepUpright(self, aKeepUpright):
        """SetKeepUpright(TEXTE_MODULE self, bool aKeepUpright)"""
        return _pcbnew.TEXTE_MODULE_SetKeepUpright(self, aKeepUpright)


    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 IsParentFlipped(self):
        """IsParentFlipped(TEXTE_MODULE self) -> bool"""
        return _pcbnew.TEXTE_MODULE_IsParentFlipped(self)


    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 SetEffects(self, aSrc):
        """SetEffects(TEXTE_MODULE self, TEXTE_MODULE aSrc)"""
        return _pcbnew.TEXTE_MODULE_SetEffects(self, aSrc)


    def SwapEffects(self, aTradingPartner):
        """SwapEffects(TEXTE_MODULE self, TEXTE_MODULE aTradingPartner)"""
        return _pcbnew.TEXTE_MODULE_SwapEffects(self, aTradingPartner)


    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 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 GetDrawRotationRadians(self):
        """GetDrawRotationRadians(TEXTE_MODULE self) -> double"""
        return _pcbnew.TEXTE_MODULE_GetDrawRotationRadians(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 * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, 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, aUnits, aList):
        """GetMsgPanelInfo(TEXTE_MODULE self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TEXTE_MODULE_GetMsgPanelInfo(self, aUnits, aList)


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


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


    def GetClass(self):
        """GetClass(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetClass(self)


    def GetSelectMenuText(self, aUnits):
        """GetSelectMenuText(TEXTE_MODULE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetSelectMenuText(self, aUnits)


    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, aView):
        """ViewGetLOD(TEXTE_MODULE self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.TEXTE_MODULE_ViewGetLOD(self, aLayer, aView)

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 __builtin__.Exception:
            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)

    ClassOf = staticmethod(ClassOf)

    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 IsParentFlipped(self):
        """IsParentFlipped(EDGE_MODULE self) -> bool"""
        return _pcbnew.EDGE_MODULE_IsParentFlipped(self)


    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 SetBezier0_C1(self, aPoint):
        """SetBezier0_C1(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetBezier0_C1(self, aPoint)


    def GetBezier0_C1(self):
        """GetBezier0_C1(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetBezier0_C1(self)


    def SetBezier0_C2(self, aPoint):
        """SetBezier0_C2(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetBezier0_C2(self, aPoint)


    def GetBezier0_C2(self):
        """GetBezier0_C2(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetBezier0_C2(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, aUnits, aList):
        """GetMsgPanelInfo(EDGE_MODULE self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDGE_MODULE_GetMsgPanelInfo(self, aUnits, aList)


    def GetClass(self):
        """GetClass(EDGE_MODULE self) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetClass(self)


    def GetSelectMenuText(self, aUnits):
        """GetSelectMenuText(EDGE_MODULE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetSelectMenuText(self, aUnits)


    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)


    def ViewGetLOD(self, aLayer, aView):
        """ViewGetLOD(EDGE_MODULE self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.EDGE_MODULE_ViewGetLOD(self, aLayer, aView)

    __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)
    __swig_setmethods__["m_Bezier0_C1"] = _pcbnew.EDGE_MODULE_m_Bezier0_C1_set
    __swig_getmethods__["m_Bezier0_C1"] = _pcbnew.EDGE_MODULE_m_Bezier0_C1_get
    if _newclass:
        m_Bezier0_C1 = _swig_property(_pcbnew.EDGE_MODULE_m_Bezier0_C1_get, _pcbnew.EDGE_MODULE_m_Bezier0_C1_set)
    __swig_setmethods__["m_Bezier0_C2"] = _pcbnew.EDGE_MODULE_m_Bezier0_C2_set
    __swig_getmethods__["m_Bezier0_C2"] = _pcbnew.EDGE_MODULE_m_Bezier0_C2_get
    if _newclass:
        m_Bezier0_C2 = _swig_property(_pcbnew.EDGE_MODULE_m_Bezier0_C2_get, _pcbnew.EDGE_MODULE_m_Bezier0_C2_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)

CH_VISIBLE = _pcbnew.CH_VISIBLE
CH_UNROUTABLE = _pcbnew.CH_UNROUTABLE
CH_ROUTE_REQ = _pcbnew.CH_ROUTE_REQ
CH_ACTIF = _pcbnew.CH_ACTIF
LOCAL_RATSNEST_ITEM = _pcbnew.LOCAL_RATSNEST_ITEM
class D_PADS(_object):
    """Proxy of C++ std::vector<(p.D_PAD)> class."""

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

    def iterator(self):
        """iterator(D_PADS self) -> SwigPyIterator"""
        return _pcbnew.D_PADS_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(D_PADS self) -> bool"""
        return _pcbnew.D_PADS___nonzero__(self)


    def __bool__(self):
        """__bool__(D_PADS self) -> bool"""
        return _pcbnew.D_PADS___bool__(self)


    def __len__(self):
        """__len__(D_PADS self) -> std::vector< D_PAD * >::size_type"""
        return _pcbnew.D_PADS___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(D_PADS self, std::vector< D_PAD * >::difference_type i, std::vector< D_PAD * >::difference_type j) -> D_PADS"""
        return _pcbnew.D_PADS___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(D_PADS self, std::vector< D_PAD * >::difference_type i, std::vector< D_PAD * >::difference_type j)
        __setslice__(D_PADS self, std::vector< D_PAD * >::difference_type i, std::vector< D_PAD * >::difference_type j, D_PADS v)
        """
        return _pcbnew.D_PADS___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(D_PADS self, std::vector< D_PAD * >::difference_type i, std::vector< D_PAD * >::difference_type j)"""
        return _pcbnew.D_PADS___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(D_PADS self, std::vector< D_PAD * >::difference_type i)
        __delitem__(D_PADS self, PySliceObject * slice)
        """
        return _pcbnew.D_PADS___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(D_PADS self, PySliceObject * slice) -> D_PADS
        __getitem__(D_PADS self, std::vector< D_PAD * >::difference_type i) -> D_PAD
        """
        return _pcbnew.D_PADS___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(D_PADS self, PySliceObject * slice, D_PADS v)
        __setitem__(D_PADS self, PySliceObject * slice)
        __setitem__(D_PADS self, std::vector< D_PAD * >::difference_type i, D_PAD x)
        """
        return _pcbnew.D_PADS___setitem__(self, *args)


    def pop(self):
        """pop(D_PADS self) -> D_PAD"""
        return _pcbnew.D_PADS_pop(self)


    def append(self, x):
        """append(D_PADS self, D_PAD x)"""
        return _pcbnew.D_PADS_append(self, x)


    def empty(self):
        """empty(D_PADS self) -> bool"""
        return _pcbnew.D_PADS_empty(self)


    def size(self):
        """size(D_PADS self) -> std::vector< D_PAD * >::size_type"""
        return _pcbnew.D_PADS_size(self)


    def swap(self, v):
        """swap(D_PADS self, D_PADS v)"""
        return _pcbnew.D_PADS_swap(self, v)


    def begin(self):
        """begin(D_PADS self) -> std::vector< D_PAD * >::iterator"""
        return _pcbnew.D_PADS_begin(self)


    def end(self):
        """end(D_PADS self) -> std::vector< D_PAD * >::iterator"""
        return _pcbnew.D_PADS_end(self)


    def rbegin(self):
        """rbegin(D_PADS self) -> std::vector< D_PAD * >::reverse_iterator"""
        return _pcbnew.D_PADS_rbegin(self)


    def rend(self):
        """rend(D_PADS self) -> std::vector< D_PAD * >::reverse_iterator"""
        return _pcbnew.D_PADS_rend(self)


    def clear(self):
        """clear(D_PADS self)"""
        return _pcbnew.D_PADS_clear(self)


    def get_allocator(self):
        """get_allocator(D_PADS self) -> std::vector< D_PAD * >::allocator_type"""
        return _pcbnew.D_PADS_get_allocator(self)


    def pop_back(self):
        """pop_back(D_PADS self)"""
        return _pcbnew.D_PADS_pop_back(self)


    def erase(self, *args):
        """
        erase(D_PADS self, std::vector< D_PAD * >::iterator pos) -> std::vector< D_PAD * >::iterator
        erase(D_PADS self, std::vector< D_PAD * >::iterator first, std::vector< D_PAD * >::iterator last) -> std::vector< D_PAD * >::iterator
        """
        return _pcbnew.D_PADS_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.D_PAD)> self) -> D_PADS
        __init__(std::vector<(p.D_PAD)> self, D_PADS arg2) -> D_PADS
        __init__(std::vector<(p.D_PAD)> self, std::vector< D_PAD * >::size_type size) -> D_PADS
        __init__(std::vector<(p.D_PAD)> self, std::vector< D_PAD * >::size_type size, D_PAD value) -> D_PADS
        """
        this = _pcbnew.new_D_PADS(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(D_PADS self, D_PAD x)"""
        return _pcbnew.D_PADS_push_back(self, x)


    def front(self):
        """front(D_PADS self) -> D_PAD"""
        return _pcbnew.D_PADS_front(self)


    def back(self):
        """back(D_PADS self) -> D_PAD"""
        return _pcbnew.D_PADS_back(self)


    def assign(self, n, x):
        """assign(D_PADS self, std::vector< D_PAD * >::size_type n, D_PAD x)"""
        return _pcbnew.D_PADS_assign(self, n, x)


    def resize(self, *args):
        """
        resize(D_PADS self, std::vector< D_PAD * >::size_type new_size)
        resize(D_PADS self, std::vector< D_PAD * >::size_type new_size, D_PAD x)
        """
        return _pcbnew.D_PADS_resize(self, *args)


    def insert(self, *args):
        """
        insert(D_PADS self, std::vector< D_PAD * >::iterator pos, D_PAD x) -> std::vector< D_PAD * >::iterator
        insert(D_PADS self, std::vector< D_PAD * >::iterator pos, std::vector< D_PAD * >::size_type n, D_PAD x)
        """
        return _pcbnew.D_PADS_insert(self, *args)


    def reserve(self, n):
        """reserve(D_PADS self, std::vector< D_PAD * >::size_type n)"""
        return _pcbnew.D_PADS_reserve(self, n)


    def capacity(self):
        """capacity(D_PADS self) -> std::vector< D_PAD * >::size_type"""
        return _pcbnew.D_PADS_capacity(self)

    __swig_destroy__ = _pcbnew.delete_D_PADS
    __del__ = lambda self: None
D_PADS_swigregister = _pcbnew.D_PADS_swigregister
D_PADS_swigregister(D_PADS)

class NETINFO_ITEM(BOARD_ITEM):
    """Proxy of C++ NETINFO_ITEM class."""

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

    def __init__(self, *args):
        """
        __init__(NETINFO_ITEM self, BOARD aParent, wxString aNetName, int aNetCode=-1) -> NETINFO_ITEM
        __init__(NETINFO_ITEM self, BOARD aParent, wxString aNetName) -> NETINFO_ITEM
        __init__(NETINFO_ITEM self, BOARD aParent) -> NETINFO_ITEM
        """
        this = _pcbnew.new_NETINFO_ITEM(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETINFO_ITEM
    __del__ = lambda self: None

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

    ClassOf = staticmethod(ClassOf)

    def GetClass(self):
        """GetClass(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetClass(self)


    def GetPosition(self):
        """GetPosition(NETINFO_ITEM self) -> wxPoint"""
        return _pcbnew.NETINFO_ITEM_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(NETINFO_ITEM self, wxPoint aPos)"""
        return _pcbnew.NETINFO_ITEM_SetPosition(self, aPos)


    def SetClass(self, aNetClass):
        """SetClass(NETINFO_ITEM self, NETCLASSPTR const & 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"""
        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 SetNetCode(self, aNetCode):
        """SetNetCode(NETINFO_ITEM self, int aNetCode)"""
        return _pcbnew.NETINFO_ITEM_SetNetCode(self, aNetCode)


    def GetNetname(self):
        """GetNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetNetname(self)


    def GetShortNetname(self):
        """GetShortNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetShortNetname(self)


    def IsCurrent(self):
        """IsCurrent(NETINFO_ITEM self) -> bool"""
        return _pcbnew.NETINFO_ITEM_IsCurrent(self)


    def SetIsCurrent(self, isCurrent):
        """SetIsCurrent(NETINFO_ITEM self, bool isCurrent)"""
        return _pcbnew.NETINFO_ITEM_SetIsCurrent(self, isCurrent)


    def GetMsgPanelInfo(self, aUnits, aList):
        """GetMsgPanelInfo(NETINFO_ITEM self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.NETINFO_ITEM_GetMsgPanelInfo(self, aUnits, aList)


    def Clear(self):
        """Clear(NETINFO_ITEM self)"""
        return _pcbnew.NETINFO_ITEM_Clear(self)


    def GetParent(self):
        """GetParent(NETINFO_ITEM self) -> BOARD"""
        return _pcbnew.NETINFO_ITEM_GetParent(self)

NETINFO_ITEM_swigregister = _pcbnew.NETINFO_ITEM_swigregister
NETINFO_ITEM_swigregister(NETINFO_ITEM)

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

class NETNAMES_MAP(_object):
    """Proxy of C++ std::map<(wxString,p.NETINFO_ITEM)> class."""

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

    def iterator(self):
        """iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP___nonzero__(self)


    def __bool__(self):
        """__bool__(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP___bool__(self)


    def __len__(self):
        """__len__(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_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__(NETNAMES_MAP self, wxString key) -> NETINFO_ITEM"""
        return _pcbnew.NETNAMES_MAP___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(NETNAMES_MAP self, wxString key)"""
        return _pcbnew.NETNAMES_MAP___delitem__(self, key)


    def has_key(self, key):
        """has_key(NETNAMES_MAP self, wxString key) -> bool"""
        return _pcbnew.NETNAMES_MAP_has_key(self, key)


    def keys(self):
        """keys(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_keys(self)


    def values(self):
        """values(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_values(self)


    def items(self):
        """items(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_items(self)


    def __contains__(self, key):
        """__contains__(NETNAMES_MAP self, wxString key) -> bool"""
        return _pcbnew.NETNAMES_MAP___contains__(self, key)


    def key_iterator(self):
        """key_iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_key_iterator(self)


    def value_iterator(self):
        """value_iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(NETNAMES_MAP self, wxString key)
        __setitem__(NETNAMES_MAP self, wxString key, NETINFO_ITEM x)
        """
        return _pcbnew.NETNAMES_MAP___setitem__(self, *args)


    def asdict(self):
        """asdict(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(wxString,p.NETINFO_ITEM)> self, std::less< wxString > const & arg2) -> NETNAMES_MAP
        __init__(std::map<(wxString,p.NETINFO_ITEM)> self) -> NETNAMES_MAP
        __init__(std::map<(wxString,p.NETINFO_ITEM)> self, NETNAMES_MAP arg2) -> NETNAMES_MAP
        """
        this = _pcbnew.new_NETNAMES_MAP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP_empty(self)


    def size(self):
        """size(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP_size(self)


    def swap(self, v):
        """swap(NETNAMES_MAP self, NETNAMES_MAP v)"""
        return _pcbnew.NETNAMES_MAP_swap(self, v)


    def begin(self):
        """begin(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_begin(self)


    def end(self):
        """end(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_end(self)


    def rbegin(self):
        """rbegin(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETNAMES_MAP_rbegin(self)


    def rend(self):
        """rend(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETNAMES_MAP_rend(self)


    def clear(self):
        """clear(NETNAMES_MAP self)"""
        return _pcbnew.NETNAMES_MAP_clear(self)


    def get_allocator(self):
        """get_allocator(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::allocator_type"""
        return _pcbnew.NETNAMES_MAP_get_allocator(self)


    def count(self, x):
        """count(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP_count(self, x)


    def erase(self, *args):
        """
        erase(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::size_type
        erase(NETNAMES_MAP self, std::map< wxString,NETINFO_ITEM * >::iterator position)
        erase(NETNAMES_MAP self, std::map< wxString,NETINFO_ITEM * >::iterator first, std::map< wxString,NETINFO_ITEM * >::iterator last)
        """
        return _pcbnew.NETNAMES_MAP_erase(self, *args)


    def find(self, x):
        """find(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_find(self, x)


    def lower_bound(self, x):
        """lower_bound(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_upper_bound(self, x)

    __swig_destroy__ = _pcbnew.delete_NETNAMES_MAP
    __del__ = lambda self: None
NETNAMES_MAP_swigregister = _pcbnew.NETNAMES_MAP_swigregister
NETNAMES_MAP_swigregister(NETNAMES_MAP)

class NETCODES_MAP(_object):
    """Proxy of C++ std::map<(int,p.NETINFO_ITEM)> class."""

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

    def iterator(self):
        """iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP___nonzero__(self)


    def __bool__(self):
        """__bool__(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP___bool__(self)


    def __len__(self):
        """__len__(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_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__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key) -> NETINFO_ITEM"""
        return _pcbnew.NETCODES_MAP___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key)"""
        return _pcbnew.NETCODES_MAP___delitem__(self, key)


    def has_key(self, key):
        """has_key(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key) -> bool"""
        return _pcbnew.NETCODES_MAP_has_key(self, key)


    def keys(self):
        """keys(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_keys(self)


    def values(self):
        """values(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_values(self)


    def items(self):
        """items(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_items(self)


    def __contains__(self, key):
        """__contains__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key) -> bool"""
        return _pcbnew.NETCODES_MAP___contains__(self, key)


    def key_iterator(self):
        """key_iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_key_iterator(self)


    def value_iterator(self):
        """value_iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key)
        __setitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key, NETINFO_ITEM x)
        """
        return _pcbnew.NETCODES_MAP___setitem__(self, *args)


    def asdict(self):
        """asdict(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(int,p.NETINFO_ITEM)> self, std::less< int > const & arg2) -> NETCODES_MAP
        __init__(std::map<(int,p.NETINFO_ITEM)> self) -> NETCODES_MAP
        __init__(std::map<(int,p.NETINFO_ITEM)> self, NETCODES_MAP arg2) -> NETCODES_MAP
        """
        this = _pcbnew.new_NETCODES_MAP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP_empty(self)


    def size(self):
        """size(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_MAP_size(self)


    def swap(self, v):
        """swap(NETCODES_MAP self, NETCODES_MAP v)"""
        return _pcbnew.NETCODES_MAP_swap(self, v)


    def begin(self):
        """begin(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_begin(self)


    def end(self):
        """end(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_end(self)


    def rbegin(self):
        """rbegin(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETCODES_MAP_rbegin(self)


    def rend(self):
        """rend(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETCODES_MAP_rend(self)


    def clear(self):
        """clear(NETCODES_MAP self)"""
        return _pcbnew.NETCODES_MAP_clear(self)


    def get_allocator(self):
        """get_allocator(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::allocator_type"""
        return _pcbnew.NETCODES_MAP_get_allocator(self)


    def count(self, x):
        """count(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_MAP_count(self, x)


    def erase(self, *args):
        """
        erase(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::size_type
        erase(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::iterator position)
        erase(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::iterator first, std::map< int,NETINFO_ITEM * >::iterator last)
        """
        return _pcbnew.NETCODES_MAP_erase(self, *args)


    def find(self, x):
        """find(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_find(self, x)


    def lower_bound(self, x):
        """lower_bound(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_upper_bound(self, x)

    __swig_destroy__ = _pcbnew.delete_NETCODES_MAP
    __del__ = lambda self: None
NETCODES_MAP_swigregister = _pcbnew.NETCODES_MAP_swigregister
NETCODES_MAP_swigregister(NETCODES_MAP)

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 __builtin__.Exception:
            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 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 RemoveNet(self, aNet):
        """RemoveNet(NETINFO_LIST self, NETINFO_ITEM aNet)"""
        return _pcbnew.NETINFO_LIST_RemoveNet(self, aNet)


    def NetsByName(self):
        """NetsByName(NETINFO_LIST self) -> NETNAMES_MAP"""
        return _pcbnew.NETINFO_LIST_NetsByName(self)


    def NetsByNetcode(self):
        """NetsByNetcode(NETINFO_LIST self) -> NETCODES_MAP"""
        return _pcbnew.NETINFO_LIST_NetsByNetcode(self)

    __swig_setmethods__["ORPHANED_ITEM"] = _pcbnew.NETINFO_LIST_ORPHANED_ITEM_set
    __swig_getmethods__["ORPHANED_ITEM"] = _pcbnew.NETINFO_LIST_ORPHANED_ITEM_get
    if _newclass:
        ORPHANED_ITEM = _swig_property(_pcbnew.NETINFO_LIST_ORPHANED_ITEM_get, _pcbnew.NETINFO_LIST_ORPHANED_ITEM_set)

    def GetParent(self):
        """GetParent(NETINFO_LIST self) -> BOARD"""
        return _pcbnew.NETINFO_LIST_GetParent(self)

NETINFO_LIST_swigregister = _pcbnew.NETINFO_LIST_swigregister
NETINFO_LIST_swigregister(NETINFO_LIST)
NETINFO_LIST.UNCONNECTED = _pcbnew.cvar.NETINFO_LIST_UNCONNECTED
NETINFO_LIST.ORPHANED = _pcbnew.cvar.NETINFO_LIST_ORPHANED

START_ON_PAD = _pcbnew.START_ON_PAD
END_ON_PAD = _pcbnew.END_ON_PAD
START_ON_TRACK = _pcbnew.START_ON_TRACK
END_ON_TRACK = _pcbnew.END_ON_TRACK
RATSNEST_ITEM_LOCAL_OK = _pcbnew.RATSNEST_ITEM_LOCAL_OK
DO_NOT_SHOW_GENERAL_RASTNEST = _pcbnew.DO_NOT_SHOW_GENERAL_RASTNEST
class STRINGSET(_object):
    """Proxy of C++ std::set<(wxString)> class."""

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

    def iterator(self):
        """iterator(STRINGSET self) -> SwigPyIterator"""
        return _pcbnew.STRINGSET_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET___nonzero__(self)


    def __bool__(self):
        """__bool__(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET___bool__(self)


    def __len__(self):
        """__len__(STRINGSET self) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET___len__(self)


    def append(self, x):
        """append(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_append(self, x)


    def __contains__(self, x):
        """__contains__(STRINGSET self, wxString x) -> bool"""
        return _pcbnew.STRINGSET___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(STRINGSET self, std::set< wxString >::difference_type i) -> wxString"""
        return _pcbnew.STRINGSET___getitem__(self, i)


    def add(self, x):
        """add(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_add(self, x)


    def discard(self, x):
        """discard(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_discard(self, x)


    def __init__(self, *args):
        """
        __init__(std::set<(wxString)> self, std::less< wxString > const & arg2) -> STRINGSET
        __init__(std::set<(wxString)> self) -> STRINGSET
        __init__(std::set<(wxString)> self, STRINGSET arg2) -> STRINGSET
        """
        this = _pcbnew.new_STRINGSET(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET_empty(self)


    def size(self):
        """size(STRINGSET self) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET_size(self)


    def clear(self):
        """clear(STRINGSET self)"""
        return _pcbnew.STRINGSET_clear(self)


    def swap(self, v):
        """swap(STRINGSET self, STRINGSET v)"""
        return _pcbnew.STRINGSET_swap(self, v)


    def count(self, x):
        """count(STRINGSET self, wxString x) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET_count(self, x)


    def begin(self):
        """begin(STRINGSET self) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_begin(self)


    def end(self):
        """end(STRINGSET self) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_end(self)


    def rbegin(self):
        """rbegin(STRINGSET self) -> std::set< wxString >::reverse_iterator"""
        return _pcbnew.STRINGSET_rbegin(self)


    def rend(self):
        """rend(STRINGSET self) -> std::set< wxString >::reverse_iterator"""
        return _pcbnew.STRINGSET_rend(self)


    def erase(self, *args):
        """
        erase(STRINGSET self, wxString x) -> std::set< wxString >::size_type
        erase(STRINGSET self, std::set< wxString >::iterator pos)
        erase(STRINGSET self, std::set< wxString >::iterator first, std::set< wxString >::iterator last)
        """
        return _pcbnew.STRINGSET_erase(self, *args)


    def find(self, x):
        """find(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_find(self, x)


    def lower_bound(self, x):
        """lower_bound(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(STRINGSET self, wxString x) -> std::pair< std::set< wxString >::iterator,std::set< wxString >::iterator >"""
        return _pcbnew.STRINGSET_equal_range(self, x)


    def insert(self, __x):
        """insert(STRINGSET self, wxString __x) -> std::pair< std::set< wxString >::iterator,bool >"""
        return _pcbnew.STRINGSET_insert(self, __x)

    __swig_destroy__ = _pcbnew.delete_STRINGSET
    __del__ = lambda self: None
STRINGSET_swigregister = _pcbnew.STRINGSET_swigregister
STRINGSET_swigregister(STRINGSET)

class NETCLASSPTR(_object):
    """Proxy of C++ std::shared_ptr<(NETCLASS)> class."""

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

    def __init__(self, name):
        """__init__(std::shared_ptr<(NETCLASS)> self, string name) -> NETCLASSPTR"""
        this = _pcbnew.new_NETCLASSPTR(name)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def NetNames(self):
        """NetNames(NETCLASSPTR self) -> STRINGSET"""
        return _pcbnew.NETCLASSPTR_NetNames(self)


    def GetName(self):
        """GetName(NETCLASSPTR self) -> wxString"""
        return _pcbnew.NETCLASSPTR_GetName(self)


    def GetCount(self):
        """GetCount(NETCLASSPTR self) -> unsigned int"""
        return _pcbnew.NETCLASSPTR_GetCount(self)


    def GetDescription(self):
        """GetDescription(NETCLASSPTR self) -> wxString"""
        return _pcbnew.NETCLASSPTR_GetDescription(self)


    def SetDescription(self, aDesc):
        """SetDescription(NETCLASSPTR self, wxString aDesc)"""
        return _pcbnew.NETCLASSPTR_SetDescription(self, aDesc)


    def GetClearance(self):
        """GetClearance(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetClearance(self)


    def SetClearance(self, aClearance):
        """SetClearance(NETCLASSPTR self, int aClearance)"""
        return _pcbnew.NETCLASSPTR_SetClearance(self, aClearance)


    def GetTrackWidth(self):
        """GetTrackWidth(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetTrackWidth(self)


    def SetTrackWidth(self, aWidth):
        """SetTrackWidth(NETCLASSPTR self, int aWidth)"""
        return _pcbnew.NETCLASSPTR_SetTrackWidth(self, aWidth)


    def GetViaDiameter(self):
        """GetViaDiameter(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetViaDiameter(self)


    def SetViaDiameter(self, aDia):
        """SetViaDiameter(NETCLASSPTR self, int aDia)"""
        return _pcbnew.NETCLASSPTR_SetViaDiameter(self, aDia)


    def GetViaDrill(self):
        """GetViaDrill(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetViaDrill(self)


    def SetViaDrill(self, aSize):
        """SetViaDrill(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetViaDrill(self, aSize)


    def GetuViaDiameter(self):
        """GetuViaDiameter(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetuViaDiameter(self)


    def SetuViaDiameter(self, aSize):
        """SetuViaDiameter(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetuViaDiameter(self, aSize)


    def GetuViaDrill(self):
        """GetuViaDrill(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetuViaDrill(self)


    def SetuViaDrill(self, aSize):
        """SetuViaDrill(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetuViaDrill(self, aSize)


    def GetDiffPairWidth(self):
        """GetDiffPairWidth(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetDiffPairWidth(self)


    def SetDiffPairWidth(self, aSize):
        """SetDiffPairWidth(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetDiffPairWidth(self, aSize)


    def GetDiffPairGap(self):
        """GetDiffPairGap(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetDiffPairGap(self)


    def SetDiffPairGap(self, aSize):
        """SetDiffPairGap(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetDiffPairGap(self, aSize)

    __swig_destroy__ = _pcbnew.delete_NETCLASSPTR
    __del__ = lambda self: None
NETCLASSPTR_swigregister = _pcbnew.NETCLASSPTR_swigregister
NETCLASSPTR_swigregister(NETCLASSPTR)

class NETCLASS_MAP(_object):
    """Proxy of C++ std::map<(wxString,NETCLASSPTR)> class."""

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

    def iterator(self):
        """iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP___nonzero__(self)


    def __bool__(self):
        """__bool__(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP___bool__(self)


    def __len__(self):
        """__len__(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_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__(NETCLASS_MAP self, wxString key) -> std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const &"""
        return _pcbnew.NETCLASS_MAP___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(NETCLASS_MAP self, wxString key)"""
        return _pcbnew.NETCLASS_MAP___delitem__(self, key)


    def has_key(self, key):
        """has_key(NETCLASS_MAP self, wxString key) -> bool"""
        return _pcbnew.NETCLASS_MAP_has_key(self, key)


    def keys(self):
        """keys(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_keys(self)


    def values(self):
        """values(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_values(self)


    def items(self):
        """items(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_items(self)


    def __contains__(self, key):
        """__contains__(NETCLASS_MAP self, wxString key) -> bool"""
        return _pcbnew.NETCLASS_MAP___contains__(self, key)


    def key_iterator(self):
        """key_iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_key_iterator(self)


    def value_iterator(self):
        """value_iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(NETCLASS_MAP self, wxString key)
        __setitem__(NETCLASS_MAP self, wxString key, std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const & x)
        """
        return _pcbnew.NETCLASS_MAP___setitem__(self, *args)


    def asdict(self):
        """asdict(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(wxString,NETCLASSPTR)> self, std::less< wxString > const & arg2) -> NETCLASS_MAP
        __init__(std::map<(wxString,NETCLASSPTR)> self) -> NETCLASS_MAP
        __init__(std::map<(wxString,NETCLASSPTR)> self, NETCLASS_MAP arg2) -> NETCLASS_MAP
        """
        this = _pcbnew.new_NETCLASS_MAP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP_empty(self)


    def size(self):
        """size(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_MAP_size(self)


    def swap(self, v):
        """swap(NETCLASS_MAP self, NETCLASS_MAP v)"""
        return _pcbnew.NETCLASS_MAP_swap(self, v)


    def begin(self):
        """begin(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_begin(self)


    def end(self):
        """end(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_end(self)


    def rbegin(self):
        """rbegin(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.NETCLASS_MAP_rbegin(self)


    def rend(self):
        """rend(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.NETCLASS_MAP_rend(self)


    def clear(self):
        """clear(NETCLASS_MAP self)"""
        return _pcbnew.NETCLASS_MAP_clear(self)


    def get_allocator(self):
        """get_allocator(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::allocator_type"""
        return _pcbnew.NETCLASS_MAP_get_allocator(self)


    def count(self, x):
        """count(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_MAP_count(self, x)


    def erase(self, *args):
        """
        erase(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type
        erase(NETCLASS_MAP self, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator position)
        erase(NETCLASS_MAP self, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator first, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator last)
        """
        return _pcbnew.NETCLASS_MAP_erase(self, *args)


    def find(self, x):
        """find(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_find(self, x)


    def lower_bound(self, x):
        """lower_bound(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_upper_bound(self, x)

    __swig_destroy__ = _pcbnew.delete_NETCLASS_MAP
    __del__ = lambda self: None
NETCLASS_MAP_swigregister = _pcbnew.NETCLASS_MAP_swigregister
NETCLASS_MAP_swigregister(NETCLASS_MAP)

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 __builtin__.Exception:
            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 Add(self, aNetclass):
        """Add(NETCLASSES self, NETCLASSPTR const & aNetclass) -> bool"""
        return _pcbnew.NETCLASSES_Add(self, aNetclass)


    def Remove(self, aNetName):
        """Remove(NETCLASSES self, wxString aNetName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Remove(self, aNetName)


    def Find(self, aName):
        """Find(NETCLASSES self, wxString aName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Find(self, aName)


    def NetClasses(self):
        """NetClasses(NETCLASSES self) -> NETCLASS_MAP"""
        return _pcbnew.NETCLASSES_NetClasses(self)

NETCLASSES_swigregister = _pcbnew.NETCLASSES_swigregister
NETCLASSES_swigregister(NETCLASSES)

UNDEFINED_LAYER = _pcbnew.UNDEFINED_LAYER
UNSELECTED_LAYER = _pcbnew.UNSELECTED_LAYER
PCBNEW_LAYER_ID_START = _pcbnew.PCBNEW_LAYER_ID_START
F_Cu = _pcbnew.F_Cu
In1_Cu = _pcbnew.In1_Cu
In2_Cu = _pcbnew.In2_Cu
In3_Cu = _pcbnew.In3_Cu
In4_Cu = _pcbnew.In4_Cu
In5_Cu = _pcbnew.In5_Cu
In6_Cu = _pcbnew.In6_Cu
In7_Cu = _pcbnew.In7_Cu
In8_Cu = _pcbnew.In8_Cu
In9_Cu = _pcbnew.In9_Cu
In10_Cu = _pcbnew.In10_Cu
In11_Cu = _pcbnew.In11_Cu
In12_Cu = _pcbnew.In12_Cu
In13_Cu = _pcbnew.In13_Cu
In14_Cu = _pcbnew.In14_Cu
In15_Cu = _pcbnew.In15_Cu
In16_Cu = _pcbnew.In16_Cu
In17_Cu = _pcbnew.In17_Cu
In18_Cu = _pcbnew.In18_Cu
In19_Cu = _pcbnew.In19_Cu
In20_Cu = _pcbnew.In20_Cu
In21_Cu = _pcbnew.In21_Cu
In22_Cu = _pcbnew.In22_Cu
In23_Cu = _pcbnew.In23_Cu
In24_Cu = _pcbnew.In24_Cu
In25_Cu = _pcbnew.In25_Cu
In26_Cu = _pcbnew.In26_Cu
In27_Cu = _pcbnew.In27_Cu
In28_Cu = _pcbnew.In28_Cu
In29_Cu = _pcbnew.In29_Cu
In30_Cu = _pcbnew.In30_Cu
B_Cu = _pcbnew.B_Cu
B_Adhes = _pcbnew.B_Adhes
F_Adhes = _pcbnew.F_Adhes
B_Paste = _pcbnew.B_Paste
F_Paste = _pcbnew.F_Paste
B_SilkS = _pcbnew.B_SilkS
F_SilkS = _pcbnew.F_SilkS
B_Mask = _pcbnew.B_Mask
F_Mask = _pcbnew.F_Mask
Dwgs_User = _pcbnew.Dwgs_User
Cmts_User = _pcbnew.Cmts_User
Eco1_User = _pcbnew.Eco1_User
Eco2_User = _pcbnew.Eco2_User
Edge_Cuts = _pcbnew.Edge_Cuts
Margin = _pcbnew.Margin
B_CrtYd = _pcbnew.B_CrtYd
F_CrtYd = _pcbnew.F_CrtYd
B_Fab = _pcbnew.B_Fab
F_Fab = _pcbnew.F_Fab
Rescue = _pcbnew.Rescue
PCB_LAYER_ID_COUNT = _pcbnew.PCB_LAYER_ID_COUNT
NETNAMES_LAYER_ID_START = _pcbnew.NETNAMES_LAYER_ID_START
NETNAMES_LAYER_ID_RESERVED = _pcbnew.NETNAMES_LAYER_ID_RESERVED
LAYER_PAD_FR_NETNAMES = _pcbnew.LAYER_PAD_FR_NETNAMES
LAYER_PAD_BK_NETNAMES = _pcbnew.LAYER_PAD_BK_NETNAMES
LAYER_PADS_NETNAMES = _pcbnew.LAYER_PADS_NETNAMES
LAYER_VIAS_NETNAMES = _pcbnew.LAYER_VIAS_NETNAMES
NETNAMES_LAYER_ID_END = _pcbnew.NETNAMES_LAYER_ID_END
GAL_LAYER_ID_START = _pcbnew.GAL_LAYER_ID_START
LAYER_VIAS = _pcbnew.LAYER_VIAS
LAYER_VIA_MICROVIA = _pcbnew.LAYER_VIA_MICROVIA
LAYER_VIA_BBLIND = _pcbnew.LAYER_VIA_BBLIND
LAYER_VIA_THROUGH = _pcbnew.LAYER_VIA_THROUGH
LAYER_NON_PLATEDHOLES = _pcbnew.LAYER_NON_PLATEDHOLES
LAYER_MOD_TEXT_FR = _pcbnew.LAYER_MOD_TEXT_FR
LAYER_MOD_TEXT_BK = _pcbnew.LAYER_MOD_TEXT_BK
LAYER_MOD_TEXT_INVISIBLE = _pcbnew.LAYER_MOD_TEXT_INVISIBLE
LAYER_ANCHOR = _pcbnew.LAYER_ANCHOR
LAYER_PAD_FR = _pcbnew.LAYER_PAD_FR
LAYER_PAD_BK = _pcbnew.LAYER_PAD_BK
LAYER_RATSNEST = _pcbnew.LAYER_RATSNEST
LAYER_GRID = _pcbnew.LAYER_GRID
LAYER_GRID_AXES = _pcbnew.LAYER_GRID_AXES
LAYER_NO_CONNECTS = _pcbnew.LAYER_NO_CONNECTS
LAYER_MOD_FR = _pcbnew.LAYER_MOD_FR
LAYER_MOD_BK = _pcbnew.LAYER_MOD_BK
LAYER_MOD_VALUES = _pcbnew.LAYER_MOD_VALUES
LAYER_MOD_REFERENCES = _pcbnew.LAYER_MOD_REFERENCES
LAYER_TRACKS = _pcbnew.LAYER_TRACKS
LAYER_PADS_TH = _pcbnew.LAYER_PADS_TH
LAYER_PADS_PLATEDHOLES = _pcbnew.LAYER_PADS_PLATEDHOLES
LAYER_VIAS_HOLES = _pcbnew.LAYER_VIAS_HOLES
LAYER_DRC = _pcbnew.LAYER_DRC
LAYER_WORKSHEET = _pcbnew.LAYER_WORKSHEET
LAYER_GP_OVERLAY = _pcbnew.LAYER_GP_OVERLAY
LAYER_SELECT_OVERLAY = _pcbnew.LAYER_SELECT_OVERLAY
LAYER_PCB_BACKGROUND = _pcbnew.LAYER_PCB_BACKGROUND
LAYER_CURSOR = _pcbnew.LAYER_CURSOR
LAYER_AUX_ITEMS = _pcbnew.LAYER_AUX_ITEMS
LAYER_DRAW_BITMAPS = _pcbnew.LAYER_DRAW_BITMAPS
GAL_LAYER_ID_BITMASK_END = _pcbnew.GAL_LAYER_ID_BITMASK_END
GAL_LAYER_ID_END = _pcbnew.GAL_LAYER_ID_END
SCH_LAYER_ID_START = _pcbnew.SCH_LAYER_ID_START
LAYER_WIRE = _pcbnew.LAYER_WIRE
LAYER_BUS = _pcbnew.LAYER_BUS
LAYER_JUNCTION = _pcbnew.LAYER_JUNCTION
LAYER_LOCLABEL = _pcbnew.LAYER_LOCLABEL
LAYER_GLOBLABEL = _pcbnew.LAYER_GLOBLABEL
LAYER_HIERLABEL = _pcbnew.LAYER_HIERLABEL
LAYER_PINNUM = _pcbnew.LAYER_PINNUM
LAYER_PINNAM = _pcbnew.LAYER_PINNAM
LAYER_REFERENCEPART = _pcbnew.LAYER_REFERENCEPART
LAYER_VALUEPART = _pcbnew.LAYER_VALUEPART
LAYER_FIELDS = _pcbnew.LAYER_FIELDS
LAYER_DEVICE = _pcbnew.LAYER_DEVICE
LAYER_NOTES = _pcbnew.LAYER_NOTES
LAYER_NETNAM = _pcbnew.LAYER_NETNAM
LAYER_PIN = _pcbnew.LAYER_PIN
LAYER_SHEET = _pcbnew.LAYER_SHEET
LAYER_SHEETNAME = _pcbnew.LAYER_SHEETNAME
LAYER_SHEETFILENAME = _pcbnew.LAYER_SHEETFILENAME
LAYER_SHEETLABEL = _pcbnew.LAYER_SHEETLABEL
LAYER_NOCONNECT = _pcbnew.LAYER_NOCONNECT
LAYER_ERC_WARN = _pcbnew.LAYER_ERC_WARN
LAYER_ERC_ERR = _pcbnew.LAYER_ERC_ERR
LAYER_DEVICE_BACKGROUND = _pcbnew.LAYER_DEVICE_BACKGROUND
LAYER_SHEET_BACKGROUND = _pcbnew.LAYER_SHEET_BACKGROUND
LAYER_SCHEMATIC_BITMAPS = _pcbnew.LAYER_SCHEMATIC_BITMAPS
LAYER_SCHEMATIC_GRID = _pcbnew.LAYER_SCHEMATIC_GRID
LAYER_SCHEMATIC_BACKGROUND = _pcbnew.LAYER_SCHEMATIC_BACKGROUND
LAYER_SCHEMATIC_CURSOR = _pcbnew.LAYER_SCHEMATIC_CURSOR
LAYER_BRIGHTENED = _pcbnew.LAYER_BRIGHTENED
LAYER_HIDDEN = _pcbnew.LAYER_HIDDEN
SCH_LAYER_ID_END = _pcbnew.SCH_LAYER_ID_END
GERBVIEW_LAYER_ID_START = _pcbnew.GERBVIEW_LAYER_ID_START
GERBVIEW_LAYER_ID_RESERVED = _pcbnew.GERBVIEW_LAYER_ID_RESERVED
LAYER_DCODES = _pcbnew.LAYER_DCODES
LAYER_NEGATIVE_OBJECTS = _pcbnew.LAYER_NEGATIVE_OBJECTS
LAYER_GERBVIEW_GRID = _pcbnew.LAYER_GERBVIEW_GRID
LAYER_GERBVIEW_AXES = _pcbnew.LAYER_GERBVIEW_AXES
LAYER_GERBVIEW_BACKGROUND = _pcbnew.LAYER_GERBVIEW_BACKGROUND
GERBVIEW_LAYER_ID_END = _pcbnew.GERBVIEW_LAYER_ID_END
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 __builtin__.Exception:
            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) -> PCB_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(BASE_SET):
    """Proxy of C++ LSET class."""

    __swig_setmethods__ = {}
    for _s in [BASE_SET]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LSET, name, value)
    __swig_getmethods__ = {}
    for _s in [BASE_SET]:
        __swig_getmethods__.update(getattr(_s, '__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 aOther) -> LSET
        __init__(LSET self, PCB_LAYER_ID aLayer) -> LSET
        __init__(LSET self, PCB_LAYER_ID const * aArray, unsigned int aCount) -> LSET
        __init__(LSET self, unsigned int aIdCount, int aFirst) -> LSET
        """
        this = _pcbnew.new_LSET(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Name(aLayerId):
        """Name(PCB_LAYER_ID aLayerId) -> wxChar const *"""
        return _pcbnew.LSET_Name(aLayerId)

    Name = staticmethod(Name)

    def InternalCuMask():
        """InternalCuMask() -> LSET"""
        return _pcbnew.LSET_InternalCuMask()

    InternalCuMask = staticmethod(InternalCuMask)

    def AllCuMask(*args):
        """
        AllCuMask(int aCuLayerCount) -> LSET
        AllCuMask() -> LSET
        """
        return _pcbnew.LSET_AllCuMask(*args)

    AllCuMask = staticmethod(AllCuMask)

    def ExternalCuMask():
        """ExternalCuMask() -> LSET"""
        return _pcbnew.LSET_ExternalCuMask()

    ExternalCuMask = staticmethod(ExternalCuMask)

    def AllNonCuMask():
        """AllNonCuMask() -> LSET"""
        return _pcbnew.LSET_AllNonCuMask()

    AllNonCuMask = staticmethod(AllNonCuMask)

    def AllLayersMask():
        """AllLayersMask() -> LSET"""
        return _pcbnew.LSET_AllLayersMask()

    AllLayersMask = staticmethod(AllLayersMask)

    def FrontTechMask():
        """FrontTechMask() -> LSET"""
        return _pcbnew.LSET_FrontTechMask()

    FrontTechMask = staticmethod(FrontTechMask)

    def FrontBoardTechMask():
        """FrontBoardTechMask() -> LSET"""
        return _pcbnew.LSET_FrontBoardTechMask()

    FrontBoardTechMask = staticmethod(FrontBoardTechMask)

    def BackTechMask():
        """BackTechMask() -> LSET"""
        return _pcbnew.LSET_BackTechMask()

    BackTechMask = staticmethod(BackTechMask)

    def BackBoardTechMask():
        """BackBoardTechMask() -> LSET"""
        return _pcbnew.LSET_BackBoardTechMask()

    BackBoardTechMask = staticmethod(BackBoardTechMask)

    def AllTechMask():
        """AllTechMask() -> LSET"""
        return _pcbnew.LSET_AllTechMask()

    AllTechMask = staticmethod(AllTechMask)

    def AllBoardTechMask():
        """AllBoardTechMask() -> LSET"""
        return _pcbnew.LSET_AllBoardTechMask()

    AllBoardTechMask = staticmethod(AllBoardTechMask)

    def FrontMask():
        """FrontMask() -> LSET"""
        return _pcbnew.LSET_FrontMask()

    FrontMask = staticmethod(FrontMask)

    def BackMask():
        """BackMask() -> LSET"""
        return _pcbnew.LSET_BackMask()

    BackMask = staticmethod(BackMask)

    def UserMask():
        """UserMask() -> LSET"""
        return _pcbnew.LSET_UserMask()

    UserMask = staticmethod(UserMask)

    def ForbiddenFootprintLayers():
        """ForbiddenFootprintLayers() -> LSET"""
        return _pcbnew.LSET_ForbiddenFootprintLayers()

    ForbiddenFootprintLayers = staticmethod(ForbiddenFootprintLayers)

    def ForbiddenTextLayers():
        """ForbiddenTextLayers() -> LSET"""
        return _pcbnew.LSET_ForbiddenTextLayers()

    ForbiddenTextLayers = staticmethod(ForbiddenTextLayers)

    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 TechAndUserUIOrder(self):
        """TechAndUserUIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_TechAndUserUIOrder(self)


    def UIOrder(self):
        """UIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_UIOrder(self)


    def Seq(self, *args):
        """
        Seq(LSET self, PCB_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) -> PCB_LAYER_ID"""
        return _pcbnew.LSET_ExtractLayer(self)


    def addLayer(self, aLayer):
        """addLayer(LSET self, PCB_LAYER_ID aLayer) -> LSET"""
        return _pcbnew.LSET_addLayer(self, aLayer)


    def removeLayer(self, aLayer):
        """removeLayer(LSET self, PCB_LAYER_ID aLayer) -> LSET"""
        return _pcbnew.LSET_removeLayer(self, aLayer)


    def addLayerSet(self, aLayerSet):
        """addLayerSet(LSET self, LSET aLayerSet) -> LSET"""
        return _pcbnew.LSET_addLayerSet(self, aLayerSet)


    def removeLayerSet(self, aLayerSet):
        """removeLayerSet(LSET self, LSET aLayerSet) -> LSET"""
        return _pcbnew.LSET_removeLayerSet(self, aLayerSet)


    def AddLayer(self, layer):
        return self.addLayer( layer )

    def AddLayerSet(self, layers):
        return self.addLayerSet( layers )

    def RemoveLayer(self, layer):
        return self.removeLayer( layer )

    def RemoveLayerSet(self, layers):
        return self.removeLayerSet( layers )

    __swig_destroy__ = _pcbnew.delete_LSET
    __del__ = lambda self: None
LSET_swigregister = _pcbnew.LSET_swigregister
LSET_swigregister(LSET)

def LSET_Name(aLayerId):
    """LSET_Name(PCB_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_ExternalCuMask():
    """LSET_ExternalCuMask() -> LSET"""
    return _pcbnew.LSET_ExternalCuMask()

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_FrontBoardTechMask():
    """LSET_FrontBoardTechMask() -> LSET"""
    return _pcbnew.LSET_FrontBoardTechMask()

def LSET_BackTechMask():
    """LSET_BackTechMask() -> LSET"""
    return _pcbnew.LSET_BackTechMask()

def LSET_BackBoardTechMask():
    """LSET_BackBoardTechMask() -> LSET"""
    return _pcbnew.LSET_BackBoardTechMask()

def LSET_AllTechMask():
    """LSET_AllTechMask() -> LSET"""
    return _pcbnew.LSET_AllTechMask()

def LSET_AllBoardTechMask():
    """LSET_AllBoardTechMask() -> LSET"""
    return _pcbnew.LSET_AllBoardTechMask()

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()

def LSET_ForbiddenFootprintLayers():
    """LSET_ForbiddenFootprintLayers() -> LSET"""
    return _pcbnew.LSET_ForbiddenFootprintLayers()

def LSET_ForbiddenTextLayers():
    """LSET_ForbiddenTextLayers() -> LSET"""
    return _pcbnew.LSET_ForbiddenTextLayers()


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(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsUserLayer(aLayerId)

def IsFrontLayer(aLayerId):
    """IsFrontLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsFrontLayer(aLayerId)

def IsBackLayer(aLayerId):
    """IsBackLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsBackLayer(aLayerId)

def FlipLayer(aLayerId, aCopperLayersCount=0):
    """
    FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount=0) -> PCB_LAYER_ID
    FlipLayer(PCB_LAYER_ID aLayerId) -> PCB_LAYER_ID
    """
    return _pcbnew.FlipLayer(aLayerId, aCopperLayersCount)

def FlipLayerMask(aMask, aCopperLayersCount=0):
    """
    FlipLayerMask(LSET aMask, int aCopperLayersCount=0) -> LSET
    FlipLayerMask(LSET aMask) -> LSET
    """
    return _pcbnew.FlipLayerMask(aMask, aCopperLayersCount)

def GetNetnameLayer(aLayer):
    """GetNetnameLayer(int aLayer) -> int"""
    return _pcbnew.GetNetnameLayer(aLayer)

def IsNetnameLayer(aLayer):
    """IsNetnameLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsNetnameLayer(aLayer)

def IsDCodeLayer(aLayer):
    """IsDCodeLayer(int aLayer) -> bool"""
    return _pcbnew.IsDCodeLayer(aLayer)

def ToLAYER_ID(aLayer):
    """ToLAYER_ID(int aLayer) -> PCB_LAYER_ID"""
    return _pcbnew.ToLAYER_ID(aLayer)
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 __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)
        __setslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j, VIA_DIMENSION_Vector v)
        """
        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 pop(self):
        """pop(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_pop(self)


    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 swap(self, v):
        """swap(VIA_DIMENSION_Vector self, VIA_DIMENSION_Vector v)"""
        return _pcbnew.VIA_DIMENSION_Vector_swap(self, v)


    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 clear(self):
        """clear(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_clear(self)


    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 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 __builtin__.Exception:
            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)

LT_UNDEFINED = _pcbnew.LT_UNDEFINED
LT_SIGNAL = _pcbnew.LT_SIGNAL
LT_POWER = _pcbnew.LT_POWER
LT_MIXED = _pcbnew.LT_MIXED
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 __builtin__.Exception:
            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)

    ShowType = staticmethod(ShowType)

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

    ParseType = staticmethod(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 MARKERS(_object):
    """Proxy of C++ std::vector<(p.MARKER_PCB)> class."""

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

    def iterator(self):
        """iterator(MARKERS self) -> SwigPyIterator"""
        return _pcbnew.MARKERS_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(MARKERS self) -> bool"""
        return _pcbnew.MARKERS___nonzero__(self)


    def __bool__(self):
        """__bool__(MARKERS self) -> bool"""
        return _pcbnew.MARKERS___bool__(self)


    def __len__(self):
        """__len__(MARKERS self) -> std::vector< MARKER_PCB * >::size_type"""
        return _pcbnew.MARKERS___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i, std::vector< MARKER_PCB * >::difference_type j) -> MARKERS"""
        return _pcbnew.MARKERS___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i, std::vector< MARKER_PCB * >::difference_type j)
        __setslice__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i, std::vector< MARKER_PCB * >::difference_type j, MARKERS v)
        """
        return _pcbnew.MARKERS___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i, std::vector< MARKER_PCB * >::difference_type j)"""
        return _pcbnew.MARKERS___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i)
        __delitem__(MARKERS self, PySliceObject * slice)
        """
        return _pcbnew.MARKERS___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MARKERS self, PySliceObject * slice) -> MARKERS
        __getitem__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i) -> MARKER_PCB
        """
        return _pcbnew.MARKERS___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MARKERS self, PySliceObject * slice, MARKERS v)
        __setitem__(MARKERS self, PySliceObject * slice)
        __setitem__(MARKERS self, std::vector< MARKER_PCB * >::difference_type i, MARKER_PCB x)
        """
        return _pcbnew.MARKERS___setitem__(self, *args)


    def pop(self):
        """pop(MARKERS self) -> MARKER_PCB"""
        return _pcbnew.MARKERS_pop(self)


    def append(self, x):
        """append(MARKERS self, MARKER_PCB x)"""
        return _pcbnew.MARKERS_append(self, x)


    def empty(self):
        """empty(MARKERS self) -> bool"""
        return _pcbnew.MARKERS_empty(self)


    def size(self):
        """size(MARKERS self) -> std::vector< MARKER_PCB * >::size_type"""
        return _pcbnew.MARKERS_size(self)


    def swap(self, v):
        """swap(MARKERS self, MARKERS v)"""
        return _pcbnew.MARKERS_swap(self, v)


    def begin(self):
        """begin(MARKERS self) -> std::vector< MARKER_PCB * >::iterator"""
        return _pcbnew.MARKERS_begin(self)


    def end(self):
        """end(MARKERS self) -> std::vector< MARKER_PCB * >::iterator"""
        return _pcbnew.MARKERS_end(self)


    def rbegin(self):
        """rbegin(MARKERS self) -> std::vector< MARKER_PCB * >::reverse_iterator"""
        return _pcbnew.MARKERS_rbegin(self)


    def rend(self):
        """rend(MARKERS self) -> std::vector< MARKER_PCB * >::reverse_iterator"""
        return _pcbnew.MARKERS_rend(self)


    def clear(self):
        """clear(MARKERS self)"""
        return _pcbnew.MARKERS_clear(self)


    def get_allocator(self):
        """get_allocator(MARKERS self) -> std::vector< MARKER_PCB * >::allocator_type"""
        return _pcbnew.MARKERS_get_allocator(self)


    def pop_back(self):
        """pop_back(MARKERS self)"""
        return _pcbnew.MARKERS_pop_back(self)


    def erase(self, *args):
        """
        erase(MARKERS self, std::vector< MARKER_PCB * >::iterator pos) -> std::vector< MARKER_PCB * >::iterator
        erase(MARKERS self, std::vector< MARKER_PCB * >::iterator first, std::vector< MARKER_PCB * >::iterator last) -> std::vector< MARKER_PCB * >::iterator
        """
        return _pcbnew.MARKERS_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.MARKER_PCB)> self) -> MARKERS
        __init__(std::vector<(p.MARKER_PCB)> self, MARKERS arg2) -> MARKERS
        __init__(std::vector<(p.MARKER_PCB)> self, std::vector< MARKER_PCB * >::size_type size) -> MARKERS
        __init__(std::vector<(p.MARKER_PCB)> self, std::vector< MARKER_PCB * >::size_type size, MARKER_PCB value) -> MARKERS
        """
        this = _pcbnew.new_MARKERS(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(MARKERS self, MARKER_PCB x)"""
        return _pcbnew.MARKERS_push_back(self, x)


    def front(self):
        """front(MARKERS self) -> MARKER_PCB"""
        return _pcbnew.MARKERS_front(self)


    def back(self):
        """back(MARKERS self) -> MARKER_PCB"""
        return _pcbnew.MARKERS_back(self)


    def assign(self, n, x):
        """assign(MARKERS self, std::vector< MARKER_PCB * >::size_type n, MARKER_PCB x)"""
        return _pcbnew.MARKERS_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MARKERS self, std::vector< MARKER_PCB * >::size_type new_size)
        resize(MARKERS self, std::vector< MARKER_PCB * >::size_type new_size, MARKER_PCB x)
        """
        return _pcbnew.MARKERS_resize(self, *args)


    def insert(self, *args):
        """
        insert(MARKERS self, std::vector< MARKER_PCB * >::iterator pos, MARKER_PCB x) -> std::vector< MARKER_PCB * >::iterator
        insert(MARKERS self, std::vector< MARKER_PCB * >::iterator pos, std::vector< MARKER_PCB * >::size_type n, MARKER_PCB x)
        """
        return _pcbnew.MARKERS_insert(self, *args)


    def reserve(self, n):
        """reserve(MARKERS self, std::vector< MARKER_PCB * >::size_type n)"""
        return _pcbnew.MARKERS_reserve(self, n)


    def capacity(self):
        """capacity(MARKERS self) -> std::vector< MARKER_PCB * >::size_type"""
        return _pcbnew.MARKERS_capacity(self)

    __swig_destroy__ = _pcbnew.delete_MARKERS
    __del__ = lambda self: None
MARKERS_swigregister = _pcbnew.MARKERS_swigregister
MARKERS_swigregister(MARKERS)

class ZONE_CONTAINERS(_object):
    """Proxy of C++ std::vector<(p.ZONE_CONTAINER)> class."""

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

    def iterator(self):
        """iterator(ZONE_CONTAINERS self) -> SwigPyIterator"""
        return _pcbnew.ZONE_CONTAINERS_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(ZONE_CONTAINERS self) -> bool"""
        return _pcbnew.ZONE_CONTAINERS___nonzero__(self)


    def __bool__(self):
        """__bool__(ZONE_CONTAINERS self) -> bool"""
        return _pcbnew.ZONE_CONTAINERS___bool__(self)


    def __len__(self):
        """__len__(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::size_type"""
        return _pcbnew.ZONE_CONTAINERS___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i, std::vector< ZONE_CONTAINER * >::difference_type j) -> ZONE_CONTAINERS"""
        return _pcbnew.ZONE_CONTAINERS___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i, std::vector< ZONE_CONTAINER * >::difference_type j)
        __setslice__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i, std::vector< ZONE_CONTAINER * >::difference_type j, ZONE_CONTAINERS v)
        """
        return _pcbnew.ZONE_CONTAINERS___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i, std::vector< ZONE_CONTAINER * >::difference_type j)"""
        return _pcbnew.ZONE_CONTAINERS___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i)
        __delitem__(ZONE_CONTAINERS self, PySliceObject * slice)
        """
        return _pcbnew.ZONE_CONTAINERS___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ZONE_CONTAINERS self, PySliceObject * slice) -> ZONE_CONTAINERS
        __getitem__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i) -> ZONE_CONTAINER
        """
        return _pcbnew.ZONE_CONTAINERS___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ZONE_CONTAINERS self, PySliceObject * slice, ZONE_CONTAINERS v)
        __setitem__(ZONE_CONTAINERS self, PySliceObject * slice)
        __setitem__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::difference_type i, ZONE_CONTAINER x)
        """
        return _pcbnew.ZONE_CONTAINERS___setitem__(self, *args)


    def pop(self):
        """pop(ZONE_CONTAINERS self) -> ZONE_CONTAINER"""
        return _pcbnew.ZONE_CONTAINERS_pop(self)


    def append(self, x):
        """append(ZONE_CONTAINERS self, ZONE_CONTAINER x)"""
        return _pcbnew.ZONE_CONTAINERS_append(self, x)


    def empty(self):
        """empty(ZONE_CONTAINERS self) -> bool"""
        return _pcbnew.ZONE_CONTAINERS_empty(self)


    def size(self):
        """size(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::size_type"""
        return _pcbnew.ZONE_CONTAINERS_size(self)


    def swap(self, v):
        """swap(ZONE_CONTAINERS self, ZONE_CONTAINERS v)"""
        return _pcbnew.ZONE_CONTAINERS_swap(self, v)


    def begin(self):
        """begin(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::iterator"""
        return _pcbnew.ZONE_CONTAINERS_begin(self)


    def end(self):
        """end(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::iterator"""
        return _pcbnew.ZONE_CONTAINERS_end(self)


    def rbegin(self):
        """rbegin(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::reverse_iterator"""
        return _pcbnew.ZONE_CONTAINERS_rbegin(self)


    def rend(self):
        """rend(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::reverse_iterator"""
        return _pcbnew.ZONE_CONTAINERS_rend(self)


    def clear(self):
        """clear(ZONE_CONTAINERS self)"""
        return _pcbnew.ZONE_CONTAINERS_clear(self)


    def get_allocator(self):
        """get_allocator(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::allocator_type"""
        return _pcbnew.ZONE_CONTAINERS_get_allocator(self)


    def pop_back(self):
        """pop_back(ZONE_CONTAINERS self)"""
        return _pcbnew.ZONE_CONTAINERS_pop_back(self)


    def erase(self, *args):
        """
        erase(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::iterator pos) -> std::vector< ZONE_CONTAINER * >::iterator
        erase(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::iterator first, std::vector< ZONE_CONTAINER * >::iterator last) -> std::vector< ZONE_CONTAINER * >::iterator
        """
        return _pcbnew.ZONE_CONTAINERS_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.ZONE_CONTAINER)> self) -> ZONE_CONTAINERS
        __init__(std::vector<(p.ZONE_CONTAINER)> self, ZONE_CONTAINERS arg2) -> ZONE_CONTAINERS
        __init__(std::vector<(p.ZONE_CONTAINER)> self, std::vector< ZONE_CONTAINER * >::size_type size) -> ZONE_CONTAINERS
        __init__(std::vector<(p.ZONE_CONTAINER)> self, std::vector< ZONE_CONTAINER * >::size_type size, ZONE_CONTAINER value) -> ZONE_CONTAINERS
        """
        this = _pcbnew.new_ZONE_CONTAINERS(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ZONE_CONTAINERS self, ZONE_CONTAINER x)"""
        return _pcbnew.ZONE_CONTAINERS_push_back(self, x)


    def front(self):
        """front(ZONE_CONTAINERS self) -> ZONE_CONTAINER"""
        return _pcbnew.ZONE_CONTAINERS_front(self)


    def back(self):
        """back(ZONE_CONTAINERS self) -> ZONE_CONTAINER"""
        return _pcbnew.ZONE_CONTAINERS_back(self)


    def assign(self, n, x):
        """assign(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type n, ZONE_CONTAINER x)"""
        return _pcbnew.ZONE_CONTAINERS_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type new_size)
        resize(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type new_size, ZONE_CONTAINER x)
        """
        return _pcbnew.ZONE_CONTAINERS_resize(self, *args)


    def insert(self, *args):
        """
        insert(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::iterator pos, ZONE_CONTAINER x) -> std::vector< ZONE_CONTAINER * >::iterator
        insert(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::iterator pos, std::vector< ZONE_CONTAINER * >::size_type n, ZONE_CONTAINER x)
        """
        return _pcbnew.ZONE_CONTAINERS_insert(self, *args)


    def reserve(self, n):
        """reserve(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type n)"""
        return _pcbnew.ZONE_CONTAINERS_reserve(self, n)


    def capacity(self):
        """capacity(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::size_type"""
        return _pcbnew.ZONE_CONTAINERS_capacity(self)

    __swig_destroy__ = _pcbnew.delete_ZONE_CONTAINERS
    __del__ = lambda self: None
ZONE_CONTAINERS_swigregister = _pcbnew.ZONE_CONTAINERS_swigregister
ZONE_CONTAINERS_swigregister(ZONE_CONTAINERS)

class TRACKS(_object):
    """Proxy of C++ std::vector<(p.TRACK)> class."""

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

    def iterator(self):
        """iterator(TRACKS self) -> SwigPyIterator"""
        return _pcbnew.TRACKS_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(TRACKS self) -> bool"""
        return _pcbnew.TRACKS___nonzero__(self)


    def __bool__(self):
        """__bool__(TRACKS self) -> bool"""
        return _pcbnew.TRACKS___bool__(self)


    def __len__(self):
        """__len__(TRACKS self) -> std::vector< TRACK * >::size_type"""
        return _pcbnew.TRACKS___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(TRACKS self, std::vector< TRACK * >::difference_type i, std::vector< TRACK * >::difference_type j) -> TRACKS"""
        return _pcbnew.TRACKS___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(TRACKS self, std::vector< TRACK * >::difference_type i, std::vector< TRACK * >::difference_type j)
        __setslice__(TRACKS self, std::vector< TRACK * >::difference_type i, std::vector< TRACK * >::difference_type j, TRACKS v)
        """
        return _pcbnew.TRACKS___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(TRACKS self, std::vector< TRACK * >::difference_type i, std::vector< TRACK * >::difference_type j)"""
        return _pcbnew.TRACKS___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(TRACKS self, std::vector< TRACK * >::difference_type i)
        __delitem__(TRACKS self, PySliceObject * slice)
        """
        return _pcbnew.TRACKS___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(TRACKS self, PySliceObject * slice) -> TRACKS
        __getitem__(TRACKS self, std::vector< TRACK * >::difference_type i) -> TRACK
        """
        return _pcbnew.TRACKS___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(TRACKS self, PySliceObject * slice, TRACKS v)
        __setitem__(TRACKS self, PySliceObject * slice)
        __setitem__(TRACKS self, std::vector< TRACK * >::difference_type i, TRACK x)
        """
        return _pcbnew.TRACKS___setitem__(self, *args)


    def pop(self):
        """pop(TRACKS self) -> TRACK"""
        return _pcbnew.TRACKS_pop(self)


    def append(self, x):
        """append(TRACKS self, TRACK x)"""
        return _pcbnew.TRACKS_append(self, x)


    def empty(self):
        """empty(TRACKS self) -> bool"""
        return _pcbnew.TRACKS_empty(self)


    def size(self):
        """size(TRACKS self) -> std::vector< TRACK * >::size_type"""
        return _pcbnew.TRACKS_size(self)


    def swap(self, v):
        """swap(TRACKS self, TRACKS v)"""
        return _pcbnew.TRACKS_swap(self, v)


    def begin(self):
        """begin(TRACKS self) -> std::vector< TRACK * >::iterator"""
        return _pcbnew.TRACKS_begin(self)


    def end(self):
        """end(TRACKS self) -> std::vector< TRACK * >::iterator"""
        return _pcbnew.TRACKS_end(self)


    def rbegin(self):
        """rbegin(TRACKS self) -> std::vector< TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rbegin(self)


    def rend(self):
        """rend(TRACKS self) -> std::vector< TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rend(self)


    def clear(self):
        """clear(TRACKS self)"""
        return _pcbnew.TRACKS_clear(self)


    def get_allocator(self):
        """get_allocator(TRACKS self) -> std::vector< TRACK * >::allocator_type"""
        return _pcbnew.TRACKS_get_allocator(self)


    def pop_back(self):
        """pop_back(TRACKS self)"""
        return _pcbnew.TRACKS_pop_back(self)


    def erase(self, *args):
        """
        erase(TRACKS self, std::vector< TRACK * >::iterator pos) -> std::vector< TRACK * >::iterator
        erase(TRACKS self, std::vector< TRACK * >::iterator first, std::vector< TRACK * >::iterator last) -> std::vector< TRACK * >::iterator
        """
        return _pcbnew.TRACKS_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.TRACK)> self) -> TRACKS
        __init__(std::vector<(p.TRACK)> self, TRACKS arg2) -> TRACKS
        __init__(std::vector<(p.TRACK)> self, std::vector< TRACK * >::size_type size) -> TRACKS
        __init__(std::vector<(p.TRACK)> self, std::vector< TRACK * >::size_type size, TRACK value) -> TRACKS
        """
        this = _pcbnew.new_TRACKS(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(TRACKS self, TRACK x)"""
        return _pcbnew.TRACKS_push_back(self, x)


    def front(self):
        """front(TRACKS self) -> TRACK"""
        return _pcbnew.TRACKS_front(self)


    def back(self):
        """back(TRACKS self) -> TRACK"""
        return _pcbnew.TRACKS_back(self)


    def assign(self, n, x):
        """assign(TRACKS self, std::vector< TRACK * >::size_type n, TRACK x)"""
        return _pcbnew.TRACKS_assign(self, n, x)


    def resize(self, *args):
        """
        resize(TRACKS self, std::vector< TRACK * >::size_type new_size)
        resize(TRACKS self, std::vector< TRACK * >::size_type new_size, TRACK x)
        """
        return _pcbnew.TRACKS_resize(self, *args)


    def insert(self, *args):
        """
        insert(TRACKS self, std::vector< TRACK * >::iterator pos, TRACK x) -> std::vector< TRACK * >::iterator
        insert(TRACKS self, std::vector< TRACK * >::iterator pos, std::vector< TRACK * >::size_type n, TRACK x)
        """
        return _pcbnew.TRACKS_insert(self, *args)


    def reserve(self, n):
        """reserve(TRACKS self, std::vector< TRACK * >::size_type n)"""
        return _pcbnew.TRACKS_reserve(self, n)


    def capacity(self):
        """capacity(TRACKS self) -> std::vector< TRACK * >::size_type"""
        return _pcbnew.TRACKS_capacity(self)

    __swig_destroy__ = _pcbnew.delete_TRACKS
    __del__ = lambda self: None
TRACKS_swigregister = _pcbnew.TRACKS_swigregister
TRACKS_swigregister(TRACKS)

class BOARD(BOARD_ITEM_CONTAINER):
    """Proxy of C++ BOARD class."""

    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM_CONTAINER]:
        __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_CONTAINER]:
        __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)

    ClassOf = staticmethod(ClassOf)

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


    def GetFileName(self):
        """GetFileName(BOARD self) -> wxString"""
        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_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_SegZoneDeprecated"] = _pcbnew.BOARD_m_SegZoneDeprecated_set
    __swig_getmethods__["m_SegZoneDeprecated"] = _pcbnew.BOARD_m_SegZoneDeprecated_get
    if _newclass:
        m_SegZoneDeprecated = _swig_property(_pcbnew.BOARD_m_SegZoneDeprecated_get, _pcbnew.BOARD_m_SegZoneDeprecated_set)

    def Tracks(self):
        """Tracks(BOARD self) -> DLIST_ITERATOR_WRAPPER< TRACK >"""
        return _pcbnew.BOARD_Tracks(self)


    def Modules(self):
        """Modules(BOARD self) -> DLIST_ITERATOR_WRAPPER< MODULE >"""
        return _pcbnew.BOARD_Modules(self)


    def Drawings(self):
        """Drawings(BOARD self) -> DLIST_ITERATOR_WRAPPER< BOARD_ITEM >"""
        return _pcbnew.BOARD_Drawings(self)


    def Zones(self):
        """Zones(BOARD self) -> ZONE_CONTAINERS"""
        return _pcbnew.BOARD_Zones(self)


    def AllConnectedItems(self):
        """AllConnectedItems(BOARD self) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.BOARD_AllConnectedItems(self)


    def DrawingsList(self):
        """DrawingsList(BOARD self) -> BOARD_ITEM_List"""
        return _pcbnew.BOARD_DrawingsList(self)

    __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 __builtin__.Exception:
            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, aItem, aMode=ADD_INSERT):
        """
        AddNative(BOARD self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)
        AddNative(BOARD self, BOARD_ITEM aItem)
        """
        return _pcbnew.BOARD_AddNative(self, aItem, aMode)


    def RemoveNative(self, aBoardItem):
        """RemoveNative(BOARD self, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_RemoveNative(self, aBoardItem)


    def GetItem(self, aWeakReference):
        """GetItem(BOARD self, void * aWeakReference) -> BOARD_ITEM"""
        return _pcbnew.BOARD_GetItem(self, aWeakReference)


    def Duplicate(self, aItem, aAddToBoard=False):
        """
        Duplicate(BOARD self, BOARD_ITEM aItem, bool aAddToBoard=False) -> BOARD_ITEM
        Duplicate(BOARD self, BOARD_ITEM aItem) -> BOARD_ITEM
        """
        return _pcbnew.BOARD_Duplicate(self, aItem, aAddToBoard)


    def GetConnectivity(self):
        """GetConnectivity(BOARD self) -> std::shared_ptr< CONNECTIVITY_DATA >"""
        return _pcbnew.BOARD_GetConnectivity(self)


    def BuildConnectivity(self):
        """BuildConnectivity(BOARD self)"""
        return _pcbnew.BOARD_BuildConnectivity(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, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsLayerEnabled(self, aLayer)


    def IsLayerVisible(self, aLayer):
        """IsLayerVisible(BOARD self, PCB_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, aLayer):
        """IsElementVisible(BOARD self, GAL_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsElementVisible(self, aLayer)


    def SetElementVisibility(self, aLayer, aNewState):
        """SetElementVisibility(BOARD self, GAL_LAYER_ID aLayer, bool aNewState)"""
        return _pcbnew.BOARD_SetElementVisibility(self, aLayer, aNewState)


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


    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 GetSelectMenuText(self, aUnits):
        """GetSelectMenuText(BOARD self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.BOARD_GetSelectMenuText(self, aUnits)


    def Colors(self):
        """Colors(BOARD self) -> COLORS_DESIGN_SETTINGS"""
        return _pcbnew.BOARD_Colors(self)


    def SetColorsSettings(self, aColorsSettings):
        """SetColorsSettings(BOARD self, COLORS_DESIGN_SETTINGS aColorsSettings)"""
        return _pcbnew.BOARD_SetColorsSettings(self, aColorsSettings)


    def GetBoardPolygonOutlines(self, aOutlines, aErrorText=None, aErrorLocation=None):
        """
        GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET aOutlines, wxString aErrorText=None, wxPoint aErrorLocation=None) -> bool
        GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET aOutlines, wxString aErrorText=None) -> bool
        GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET aOutlines) -> bool
        """
        return _pcbnew.BOARD_GetBoardPolygonOutlines(self, aOutlines, aErrorText, aErrorLocation)


    def ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines):
        """ConvertBrdLayerToPolygonalContours(BOARD self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aOutlines)"""
        return _pcbnew.BOARD_ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines)


    def GetLayerID(self, aLayerName):
        """GetLayerID(BOARD self, wxString aLayerName) -> PCB_LAYER_ID const"""
        return _pcbnew.BOARD_GetLayerID(self, aLayerName)


    def GetLayerName(self, aLayer):
        """GetLayerName(BOARD self, PCB_LAYER_ID aLayer) -> wxString"""
        return _pcbnew.BOARD_GetLayerName(self, aLayer)


    def SetLayerName(self, aLayer, aLayerName):
        """SetLayerName(BOARD self, PCB_LAYER_ID aLayer, wxString aLayerName) -> bool"""
        return _pcbnew.BOARD_SetLayerName(self, aLayer, aLayerName)


    def GetStandardLayerName(aLayerId):
        """GetStandardLayerName(PCB_LAYER_ID aLayerId) -> wxString"""
        return _pcbnew.BOARD_GetStandardLayerName(aLayerId)

    GetStandardLayerName = staticmethod(GetStandardLayerName)

    def SetLayerDescr(self, aIndex, aLayer):
        """SetLayerDescr(BOARD self, PCB_LAYER_ID aIndex, LAYER aLayer) -> bool"""
        return _pcbnew.BOARD_SetLayerDescr(self, aIndex, aLayer)


    def GetLayerType(self, aLayer):
        """GetLayerType(BOARD self, PCB_LAYER_ID aLayer) -> LAYER_T"""
        return _pcbnew.BOARD_GetLayerType(self, aLayer)


    def SetLayerType(self, aLayer, aLayerType):
        """SetLayerType(BOARD self, PCB_LAYER_ID aLayer, LAYER_T aLayerType) -> bool"""
        return _pcbnew.BOARD_SetLayerType(self, aLayer, aLayerType)


    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 GetNodesCount(self, aNet=-1):
        """
        GetNodesCount(BOARD self, int aNet=-1) -> unsigned int
        GetNodesCount(BOARD self) -> unsigned int
        """
        return _pcbnew.BOARD_GetNodesCount(self, aNet)


    def GetUnconnectedNetCount(self):
        """GetUnconnectedNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetUnconnectedNetCount(self)


    def GetPadCount(self):
        """GetPadCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetPadCount(self)


    def GetPads(self):
        """GetPads(BOARD self) -> D_PADS"""
        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 aNetname) -> NETINFO_ITEM
        """
        return _pcbnew.BOARD_FindNet(self, *args)


    def GetNetInfo(self):
        """GetNetInfo(BOARD self) -> NETINFO_LIST"""
        return _pcbnew.BOARD_GetNetInfo(self)


    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 GetBoardEdgesBoundingBox(self):
        """GetBoardEdgesBoundingBox(BOARD self) -> EDA_RECT"""
        return _pcbnew.BOARD_GetBoardEdgesBoundingBox(self)


    def GetMsgPanelInfo(self, aUnits, aList):
        """GetMsgPanelInfo(BOARD self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.BOARD_GetMsgPanelInfo(self, aUnits, 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 * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.BOARD_Visit(self, inspector, testData, scanTypes)


    def FindModuleByReference(self, aReference):
        """FindModuleByReference(BOARD self, wxString aReference) -> MODULE"""
        return _pcbnew.BOARD_FindModuleByReference(self, aReference)


    def FindModule(self, aRefOrTimeStamp, aSearchByTimeStamp=False):
        """
        FindModule(BOARD self, wxString aRefOrTimeStamp, bool aSearchByTimeStamp=False) -> MODULE
        FindModule(BOARD self, wxString aRefOrTimeStamp) -> MODULE
        """
        return _pcbnew.BOARD_FindModule(self, aRefOrTimeStamp, aSearchByTimeStamp)


    def ReplaceNetlist(self, aNetlist, aDeleteSinglePadNets, aNewFootprints, aReporter):
        """ReplaceNetlist(BOARD self, NETLIST & aNetlist, bool aDeleteSinglePadNets, std::vector< MODULE *,std::allocator< MODULE * > > * aNewFootprints, REPORTER & aReporter)"""
        return _pcbnew.BOARD_ReplaceNetlist(self, aNetlist, aDeleteSinglePadNets, aNewFootprints, aReporter)


    def updateComponentPadConnections(self, aNetlist, footprint, component, aReporter):
        """updateComponentPadConnections(BOARD self, NETLIST & aNetlist, MODULE footprint, COMPONENT * component, REPORTER & aReporter)"""
        return _pcbnew.BOARD_updateComponentPadConnections(self, aNetlist, footprint, component, 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, PCB_LAYER_ID aStartLayer, PCB_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, PCB_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, PCB_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, PCB_LAYER_ID aLayer, wxPoint aStartPointPosition, int aHatch) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_AddArea(self, aNewZonesList, aNetcode, aLayer, aStartPointPosition, aHatch)


    def InsertArea(self, aNetcode, aAreaIdx, aLayer, aCornerX, aCornerY, aHatch):
        """InsertArea(BOARD self, int aNetcode, int aAreaIdx, PCB_LAYER_ID aLayer, int aCornerX, int aCornerY, int aHatch) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_InsertArea(self, aNetcode, aAreaIdx, aLayer, aCornerX, aCornerY, aHatch)


    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 GetViaByPosition(self, *args):
        """
        GetViaByPosition(BOARD self, wxPoint aPosition, PCB_LAYER_ID aLayer) -> VIA
        GetViaByPosition(BOARD self, wxPoint aPosition) -> VIA
        """
        return _pcbnew.BOARD_GetViaByPosition(self, *args)


    def GetTracksByPosition(self, *args):
        """
        GetTracksByPosition(BOARD self, wxPoint aPosition, PCB_LAYER_ID aLayer) -> std::list< TRACK *,std::allocator< TRACK * > >
        GetTracksByPosition(BOARD self, wxPoint aPosition) -> std::list< TRACK *,std::allocator< TRACK * > >
        """
        return _pcbnew.BOARD_GetTracksByPosition(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, D_PADS aPadList, wxPoint aPosition, LSET aLayerMask) -> D_PAD
        """
        return _pcbnew.BOARD_GetPad(self, *args)


    def PadDelete(self, aPad):
        """PadDelete(BOARD self, D_PAD aPad)"""
        return _pcbnew.BOARD_PadDelete(self, aPad)


    def GetSortedPadListByXthenYCoord(self, aVector, aNetCode=-1):
        """
        GetSortedPadListByXthenYCoord(BOARD self, D_PADS aVector, int aNetCode=-1)
        GetSortedPadListByXthenYCoord(BOARD self, D_PADS aVector)
        """
        return _pcbnew.BOARD_GetSortedPadListByXthenYCoord(self, aVector, aNetCode)


    def GetVisibleTrack(self, aStartingTrace, aPosition, aLayerSet):
        """GetVisibleTrack(BOARD self, TRACK aStartingTrace, wxPoint aPosition, LSET aLayerSet) -> TRACK"""
        return _pcbnew.BOARD_GetVisibleTrack(self, aStartingTrace, aPosition, aLayerSet)


    def MarkTrace(self, aTrackList, aTrace, aCount, aTraceLength, aInPackageLength, aReorder):
        """MarkTrace(BOARD self, TRACK aTrackList, TRACK aTrace, int * aCount, double * aTraceLength, double * aInPackageLength, bool aReorder) -> TRACK"""
        return _pcbnew.BOARD_MarkTrace(self, aTrackList, aTrace, aCount, aTraceLength, aInPackageLength, aReorder)


    def TracksInNet(self, aNetCode):
        """TracksInNet(BOARD self, int aNetCode) -> TRACKS"""
        return _pcbnew.BOARD_TracksInNet(self, aNetCode)


    def TracksInNetBetweenPoints(self, aStartPos, aGoalPos, aNetCode):
        """TracksInNetBetweenPoints(BOARD self, wxPoint aStartPos, wxPoint aGoalPos, int aNetCode) -> TRACKS"""
        return _pcbnew.BOARD_TracksInNetBetweenPoints(self, aStartPos, aGoalPos, aNetCode)


    def GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked=False):
        """
        GetFootprint(BOARD self, wxPoint aPosition, PCB_LAYER_ID aActiveLayer, bool aVisibleOnly, bool aIgnoreLocked=False) -> MODULE
        GetFootprint(BOARD self, wxPoint aPosition, PCB_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 ClearAllNetCodes(self):
        """ClearAllNetCodes(BOARD self)"""
        return _pcbnew.BOARD_ClearAllNetCodes(self)


    def SanitizeNetcodes(self):
        """SanitizeNetcodes(BOARD self)"""
        return _pcbnew.BOARD_SanitizeNetcodes(self)



    def GetModules(self):             return self.m_Modules
    def GetDrawings(self):            return self.DrawingsList()
    def GetTracks(self):              return self.m_Track

    def Save(self,filename):
        return SaveBoard(filename,self)

    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

    def GetNetsByName(self):
        """
        Return a dictionary like object with key:wxString netname and value:NETINFO_ITEM
        """
        return self.GetNetInfo().NetsByName()

    def GetNetsByNetcode(self):
        """
        Return a dictionary like object with key:int netcode and value:NETINFO_ITEM
        """
        return self.GetNetInfo().NetsByNetcode()

    def GetNetcodeFromNetname(self,netname):
        """
        Given a netname, return its netcode
        """
        net = self.GetNetsByName()[netname]
        return net.GetNet()

    def GetAllNetClasses(self):
        """
        Return a dictionary like object with net_class_name as key and NETCLASSPTR as value
        GetNetClasses(BOARD self) -> { wxString net_class_name : NETCLASSPTR }
        Include the "Default" netclass also.
        """
        netclassmap = self.GetNetClasses().NetClasses()

    # Add the Default one too, but this is probably modifying the NETCLASS_MAP
    # in the BOARD.  If that causes trouble, could make a deepcopy() here first.
    # netclassmap = deepcopy(netclassmap)
        netclassmap['Default'] = self.GetNetClasses().GetDefault()
        return netclassmap

BOARD_swigregister = _pcbnew.BOARD_swigregister
BOARD_swigregister(BOARD)

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

def BOARD_GetStandardLayerName(aLayerId):
    """BOARD_GetStandardLayerName(PCB_LAYER_ID aLayerId) -> wxString"""
    return _pcbnew.BOARD_GetStandardLayerName(aLayerId)

DO_NOT_INCLUDE_NPTH = _pcbnew.DO_NOT_INCLUDE_NPTH
INCLUDE_NPTH = _pcbnew.INCLUDE_NPTH
MOD_DEFAULT = _pcbnew.MOD_DEFAULT
MOD_CMS = _pcbnew.MOD_CMS
MOD_VIRTUAL = _pcbnew.MOD_VIRTUAL
class MODULE_3D_SETTINGS(_object):
    """Proxy of C++ MODULE_3D_SETTINGS class."""

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

    def __init__(self):
        """__init__(MODULE_3D_SETTINGS self) -> MODULE_3D_SETTINGS"""
        this = _pcbnew.new_MODULE_3D_SETTINGS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["m_Scale"] = _pcbnew.MODULE_3D_SETTINGS_m_Scale_set
    __swig_getmethods__["m_Scale"] = _pcbnew.MODULE_3D_SETTINGS_m_Scale_get
    if _newclass:
        m_Scale = _swig_property(_pcbnew.MODULE_3D_SETTINGS_m_Scale_get, _pcbnew.MODULE_3D_SETTINGS_m_Scale_set)
    __swig_setmethods__["m_Rotation"] = _pcbnew.MODULE_3D_SETTINGS_m_Rotation_set
    __swig_getmethods__["m_Rotation"] = _pcbnew.MODULE_3D_SETTINGS_m_Rotation_get
    if _newclass:
        m_Rotation = _swig_property(_pcbnew.MODULE_3D_SETTINGS_m_Rotation_get, _pcbnew.MODULE_3D_SETTINGS_m_Rotation_set)
    __swig_setmethods__["m_Offset"] = _pcbnew.MODULE_3D_SETTINGS_m_Offset_set
    __swig_getmethods__["m_Offset"] = _pcbnew.MODULE_3D_SETTINGS_m_Offset_get
    if _newclass:
        m_Offset = _swig_property(_pcbnew.MODULE_3D_SETTINGS_m_Offset_get, _pcbnew.MODULE_3D_SETTINGS_m_Offset_set)
    __swig_setmethods__["m_Filename"] = _pcbnew.MODULE_3D_SETTINGS_m_Filename_set
    __swig_getmethods__["m_Filename"] = _pcbnew.MODULE_3D_SETTINGS_m_Filename_get
    if _newclass:
        m_Filename = _swig_property(_pcbnew.MODULE_3D_SETTINGS_m_Filename_get, _pcbnew.MODULE_3D_SETTINGS_m_Filename_set)
    __swig_setmethods__["m_Preview"] = _pcbnew.MODULE_3D_SETTINGS_m_Preview_set
    __swig_getmethods__["m_Preview"] = _pcbnew.MODULE_3D_SETTINGS_m_Preview_get
    if _newclass:
        m_Preview = _swig_property(_pcbnew.MODULE_3D_SETTINGS_m_Preview_get, _pcbnew.MODULE_3D_SETTINGS_m_Preview_set)
    __swig_destroy__ = _pcbnew.delete_MODULE_3D_SETTINGS
    __del__ = lambda self: None
MODULE_3D_SETTINGS_swigregister = _pcbnew.MODULE_3D_SETTINGS_swigregister
MODULE_3D_SETTINGS_swigregister(MODULE_3D_SETTINGS)

class MODULE_3D_SETTINGS_VECTOR3D(_object):
    """Proxy of C++ MODULE_3D_SETTINGS::VECTOR3D class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MODULE_3D_SETTINGS_VECTOR3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MODULE_3D_SETTINGS_VECTOR3D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_x_set
    __swig_getmethods__["x"] = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_x_get
    if _newclass:
        x = _swig_property(_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_x_get, _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_x_set)
    __swig_setmethods__["y"] = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_y_set
    __swig_getmethods__["y"] = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_y_get
    if _newclass:
        y = _swig_property(_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_y_get, _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_y_set)
    __swig_setmethods__["z"] = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_z_set
    __swig_getmethods__["z"] = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_z_get
    if _newclass:
        z = _swig_property(_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_z_get, _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_z_set)

    def __init__(self):
        """__init__(MODULE_3D_SETTINGS::VECTOR3D self) -> MODULE_3D_SETTINGS_VECTOR3D"""
        this = _pcbnew.new_MODULE_3D_SETTINGS_VECTOR3D()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_MODULE_3D_SETTINGS_VECTOR3D
    __del__ = lambda self: None
MODULE_3D_SETTINGS_VECTOR3D_swigregister = _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_swigregister
MODULE_3D_SETTINGS_VECTOR3D_swigregister(MODULE_3D_SETTINGS_VECTOR3D)

class MODULE(BOARD_ITEM_CONTAINER):
    """Proxy of C++ MODULE class."""

    __swig_setmethods__ = {}
    for _s in [BOARD_ITEM_CONTAINER]:
        __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_CONTAINER]:
        __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 __builtin__.Exception:
            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)

    ClassOf = staticmethod(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 AddNative(self, aItem, aMode=ADD_INSERT):
        """
        AddNative(MODULE self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)
        AddNative(MODULE self, BOARD_ITEM aItem)
        """
        return _pcbnew.MODULE_AddNative(self, aItem, aMode)


    def RemoveNative(self, aItem):
        """RemoveNative(MODULE self, BOARD_ITEM aItem)"""
        return _pcbnew.MODULE_RemoveNative(self, aItem)


    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 GetBoundingPoly(self):
        """GetBoundingPoly(MODULE self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_GetBoundingPoly(self)


    def GetBoundingBox(self):
        """GetBoundingBox(MODULE self) -> EDA_RECT"""
        return _pcbnew.MODULE_GetBoundingBox(self)


    def PadsList(self, *args):
        """
        PadsList(MODULE self) -> PAD_List
        PadsList(MODULE self) -> PAD_List
        """
        return _pcbnew.MODULE_PadsList(self, *args)


    def GraphicalItemsList(self, *args):
        """
        GraphicalItemsList(MODULE self) -> BOARD_ITEM_List
        GraphicalItemsList(MODULE self) -> BOARD_ITEM_List
        """
        return _pcbnew.MODULE_GraphicalItemsList(self, *args)


    def Pads(self):
        """Pads(MODULE self) -> DLIST_ITERATOR_WRAPPER< D_PAD >"""
        return _pcbnew.MODULE_Pads(self)


    def GraphicalItems(self):
        """GraphicalItems(MODULE self) -> DLIST_ITERATOR_WRAPPER< BOARD_ITEM >"""
        return _pcbnew.MODULE_GraphicalItems(self)


    def Models(self, *args):
        """
        Models(MODULE self) -> MODULE_3D_SETTINGS_List
        Models(MODULE self) -> MODULE_3D_SETTINGS_List
        """
        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 SetOrientationDegrees(self, aOrientation):
        """SetOrientationDegrees(MODULE self, double aOrientation)"""
        return _pcbnew.MODULE_SetOrientationDegrees(self, aOrientation)


    def GetOrientation(self):
        """GetOrientation(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientation(self)


    def GetOrientationDegrees(self):
        """GetOrientationDegrees(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientationDegrees(self)


    def GetOrientationRadians(self):
        """GetOrientationRadians(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientationRadians(self)


    def GetFPID(self):
        """GetFPID(MODULE self) -> LIB_ID"""
        return _pcbnew.MODULE_GetFPID(self)


    def SetFPID(self, aFPID):
        """SetFPID(MODULE self, LIB_ID aFPID)"""
        return _pcbnew.MODULE_SetFPID(self, aFPID)


    def GetDescription(self):
        """GetDescription(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetDescription(self)


    def SetDescription(self, aDoc):
        """SetDescription(MODULE self, wxString aDoc)"""
        return _pcbnew.MODULE_SetDescription(self, aDoc)


    def GetKeywords(self):
        """GetKeywords(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetKeywords(self)


    def SetKeywords(self, aKeywords):
        """SetKeywords(MODULE self, wxString aKeywords)"""
        return _pcbnew.MODULE_SetKeywords(self, aKeywords)


    def GetPath(self):
        """GetPath(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetPath(self)


    def SetPath(self, aPath):
        """SetPath(MODULE self, wxString 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 IsNetTie(self):
        """IsNetTie(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsNetTie(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, timestamp_t aTime)
        SetLastEditTime(MODULE self)
        """
        return _pcbnew.MODULE_SetLastEditTime(self, *args)


    def GetLastEditTime(self):
        """GetLastEditTime(MODULE self) -> timestamp_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, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)
        TransformPadsShapesWithClearanceToPolygon(MODULE self, PCB_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, aCircleToSegmentsCountForTexts=0, aIncludeText=True):
        """
        TransformGraphicShapesWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0, bool aIncludeText=True)
        TransformGraphicShapesWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0)
        TransformGraphicShapesWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts, aIncludeText)


    def TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts=0):
        """
        TransformGraphicTextWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0)
        TransformGraphicTextWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts)


    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, aUnits, aList):
        """GetMsgPanelInfo(MODULE self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MODULE_GetMsgPanelInfo(self, aUnits, aList)


    def HitTestAccurate(self, aPosition):
        """HitTestAccurate(MODULE self, wxPoint aPosition) -> bool"""
        return _pcbnew.MODULE_HitTestAccurate(self, aPosition)


    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"""
        return _pcbnew.MODULE_GetReference(self)


    def SetReference(self, aReference):
        """SetReference(MODULE self, wxString aReference)"""
        return _pcbnew.MODULE_SetReference(self, aReference)


    def IncrementReference(self, aDelta):
        """IncrementReference(MODULE self, int aDelta)"""
        return _pcbnew.MODULE_IncrementReference(self, aDelta)


    def GetValue(self):
        """GetValue(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetValue(self)


    def SetValue(self, aValue):
        """SetValue(MODULE self, wxString 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 FindPadByName(self, aPadName):
        """FindPadByName(MODULE self, wxString 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 GetTopLeftPad(self):
        """GetTopLeftPad(MODULE self) -> D_PAD"""
        return _pcbnew.MODULE_GetTopLeftPad(self)


    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 GetUniquePadCount(self, *args):
        """
        GetUniquePadCount(MODULE self, INCLUDE_NPTH_T aIncludeNPTH) -> unsigned int
        GetUniquePadCount(MODULE self) -> unsigned int
        """
        return _pcbnew.MODULE_GetUniquePadCount(self, *args)


    def GetNextPadName(self, aFillSequenceGaps):
        """GetNextPadName(MODULE self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_GetNextPadName(self, aFillSequenceGaps)


    def GetArea(self, aPadding=0):
        """
        GetArea(MODULE self, int aPadding=0) -> double
        GetArea(MODULE self) -> double
        """
        return _pcbnew.MODULE_GetArea(self, aPadding)


    def GetLink(self):
        """GetLink(MODULE self) -> timestamp_t"""
        return _pcbnew.MODULE_GetLink(self)


    def SetLink(self, aLink):
        """SetLink(MODULE self, timestamp_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 Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule=False):
        """
        Duplicate(MODULE self, BOARD_ITEM aItem, bool aIncrementPadNumbers, bool aAddToModule=False) -> BOARD_ITEM
        Duplicate(MODULE self, BOARD_ITEM aItem, bool aIncrementPadNumbers) -> BOARD_ITEM
        """
        return _pcbnew.MODULE_Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule)


    def Add3DModel(self, a3DModel):
        """Add3DModel(MODULE self, MODULE_3D_SETTINGS a3DModel)"""
        return _pcbnew.MODULE_Add3DModel(self, a3DModel)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(MODULE self, INSPECTOR inspector, void * 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, aUnits):
        """GetSelectMenuText(MODULE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.MODULE_GetSelectMenuText(self, aUnits)


    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, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.MODULE_RunOnChildren(self, aFunction)


    def GetAllDrawingLayers(self, aLayers, aCount, aIncludePads=True):
        """
        GetAllDrawingLayers(MODULE self, int [] aLayers, int & aCount, bool aIncludePads=True)
        GetAllDrawingLayers(MODULE self, int [] aLayers, int & aCount)
        """
        return _pcbnew.MODULE_GetAllDrawingLayers(self, aLayers, aCount, aIncludePads)


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


    def ViewGetLOD(self, aLayer, aView):
        """ViewGetLOD(MODULE self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.MODULE_ViewGetLOD(self, aLayer, aView)


    def ViewBBox(self):
        """ViewBBox(MODULE self) -> BOX2I const"""
        return _pcbnew.MODULE_ViewBBox(self)


    def CopyNetlistSettings(self, aModule, aCopyLocalSettings):
        """CopyNetlistSettings(MODULE self, MODULE aModule, bool aCopyLocalSettings)"""
        return _pcbnew.MODULE_CopyNetlistSettings(self, aModule, aCopyLocalSettings)


    def IsLibNameValid(aName):
        """IsLibNameValid(wxString aName) -> bool"""
        return _pcbnew.MODULE_IsLibNameValid(aName)

    IsLibNameValid = staticmethod(IsLibNameValid)

    def StringLibNameInvalidChars(aUserReadable):
        """StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
        return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)

    StringLibNameInvalidChars = staticmethod(StringLibNameInvalidChars)

    def SetInitialComments(self, aInitialComments):
        """SetInitialComments(MODULE self, wxArrayString * aInitialComments)"""
        return _pcbnew.MODULE_SetInitialComments(self, aInitialComments)


    def CoverageRatio(self, aCollector):
        """CoverageRatio(MODULE self, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.MODULE_CoverageRatio(self, aCollector)


    def GetInitialComments(self):
        """GetInitialComments(MODULE self) -> wxArrayString const *"""
        return _pcbnew.MODULE_GetInitialComments(self)


    def GetPolyCourtyardFront(self):
        """GetPolyCourtyardFront(MODULE self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_GetPolyCourtyardFront(self)


    def GetPolyCourtyardBack(self):
        """GetPolyCourtyardBack(MODULE self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_GetPolyCourtyardBack(self)


    def BuildPolyCourtyard(self):
        """BuildPolyCourtyard(MODULE self) -> bool"""
        return _pcbnew.MODULE_BuildPolyCourtyard(self)


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



    def Pads(self):            return self.PadsList()
    def GraphicalItems(self):  return self.GraphicalItemsList()

    #def SaveToLibrary(self,filename):
    #  return SaveModuleToLibrary(filename,self)

    #
    # add function, clears the thisown to avoid python from deleting
    # the object in the garbage collector
    #

MODULE_swigregister = _pcbnew.MODULE_swigregister
MODULE_swigregister(MODULE)

def MODULE_ClassOf(aItem):
    """MODULE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.MODULE_ClassOf(aItem)
MODULE_is_LOCKED = _pcbnew.MODULE_is_LOCKED
MODULE_is_PLACED = _pcbnew.MODULE_is_PLACED
MODULE_to_PLACE = _pcbnew.MODULE_to_PLACE
MODULE_PADS_LOCKED = _pcbnew.MODULE_PADS_LOCKED

def MODULE_IsLibNameValid(aName):
    """MODULE_IsLibNameValid(wxString aName) -> bool"""
    return _pcbnew.MODULE_IsLibNameValid(aName)

def MODULE_StringLibNameInvalidChars(aUserReadable):
    """MODULE_StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
    return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)

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, Python 2 way to implement an iterator
            return self.__next__()

        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 __builtin__.Exception:
            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 AddNative(self, aItem, aMode=ADD_INSERT):
        """
        AddNative(MODULE_List self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)
        AddNative(MODULE_List self, BOARD_ITEM aItem)
        """
        return _pcbnew.MODULE_List_AddNative(self, aItem, aMode)


    def RemoveNative(self, aItem):
        """RemoveNative(MODULE_List self, BOARD_ITEM aItem)"""
        return _pcbnew.MODULE_List_RemoveNative(self, aItem)


    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 GetBoundingPoly(self):
        """GetBoundingPoly(MODULE_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_List_GetBoundingPoly(self)


    def GetBoundingBox(self):
        """GetBoundingBox(MODULE_List self) -> EDA_RECT"""
        return _pcbnew.MODULE_List_GetBoundingBox(self)


    def PadsList(self, *args):
        """
        PadsList(MODULE_List self) -> PAD_List
        PadsList(MODULE_List self) -> PAD_List
        """
        return _pcbnew.MODULE_List_PadsList(self, *args)


    def GraphicalItemsList(self, *args):
        """
        GraphicalItemsList(MODULE_List self) -> BOARD_ITEM_List
        GraphicalItemsList(MODULE_List self) -> BOARD_ITEM_List
        """
        return _pcbnew.MODULE_List_GraphicalItemsList(self, *args)


    def Pads(self):
        """Pads(MODULE_List self) -> DLIST_ITERATOR_WRAPPER< D_PAD >"""
        return _pcbnew.MODULE_List_Pads(self)


    def GraphicalItems(self):
        """GraphicalItems(MODULE_List self) -> DLIST_ITERATOR_WRAPPER< BOARD_ITEM >"""
        return _pcbnew.MODULE_List_GraphicalItems(self)


    def Models(self, *args):
        """
        Models(MODULE_List self) -> MODULE_3D_SETTINGS_List
        Models(MODULE_List self) -> MODULE_3D_SETTINGS_List
        """
        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 SetOrientationDegrees(self, aOrientation):
        """SetOrientationDegrees(MODULE_List self, double aOrientation)"""
        return _pcbnew.MODULE_List_SetOrientationDegrees(self, aOrientation)


    def GetOrientation(self):
        """GetOrientation(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientation(self)


    def GetOrientationDegrees(self):
        """GetOrientationDegrees(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientationDegrees(self)


    def GetOrientationRadians(self):
        """GetOrientationRadians(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientationRadians(self)


    def GetFPID(self):
        """GetFPID(MODULE_List self) -> LIB_ID"""
        return _pcbnew.MODULE_List_GetFPID(self)


    def SetFPID(self, aFPID):
        """SetFPID(MODULE_List self, LIB_ID aFPID)"""
        return _pcbnew.MODULE_List_SetFPID(self, aFPID)


    def GetDescription(self):
        """GetDescription(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetDescription(self)


    def SetDescription(self, aDoc):
        """SetDescription(MODULE_List self, wxString aDoc)"""
        return _pcbnew.MODULE_List_SetDescription(self, aDoc)


    def GetKeywords(self):
        """GetKeywords(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetKeywords(self)


    def SetKeywords(self, aKeywords):
        """SetKeywords(MODULE_List self, wxString aKeywords)"""
        return _pcbnew.MODULE_List_SetKeywords(self, aKeywords)


    def GetPath(self):
        """GetPath(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetPath(self)


    def SetPath(self, aPath):
        """SetPath(MODULE_List self, wxString 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 IsNetTie(self):
        """IsNetTie(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsNetTie(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, timestamp_t aTime)
        SetLastEditTime(MODULE_List self)
        """
        return _pcbnew.MODULE_List_SetLastEditTime(self, *args)


    def GetLastEditTime(self):
        """GetLastEditTime(MODULE_List self) -> timestamp_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, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)
        TransformPadsShapesWithClearanceToPolygon(MODULE_List self, PCB_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, aCircleToSegmentsCountForTexts=0, aIncludeText=True):
        """
        TransformGraphicShapesWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0, bool aIncludeText=True)
        TransformGraphicShapesWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0)
        TransformGraphicShapesWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_List_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts, aIncludeText)


    def TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts=0):
        """
        TransformGraphicTextWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0)
        TransformGraphicTextWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_List_TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts)


    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, aUnits, aList):
        """GetMsgPanelInfo(MODULE_List self, EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MODULE_List_GetMsgPanelInfo(self, aUnits, 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 HitTestAccurate(self, aPosition):
        """HitTestAccurate(MODULE_List self, wxPoint aPosition) -> bool"""
        return _pcbnew.MODULE_List_HitTestAccurate(self, aPosition)


    def GetReference(self):
        """GetReference(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetReference(self)


    def SetReference(self, aReference):
        """SetReference(MODULE_List self, wxString aReference)"""
        return _pcbnew.MODULE_List_SetReference(self, aReference)


    def IncrementReference(self, aDelta):
        """IncrementReference(MODULE_List self, int aDelta)"""
        return _pcbnew.MODULE_List_IncrementReference(self, aDelta)


    def GetValue(self):
        """GetValue(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetValue(self)


    def SetValue(self, aValue):
        """SetValue(MODULE_List self, wxString 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 FindPadByName(self, aPadName):
        """FindPadByName(MODULE_List self, wxString 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 GetTopLeftPad(self):
        """GetTopLeftPad(MODULE_List self) -> D_PAD"""
        return _pcbnew.MODULE_List_GetTopLeftPad(self)


    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 GetUniquePadCount(self, *args):
        """
        GetUniquePadCount(MODULE_List self, INCLUDE_NPTH_T aIncludeNPTH) -> unsigned int
        GetUniquePadCount(MODULE_List self) -> unsigned int
        """
        return _pcbnew.MODULE_List_GetUniquePadCount(self, *args)


    def GetNextPadName(self, aFillSequenceGaps):
        """GetNextPadName(MODULE_List self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_List_GetNextPadName(self, aFillSequenceGaps)


    def GetArea(self, aPadding=0):
        """
        GetArea(MODULE_List self, int aPadding=0) -> double
        GetArea(MODULE_List self) -> double
        """
        return _pcbnew.MODULE_List_GetArea(self, aPadding)


    def GetLink(self):
        """GetLink(MODULE_List self) -> timestamp_t"""
        return _pcbnew.MODULE_List_GetLink(self)


    def SetLink(self, aLink):
        """SetLink(MODULE_List self, timestamp_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 Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule=False):
        """
        Duplicate(MODULE_List self, BOARD_ITEM aItem, bool aIncrementPadNumbers, bool aAddToModule=False) -> BOARD_ITEM
        Duplicate(MODULE_List self, BOARD_ITEM aItem, bool aIncrementPadNumbers) -> BOARD_ITEM
        """
        return _pcbnew.MODULE_List_Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule)


    def Add3DModel(self, a3DModel):
        """Add3DModel(MODULE_List self, MODULE_3D_SETTINGS a3DModel)"""
        return _pcbnew.MODULE_List_Add3DModel(self, a3DModel)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(MODULE_List self, INSPECTOR inspector, void * 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, aUnits):
        """GetSelectMenuText(MODULE_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.MODULE_List_GetSelectMenuText(self, aUnits)


    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, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.MODULE_List_RunOnChildren(self, aFunction)


    def GetAllDrawingLayers(self, aLayers, aCount, aIncludePads=True):
        """
        GetAllDrawingLayers(MODULE_List self, int [] aLayers, int & aCount, bool aIncludePads=True)
        GetAllDrawingLayers(MODULE_List self, int [] aLayers, int & aCount)
        """
        return _pcbnew.MODULE_List_GetAllDrawingLayers(self, aLayers, aCount, aIncludePads)


    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, aView):
        """ViewGetLOD(MODULE_List self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.MODULE_List_ViewGetLOD(self, aLayer, aView)


    def ViewBBox(self):
        """ViewBBox(MODULE_List self) -> BOX2I const"""
        return _pcbnew.MODULE_List_ViewBBox(self)


    def CopyNetlistSettings(self, aModule, aCopyLocalSettings):
        """CopyNetlistSettings(MODULE_List self, MODULE aModule, bool aCopyLocalSettings)"""
        return _pcbnew.MODULE_List_CopyNetlistSettings(self, aModule, aCopyLocalSettings)


    def IsLibNameValid(self, aName):
        """IsLibNameValid(MODULE_List self, wxString 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 CoverageRatio(self, aCollector):
        """CoverageRatio(MODULE_List self, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.MODULE_List_CoverageRatio(self, aCollector)


    def GetInitialComments(self):
        """GetInitialComments(MODULE_List self) -> wxArrayString const *"""
        return _pcbnew.MODULE_List_GetInitialComments(self)


    def GetPolyCourtyardFront(self):
        """GetPolyCourtyardFront(MODULE_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_List_GetPolyCourtyardFront(self)


    def GetPolyCourtyardBack(self):
        """GetPolyCourtyardBack(MODULE_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_List_GetPolyCourtyardBack(self)


    def BuildPolyCourtyard(self):
        """BuildPolyCourtyard(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_BuildPolyCourtyard(self)


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


    def DeleteNative(self, aItem):
        """DeleteNative(MODULE_List self, BOARD_ITEM aItem)"""
        return _pcbnew.MODULE_List_DeleteNative(self, aItem)


    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_CONTAINER"""
        return _pcbnew.MODULE_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(MODULE_List self) -> PCB_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, PCB_LAYER_ID aLayer)"""
        return _pcbnew.MODULE_List_SetLayer(self, aLayer)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(MODULE_List self, PCB_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 TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth=False):
        """
        TransformShapeWithClearanceToPolygon(MODULE_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)
        TransformShapeWithClearanceToPolygon(MODULE_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)


    def Type(self):
        """Type(MODULE_List self) -> KICAD_T"""
        return _pcbnew.MODULE_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(MODULE_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.MODULE_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(MODULE_List self) -> timestamp_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 IsType(self, aScanTypes):
        """IsType(MODULE_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.MODULE_List_IsType(self, aScanTypes)


    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 * 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 MODULE_3D_SETTINGS_List(_object):
    """Proxy of C++ std::list<(MODULE_3D_SETTINGS)> class."""

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

    def iterator(self):
        """iterator(MODULE_3D_SETTINGS_List self) -> SwigPyIterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(MODULE_3D_SETTINGS_List self) -> bool"""
        return _pcbnew.MODULE_3D_SETTINGS_List___nonzero__(self)


    def __bool__(self):
        """__bool__(MODULE_3D_SETTINGS_List self) -> bool"""
        return _pcbnew.MODULE_3D_SETTINGS_List___bool__(self)


    def __len__(self):
        """__len__(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::size_type"""
        return _pcbnew.MODULE_3D_SETTINGS_List___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i, std::list< MODULE_3D_SETTINGS >::difference_type j) -> MODULE_3D_SETTINGS_List"""
        return _pcbnew.MODULE_3D_SETTINGS_List___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i, std::list< MODULE_3D_SETTINGS >::difference_type j)
        __setslice__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i, std::list< MODULE_3D_SETTINGS >::difference_type j, MODULE_3D_SETTINGS_List v)
        """
        return _pcbnew.MODULE_3D_SETTINGS_List___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i, std::list< MODULE_3D_SETTINGS >::difference_type j)"""
        return _pcbnew.MODULE_3D_SETTINGS_List___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i)
        __delitem__(MODULE_3D_SETTINGS_List self, PySliceObject * slice)
        """
        return _pcbnew.MODULE_3D_SETTINGS_List___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MODULE_3D_SETTINGS_List self, PySliceObject * slice) -> MODULE_3D_SETTINGS_List
        __getitem__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i) -> MODULE_3D_SETTINGS
        """
        return _pcbnew.MODULE_3D_SETTINGS_List___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MODULE_3D_SETTINGS_List self, PySliceObject * slice, MODULE_3D_SETTINGS_List v)
        __setitem__(MODULE_3D_SETTINGS_List self, PySliceObject * slice)
        __setitem__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::difference_type i, MODULE_3D_SETTINGS x)
        """
        return _pcbnew.MODULE_3D_SETTINGS_List___setitem__(self, *args)


    def pop(self):
        """pop(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS"""
        return _pcbnew.MODULE_3D_SETTINGS_List_pop(self)


    def append(self, x):
        """append(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_append(self, x)


    def empty(self):
        """empty(MODULE_3D_SETTINGS_List self) -> bool"""
        return _pcbnew.MODULE_3D_SETTINGS_List_empty(self)


    def size(self):
        """size(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::size_type"""
        return _pcbnew.MODULE_3D_SETTINGS_List_size(self)


    def swap(self, v):
        """swap(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS_List v)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_swap(self, v)


    def begin(self):
        """begin(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_begin(self)


    def end(self):
        """end(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_end(self)


    def rbegin(self):
        """rbegin(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::reverse_iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_rbegin(self)


    def rend(self):
        """rend(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::reverse_iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_rend(self)


    def clear(self):
        """clear(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_clear(self)


    def get_allocator(self):
        """get_allocator(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::allocator_type"""
        return _pcbnew.MODULE_3D_SETTINGS_List_get_allocator(self)


    def pop_back(self):
        """pop_back(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_pop_back(self)


    def erase(self, *args):
        """
        erase(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::iterator pos) -> std::list< MODULE_3D_SETTINGS >::iterator
        erase(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::iterator first, std::list< MODULE_3D_SETTINGS >::iterator last) -> std::list< MODULE_3D_SETTINGS >::iterator
        """
        return _pcbnew.MODULE_3D_SETTINGS_List_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(MODULE_3D_SETTINGS)> self) -> MODULE_3D_SETTINGS_List
        __init__(std::list<(MODULE_3D_SETTINGS)> self, MODULE_3D_SETTINGS_List arg2) -> MODULE_3D_SETTINGS_List
        __init__(std::list<(MODULE_3D_SETTINGS)> self, std::list< MODULE_3D_SETTINGS >::size_type size) -> MODULE_3D_SETTINGS_List
        __init__(std::list<(MODULE_3D_SETTINGS)> self, std::list< MODULE_3D_SETTINGS >::size_type size, MODULE_3D_SETTINGS value) -> MODULE_3D_SETTINGS_List
        """
        this = _pcbnew.new_MODULE_3D_SETTINGS_List(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_push_back(self, x)


    def front(self):
        """front(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS"""
        return _pcbnew.MODULE_3D_SETTINGS_List_front(self)


    def back(self):
        """back(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS"""
        return _pcbnew.MODULE_3D_SETTINGS_List_back(self)


    def assign(self, n, x):
        """assign(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::size_type n, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::size_type new_size)
        resize(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::size_type new_size, MODULE_3D_SETTINGS x)
        """
        return _pcbnew.MODULE_3D_SETTINGS_List_resize(self, *args)


    def insert(self, *args):
        """
        insert(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::iterator pos, MODULE_3D_SETTINGS x) -> std::list< MODULE_3D_SETTINGS >::iterator
        insert(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::iterator pos, std::list< MODULE_3D_SETTINGS >::size_type n, MODULE_3D_SETTINGS x)
        """
        return _pcbnew.MODULE_3D_SETTINGS_List_insert(self, *args)


    def pop_front(self):
        """pop_front(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_pop_front(self)


    def push_front(self, x):
        """push_front(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_push_front(self, x)


    def reverse(self):
        """reverse(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_reverse(self)

    __swig_destroy__ = _pcbnew.delete_MODULE_3D_SETTINGS_List
    __del__ = lambda self: None
MODULE_3D_SETTINGS_List_swigregister = _pcbnew.MODULE_3D_SETTINGS_List_swigregister
MODULE_3D_SETTINGS_List_swigregister(MODULE_3D_SETTINGS_List)


def GetPluginForPath(libname):
    plugin_type = IO_MGR.GuessPluginTypeFromLibPath( libname );
    return IO_MGR.PluginFind(plugin_type)

def FootprintEnumerate(libname):
    plug = GetPluginForPath(libname)
    return plug.FootprintEnumerate(libname)

def FootprintLoad(libname,name):
    plug = GetPluginForPath(libname)
    return plug.FootprintLoad(libname,name)

def FootprintSave(libname,module):
    plug = GetPluginForPath(libname)
    return plug.FootprintSave(libname,module)

def FootprintDelete(libname,name):
    plug = GetPluginForPath(libname)
    plug.FootprintDelete(libname,name)

def FootprintLibCreate(libname):
    plug = GetPluginForPath(libname)
    plug.FootprintLibCreate(libname)

def FootprintLibDelete(libname):
    plug = GetPluginForPath(libname)
    plug.FootprintLibDelete(libname)

def FootprintIsWritable(libname):
    plug = GetPluginForPath(libname)
    plug.FootprintLibIsWritable(libname)

class PYTHON_FOOTPRINT_WIZARD_LIST(_object):
    """Proxy of C++ PYTHON_FOOTPRINT_WIZARD_LIST class."""

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

    def register_wizard(wizard):
        """register_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard)

    register_wizard = staticmethod(register_wizard)

    def deregister_wizard(wizard):
        """deregister_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard)

    deregister_wizard = staticmethod(deregister_wizard)

    def __init__(self):
        """__init__(PYTHON_FOOTPRINT_WIZARD_LIST self) -> PYTHON_FOOTPRINT_WIZARD_LIST"""
        this = _pcbnew.new_PYTHON_FOOTPRINT_WIZARD_LIST()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PYTHON_FOOTPRINT_WIZARD_LIST
    __del__ = lambda self: None
PYTHON_FOOTPRINT_WIZARD_LIST_swigregister = _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_swigregister
PYTHON_FOOTPRINT_WIZARD_LIST_swigregister(PYTHON_FOOTPRINT_WIZARD_LIST)

def PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard):
    """PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard)

def PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard):
    """PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard)

class PYTHON_ACTION_PLUGINS(_object):
    """Proxy of C++ PYTHON_ACTION_PLUGINS class."""

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

    def register_action(wizard):
        """register_action(PyObject * wizard)"""
        return _pcbnew.PYTHON_ACTION_PLUGINS_register_action(wizard)

    register_action = staticmethod(register_action)

    def deregister_action(wizard):
        """deregister_action(PyObject * wizard)"""
        return _pcbnew.PYTHON_ACTION_PLUGINS_deregister_action(wizard)

    deregister_action = staticmethod(deregister_action)

    def __init__(self):
        """__init__(PYTHON_ACTION_PLUGINS self) -> PYTHON_ACTION_PLUGINS"""
        this = _pcbnew.new_PYTHON_ACTION_PLUGINS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PYTHON_ACTION_PLUGINS
    __del__ = lambda self: None
PYTHON_ACTION_PLUGINS_swigregister = _pcbnew.PYTHON_ACTION_PLUGINS_swigregister
PYTHON_ACTION_PLUGINS_swigregister(PYTHON_ACTION_PLUGINS)

def PYTHON_ACTION_PLUGINS_register_action(wizard):
    """PYTHON_ACTION_PLUGINS_register_action(PyObject * wizard)"""
    return _pcbnew.PYTHON_ACTION_PLUGINS_register_action(wizard)

def PYTHON_ACTION_PLUGINS_deregister_action(wizard):
    """PYTHON_ACTION_PLUGINS_deregister_action(PyObject * wizard)"""
    return _pcbnew.PYTHON_ACTION_PLUGINS_deregister_action(wizard)


def ToMM(iu):
    if type(iu) in [int,float]:
        return float(iu) / float(IU_PER_MM)
    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(IU_PER_MM))
    elif type(mm) in [wxPoint,wxSize]:
        return tuple(map(FromMM,mm))

def ToMils(iu):
    if type(iu) in [int,float]:
        return float(iu) / float(IU_PER_MILS)
    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(IU_PER_MILS))
    elif type(mils) in [wxPoint,wxSize]:
        return tuple(map(FromMils,mils))

def PutOnGridMM(value, gridSizeMM):
    thresh = FromMM(gridSizeMM)
    return round(value/thresh)*thresh

def PutOnGridMils(value, gridSizeMils):
    thresh = FromMils(gridSizeMils)
    return round(value/thresh)*thresh

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.


