# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# 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:
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pcbnew
else:
    import _pcbnew

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register SwigPyIterator in _pcbnew:
_pcbnew.SwigPyIterator_swigregister(SwigPyIterator)

class string(object):
    r"""Proxy of C++ std::basic_string< char > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

    def copy(self, __s, __n, __pos=0):
        r"""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"""
        return _pcbnew.string_copy(self, __s, __n, __pos)

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

    def find(self, *args):
        r"""
        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, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find(self, *args)

    def rfind(self, *args):
        r"""
        rfind(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> 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 >::npos) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_rfind(self, *args)

    def find_first_of(self, *args):
        r"""
        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, 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
        """
        return _pcbnew.string_find_first_of(self, *args)

    def find_last_of(self, *args):
        r"""
        find_last_of(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> 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 >::npos) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_last_of(self, *args)

    def find_first_not_of(self, *args):
        r"""
        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, 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
        """
        return _pcbnew.string_find_first_not_of(self, *args)

    def find_last_not_of(self, *args):
        r"""
        find_last_not_of(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> 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 >::npos) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_last_not_of(self, *args)

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        erase(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n=std::basic_string< char >::npos) -> 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):
        r"""
        __init__(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
        __init__(string self) -> string
        __init__(string self, string other) -> string
        __init__(string self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string
        """
        _pcbnew.string_swiginit(self, _pcbnew.new_string(*args))

    def assign(self, *args):
        r"""
        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):
        r"""
        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):
        r"""iterator(string self) -> SwigPyIterator"""
        return _pcbnew.string_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""
        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):
        r"""
        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):
        r"""__iadd__(string self, string v) -> string"""
        return _pcbnew.string___iadd__(self, v)

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

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

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

    def __rlshift__(self, out):
        r"""__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):
        r"""__eq__(string self, string v) -> bool"""
        return _pcbnew.string___eq__(self, v)

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

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

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

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

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

# Register string in _pcbnew:
_pcbnew.string_swigregister(string)
cvar = _pcbnew.cvar
string.npos = _pcbnew.cvar.string_npos

SHARED_PTR_DISOWN = _pcbnew.SHARED_PTR_DISOWN

class KI_PARAM_ERROR(object):
    r"""Proxy of C++ KI_PARAM_ERROR class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(KI_PARAM_ERROR self, wxString aMessage) -> KI_PARAM_ERROR
        __init__(KI_PARAM_ERROR self) -> KI_PARAM_ERROR
        """
        _pcbnew.KI_PARAM_ERROR_swiginit(self, _pcbnew.new_KI_PARAM_ERROR(*args))

    def What(self):
        r"""What(KI_PARAM_ERROR self) -> wxString"""
        return _pcbnew.KI_PARAM_ERROR_What(self)
    __swig_destroy__ = _pcbnew.delete_KI_PARAM_ERROR

# Register KI_PARAM_ERROR in _pcbnew:
_pcbnew.KI_PARAM_ERROR_swigregister(KI_PARAM_ERROR)

class IO_ERROR(object):
    r"""Proxy of C++ IO_ERROR class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber) -> IO_ERROR
        __init__(IO_ERROR self) -> IO_ERROR
        """
        _pcbnew.IO_ERROR_swiginit(self, _pcbnew.new_IO_ERROR(*args))

    def init(self, aProblem, aThrowersFile, aThrowersFunction, aThrowersLineNumber):
        r"""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):
        r"""Problem(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_Problem(self)

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

    def What(self):
        r"""What(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_What(self)
    __swig_destroy__ = _pcbnew.delete_IO_ERROR

# Register IO_ERROR in _pcbnew:
_pcbnew.IO_ERROR_swigregister(IO_ERROR)

class DHEAD(object):
    r"""Proxy of C++ DHEAD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

# Register DHEAD in _pcbnew:
_pcbnew.DHEAD_swigregister(DHEAD)


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

def wxGetDefaultPyEncoding():
    r"""wxGetDefaultPyEncoding() -> char const *"""
    return _pcbnew.wxGetDefaultPyEncoding()
class wxRect(object):
    r"""Proxy of C++ wxRect class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _pcbnew.wxRect_swiginit(self, _pcbnew.new_wxRect(*args))

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

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

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

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

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

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

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

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

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

    def SetPosition(self, p):
        r"""SetPosition(wxRect self, wxPoint p)"""
        return _pcbnew.wxRect_SetPosition(self, p)
    x = property(_pcbnew.wxRect_x_get, _pcbnew.wxRect_x_set, doc=r"""x : int""")
    y = property(_pcbnew.wxRect_y_get, _pcbnew.wxRect_y_set, doc=r"""y : int""")
    width = property(_pcbnew.wxRect_width_get, _pcbnew.wxRect_width_set, doc=r"""width : int""")
    height = property(_pcbnew.wxRect_height_get, _pcbnew.wxRect_height_set, doc=r"""height : int""")

    def Get(self):
        r"""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

# Register wxRect in _pcbnew:
_pcbnew.wxRect_swigregister(wxRect)

class wxSize(object):
    r"""Proxy of C++ wxSize class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.wxSize_x_get, _pcbnew.wxSize_x_set, doc=r"""x : int""")
    y = property(_pcbnew.wxSize_y_get, _pcbnew.wxSize_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(wxSize self, int xx, int yy) -> wxSize
        __init__(wxSize self, double xx, double yy) -> wxSize
        """
        _pcbnew.wxSize_swiginit(self, _pcbnew.new_wxSize(*args))

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

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

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

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

    def GetHeight(self):
        r"""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



# Register wxSize in _pcbnew:
_pcbnew.wxSize_swigregister(wxSize)

class wxPoint(object):
    r"""Proxy of C++ wxPoint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.wxPoint_x_get, _pcbnew.wxPoint_x_set, doc=r"""x : int""")
    y = property(_pcbnew.wxPoint_y_get, _pcbnew.wxPoint_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(wxPoint self, int xx, int yy) -> wxPoint
        __init__(wxPoint self, double xx, double yy) -> wxPoint
        """
        _pcbnew.wxPoint_swiginit(self, _pcbnew.new_wxPoint(*args))
    __swig_destroy__ = _pcbnew.delete_wxPoint

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

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

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

    def Get(self):
        r"""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)



# Register wxPoint in _pcbnew:
_pcbnew.wxPoint_swigregister(wxPoint)

class wxString(object):
    r"""Proxy of C++ wxString class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _pcbnew.delete_wxString

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

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


    def __init__(self):
        r"""__init__(wxString self) -> wxString"""
        _pcbnew.wxString_swiginit(self, _pcbnew.new_wxString())

# Register wxString in _pcbnew:
_pcbnew.wxString_swigregister(wxString)

class wxPoint_Vector(object):
    r"""Proxy of C++ std::vector< wxPoint > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(wxPoint_Vector self) -> wxPoint_Vector
        __init__(wxPoint_Vector self, wxPoint_Vector other) -> wxPoint_Vector
        __init__(wxPoint_Vector self, std::vector< wxPoint >::size_type size) -> wxPoint_Vector
        __init__(wxPoint_Vector self, std::vector< wxPoint >::size_type size, wxPoint value) -> wxPoint_Vector
        """
        _pcbnew.wxPoint_Vector_swiginit(self, _pcbnew.new_wxPoint_Vector(*args))

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

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

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

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

    def resize(self, *args):
        r"""
        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):
        r"""
        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):
        r"""reserve(wxPoint_Vector self, std::vector< wxPoint >::size_type n)"""
        return _pcbnew.wxPoint_Vector_reserve(self, n)

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

# Register wxPoint_Vector in _pcbnew:
_pcbnew.wxPoint_Vector_swigregister(wxPoint_Vector)


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

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

def GetChars(s):
    r"""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):
    r"""Proxy of C++ EDA_ITEM class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def IsType(self, aScanTypes):
        r"""IsType(EDA_ITEM self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.EDA_ITEM_IsType(self, aScanTypes)

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

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""HitTest(EDA_ITEM self, wxPoint aPosition) -> bool"""
        return _pcbnew.EDA_ITEM_HitTest(self, aPosition)

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

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

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

    def Visit(self, inspector, testData, scanTypes):
        r"""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):
        r"""GetClass(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(EDA_ITEM self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.EDA_ITEM_GetSelectMenuText(self, aUnits)

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

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

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

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

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

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

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

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

# Register EDA_ITEM in _pcbnew:
_pcbnew.EDA_ITEM_swigregister(EDA_ITEM)

def EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes):
    r"""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):
    r"""EDA_ITEM_Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
    return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)


def new_clone(aItem):
    r"""new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
    return _pcbnew.new_clone(aItem)
class EDA_RECT(object):
    r"""Proxy of C++ EDA_RECT class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(EDA_RECT self) -> EDA_RECT
        __init__(EDA_RECT self, wxPoint aPos, wxSize aSize) -> EDA_RECT
        """
        _pcbnew.EDA_RECT_swiginit(self, _pcbnew.new_EDA_RECT(*args))
    __swig_destroy__ = _pcbnew.delete_EDA_RECT

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

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

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

    def Contains(self, *args):
        r"""
        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):
        r"""GetSize(EDA_RECT self) -> wxSize"""
        return _pcbnew.EDA_RECT_GetSize(self)

    def GetSizeMax(self):
        r"""GetSizeMax(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetSizeMax(self)

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

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

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

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

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

    def GetCenter(self):
        r"""GetCenter(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetCenter(self)

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

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

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

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

    def GetTop(self):
        r"""GetTop(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetTop(self)

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

    def IsValid(self):
        r"""IsValid(EDA_RECT self) -> bool"""
        return _pcbnew.EDA_RECT_IsValid(self)

    def SetOrigin(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""SetX(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetX(self, val)

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

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

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

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

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

    def Intersects(self, *args):
        r"""
        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):
        r"""ClosestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
        return _pcbnew.EDA_RECT_ClosestPointTo(self, aPoint)

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

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

    def IntersectsCircleEdge(self, aCenter, aRadius, aWidth):
        r"""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):
        r"""getWxRect(EDA_RECT self) -> wxRect"""
        return _pcbnew.EDA_RECT_getWxRect(self)

    def getBOX2I(self):
        r"""getBOX2I(EDA_RECT self) -> BOX2I"""
        return _pcbnew.EDA_RECT_getBOX2I(self)

    def Inflate(self, *args):
        r"""
        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):
        r"""
        Merge(EDA_RECT self, EDA_RECT aRect)
        Merge(EDA_RECT self, wxPoint aPoint)
        """
        return _pcbnew.EDA_RECT_Merge(self, *args)

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

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

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

# Register EDA_RECT in _pcbnew:
_pcbnew.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):
    r"""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):
    r"""Proxy of C++ LOCALE_IO class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(LOCALE_IO self) -> LOCALE_IO"""
        _pcbnew.LOCALE_IO_swiginit(self, _pcbnew.new_LOCALE_IO())
    __swig_destroy__ = _pcbnew.delete_LOCALE_IO

# Register LOCALE_IO in _pcbnew:
_pcbnew.LOCALE_IO_swigregister(LOCALE_IO)


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

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

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

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

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

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

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

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

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

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

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

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

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aPath, aFilename):
        r"""__init__(WX_FILENAME self, wxString aPath, wxString aFilename) -> WX_FILENAME"""
        _pcbnew.WX_FILENAME_swiginit(self, _pcbnew.new_WX_FILENAME(aPath, aFilename))

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

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

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

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

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

    def GetTimestamp(self):
        r"""GetTimestamp(WX_FILENAME self) -> long long"""
        return _pcbnew.WX_FILENAME_GetTimestamp(self)
    __swig_destroy__ = _pcbnew.delete_WX_FILENAME

# Register WX_FILENAME in _pcbnew:
_pcbnew.WX_FILENAME_swigregister(WX_FILENAME)


def TimestampDir(aDirPath, aFilespec):
    r"""TimestampDir(wxString aDirPath, wxString aFilespec) -> long long"""
    return _pcbnew.TimestampDir(aDirPath, aFilespec)
class TITLE_BLOCK(object):
    r"""Proxy of C++ TITLE_BLOCK class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(TITLE_BLOCK self) -> TITLE_BLOCK"""
        _pcbnew.TITLE_BLOCK_swiginit(self, _pcbnew.new_TITLE_BLOCK())
    __swig_destroy__ = _pcbnew.delete_TITLE_BLOCK

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register TITLE_BLOCK in _pcbnew:
_pcbnew.TITLE_BLOCK_swigregister(TITLE_BLOCK)

class COLOR4D(object):
    r"""Proxy of C++ KIGFX::COLOR4D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(COLOR4D self) -> COLOR4D
        __init__(COLOR4D self, double aRed, double aGreen, double aBlue, double aAlpha) -> COLOR4D
        __init__(COLOR4D self, EDA_COLOR_T aColor) -> COLOR4D
        __init__(COLOR4D self, wxColour const & aColor) -> COLOR4D
        """
        _pcbnew.COLOR4D_swiginit(self, _pcbnew.new_COLOR4D(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def FromHSV(self, aInH, aInS, aInV):
        r"""FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
        return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)
    r = property(_pcbnew.COLOR4D_r_get, _pcbnew.COLOR4D_r_set, doc=r"""r : double""")
    g = property(_pcbnew.COLOR4D_g_get, _pcbnew.COLOR4D_g_set, doc=r"""g : double""")
    b = property(_pcbnew.COLOR4D_b_get, _pcbnew.COLOR4D_b_set, doc=r"""b : double""")
    a = property(_pcbnew.COLOR4D_a_get, _pcbnew.COLOR4D_a_set, doc=r"""a : double""")
    __swig_destroy__ = _pcbnew.delete_COLOR4D

# Register COLOR4D in _pcbnew:
_pcbnew.COLOR4D_swigregister(COLOR4D)

def COLOR4D_GetNearestLegacyColor(aColor):
    r"""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):
    r"""__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
    return _pcbnew.__eq__(lhs, rhs)

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

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SETTINGS self) -> SETTINGS"""
        _pcbnew.SETTINGS_swiginit(self, _pcbnew.new_SETTINGS())
    __swig_destroy__ = _pcbnew.delete_SETTINGS

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

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

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

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

    def Add(self, *args):
        r"""
        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)

# Register SETTINGS in _pcbnew:
_pcbnew.SETTINGS_swigregister(SETTINGS)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_LayersColors = property(_pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get, _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set, doc=r"""m_LayersColors : a(LAYER_ID_COUNT).COLOR4D""")

    def __init__(self, aFrameType):
        r"""__init__(COLORS_DESIGN_SETTINGS self, FRAME_T aFrameType) -> COLORS_DESIGN_SETTINGS"""
        _pcbnew.COLORS_DESIGN_SETTINGS_swiginit(self, _pcbnew.new_COLORS_DESIGN_SETTINGS(aFrameType))
    __swig_destroy__ = _pcbnew.delete_COLORS_DESIGN_SETTINGS

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

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

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

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

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

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

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

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

# Register COLORS_DESIGN_SETTINGS in _pcbnew:
_pcbnew.COLORS_DESIGN_SETTINGS_swigregister(COLORS_DESIGN_SETTINGS)

class MARKER_BASE(object):
    r"""Proxy of C++ MARKER_BASE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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
    
    m_Pos = property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set, doc=r"""m_Pos : wxPoint""")

    def __init__(self, *args):
        r"""
        __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
        """
        _pcbnew.MARKER_BASE_swiginit(self, _pcbnew.new_MARKER_BASE(*args))
    __swig_destroy__ = _pcbnew.delete_MARKER_BASE

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

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

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

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

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

    def DrawMarker(self, aPanel, aDC, aDrawMode, aOffset):
        r"""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):
        r"""GetPos(MARKER_BASE self) -> wxPoint"""
        return _pcbnew.MARKER_BASE_GetPos(self)

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

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

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

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

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

    def SetData(self, *args):
        r"""
        SetData(MARKER_BASE self, EDA_UNITS_T aUnits, int aErrorCode, wxPoint aMarkerPos, EDA_ITEM aItem, wxPoint aPos, EDA_ITEM bItem=None, wxPoint bPos=wxPoint())
        SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText=wxEmptyString, wxPoint bPos=wxPoint())
        """
        return _pcbnew.MARKER_BASE_SetData(self, *args)

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

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

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

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

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

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

# Register MARKER_BASE in _pcbnew:
_pcbnew.MARKER_BASE_swigregister(MARKER_BASE)

class UNIQUE_MUTEX(object):
    r"""Proxy of C++ UNIQUE_MUTEX class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(UNIQUE_MUTEX self) -> UNIQUE_MUTEX
        __init__(UNIQUE_MUTEX self, UNIQUE_MUTEX arg2) -> UNIQUE_MUTEX
        """
        _pcbnew.UNIQUE_MUTEX_swiginit(self, _pcbnew.new_UNIQUE_MUTEX(*args))
    __swig_destroy__ = _pcbnew.delete_UNIQUE_MUTEX

# Register UNIQUE_MUTEX in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ TEXT_EFFECTS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aSetOfBits=0):
        r"""__init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS"""
        _pcbnew.TEXT_EFFECTS_swiginit(self, _pcbnew.new_TEXT_EFFECTS(aSetOfBits))
    bits = property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set, doc=r"""bits : short""")
    hjustify = property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set, doc=r"""hjustify : signed char""")
    vjustify = property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set, doc=r"""vjustify : signed char""")
    size = property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set, doc=r"""size : wxSize""")
    penwidth = property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set, doc=r"""penwidth : int""")
    angle = property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set, doc=r"""angle : double""")
    pos = property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set, doc=r"""pos : wxPoint""")

    def Bit(self, *args):
        r"""
        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

# Register TEXT_EFFECTS in _pcbnew:
_pcbnew.TEXT_EFFECTS_swigregister(TEXT_EFFECTS)

class EDA_TEXT(object):
    r"""Proxy of C++ EDA_TEXT class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(EDA_TEXT self, wxString text=wxEmptyString) -> EDA_TEXT"""
        _pcbnew.EDA_TEXT_swiginit(self, _pcbnew.new_EDA_TEXT(*args))
    __swig_destroy__ = _pcbnew.delete_EDA_TEXT

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

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

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

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

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

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

    def SetTextAngle(self, aAngle):
        r"""SetTextAngle(EDA_TEXT self, double aAngle)"""
        return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)

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

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

    def GetTextAngleRadians(self):
        r"""GetTextAngleRadians(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngleRadians(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def SetEffects(self, aSrc):
        r"""SetEffects(EDA_TEXT self, EDA_TEXT aSrc)"""
        return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def Draw(self, *args):
        r"""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=COLOR4D::UNSPECIFIED)"""
        return _pcbnew.EDA_TEXT_Draw(self, *args)

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

    def TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue):
        r"""TransformBoundingBoxWithClearanceToPolygon(EDA_TEXT self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue)"""
        return _pcbnew.EDA_TEXT_TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue)

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

    def LenSize(self, aLine, aThickness):
        r"""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):
        r"""GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1, bool aInvertY=False) -> EDA_RECT"""
        return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aThickness, aInvertY)

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

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

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

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

# Register EDA_TEXT in _pcbnew:
_pcbnew.EDA_TEXT_swigregister(EDA_TEXT)

class intVector(object):
    r"""Proxy of C++ std::vector< int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __delitem__(intVector self, std::vector< int >::difference_type i)
        __delitem__(intVector self, PySliceObject * slice)
        """
        return _pcbnew.intVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""pop(intVector self) -> std::vector< int >::value_type"""
        return _pcbnew.intVector_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(intVector self) -> intVector
        __init__(intVector self, intVector other) -> intVector
        __init__(intVector self, std::vector< int >::size_type size) -> intVector
        __init__(intVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
        """
        _pcbnew.intVector_swiginit(self, _pcbnew.new_intVector(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(intVector self, std::vector< int >::size_type n)"""
        return _pcbnew.intVector_reserve(self, n)

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

# Register intVector in _pcbnew:
_pcbnew.intVector_swigregister(intVector)

class str_utf8_Map(object):
    r"""Proxy of C++ std::map< std::string,UTF8 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

    def __len__(self):
        r"""__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):
        r"""__getitem__(str_utf8_Map self, string key) -> UTF8"""
        return _pcbnew.str_utf8_Map___getitem__(self, key)

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

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

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

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

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

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

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

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

    def __setitem__(self, *args):
        r"""
        __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):
        r"""asdict(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(str_utf8_Map self, std::less< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > const & other) -> str_utf8_Map
        __init__(str_utf8_Map self) -> str_utf8_Map
        __init__(str_utf8_Map self, str_utf8_Map other) -> str_utf8_Map
        """
        _pcbnew.str_utf8_Map_swiginit(self, _pcbnew.new_str_utf8_Map(*args))

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

    def size(self):
        r"""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):
        r"""swap(str_utf8_Map self, str_utf8_Map v)"""
        return _pcbnew.str_utf8_Map_swap(self, v)

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

    def get_allocator(self):
        r"""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):
        r"""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):
        r"""
        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):
        r"""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):
        r"""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):
        r"""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

# Register str_utf8_Map in _pcbnew:
_pcbnew.str_utf8_Map_swigregister(str_utf8_Map)

class base_seqVect(object):
    r"""Proxy of C++ std::vector< enum PCB_LAYER_ID > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type"""
        return _pcbnew.base_seqVect_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(base_seqVect self) -> base_seqVect
        __init__(base_seqVect self, base_seqVect other) -> base_seqVect
        __init__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type size) -> base_seqVect
        __init__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type size, std::vector< enum PCB_LAYER_ID >::value_type const & value) -> base_seqVect
        """
        _pcbnew.base_seqVect_swiginit(self, _pcbnew.new_base_seqVect(*args))

    def push_back(self, x):
        r"""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):
        r"""front(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
        return _pcbnew.base_seqVect_front(self)

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n)"""
        return _pcbnew.base_seqVect_reserve(self, n)

    def capacity(self):
        r"""capacity(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect_capacity(self)
    __swig_destroy__ = _pcbnew.delete_base_seqVect

# Register base_seqVect in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ SHAPE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

# Register SHAPE in _pcbnew:
_pcbnew.SHAPE_swigregister(SHAPE)


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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.VECTOR2I_x_get, _pcbnew.VECTOR2I_x_set, doc=r"""x : int""")
    y = property(_pcbnew.VECTOR2I_y_get, _pcbnew.VECTOR2I_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(VECTOR2I self) -> VECTOR2I
        __init__(VECTOR2I self, wxPoint aPoint) -> VECTOR2I
        __init__(VECTOR2I self, wxSize aSize) -> VECTOR2I
        __init__(VECTOR2I self, int x, int y) -> VECTOR2I
        """
        _pcbnew.VECTOR2I_swiginit(self, _pcbnew.new_VECTOR2I(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __mul__(self, *args):
        r"""
        __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):
        r"""__eq__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___eq__(self, aVector)

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

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

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

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

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

# Register VECTOR2I in _pcbnew:
_pcbnew.VECTOR2I_swigregister(VECTOR2I)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _pcbnew.SHAPE_LINE_CHAIN_swiginit(self, _pcbnew.new_SHAPE_LINE_CHAIN(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_LINE_CHAIN

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def Replace(self, *args):
        r"""
        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):
        r"""
        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):
        r"""Split(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Split(self, aP)

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

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

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

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

    def Intersect(self, *args):
        r"""
        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):
        r"""PathLength(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PathLength(self, aP)

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

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

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

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

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

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

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

    def NearestPoint(self, *args):
        r"""
        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):
        r"""Format(SHAPE_LINE_CHAIN self) -> string"""
        return _pcbnew.SHAPE_LINE_CHAIN_Format(self)

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

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

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

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

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

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

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

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

# Register SHAPE_LINE_CHAIN in _pcbnew:
_pcbnew.SHAPE_LINE_CHAIN_swigregister(SHAPE_LINE_CHAIN)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SHAPE_POLY_SET self) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_POLY_SET aOther, bool aDeepCopy=False) -> SHAPE_POLY_SET
        """
        _pcbnew.SHAPE_POLY_SET_swiginit(self, _pcbnew.new_SHAPE_POLY_SET(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_POLY_SET

    def GetRelativeIndices(self, aGlobalIdx, aRelativeIndices):
        r"""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):
        r"""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):
        r"""Clone(SHAPE_POLY_SET self) -> SHAPE"""
        return _pcbnew.SHAPE_POLY_SET_Clone(self)

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

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

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

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

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

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

    def Vertex(self, *args):
        r"""
        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):
        r"""
        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):
        r"""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):
        r"""IsPolygonSelfIntersecting(SHAPE_POLY_SET self, int aPolygonIndex) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsPolygonSelfIntersecting(self, aPolygonIndex)

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

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

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

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

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

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

    def Subset(self, aFirstPolygon, aLastPolygon):
        r"""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):
        r"""UnitSet(SHAPE_POLY_SET self, int aPolygonIndex) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_UnitSet(self, aPolygonIndex)

    def Hole(self, aOutline, aHole):
        r"""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):
        r"""
        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):
        r"""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):
        r"""COutline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_COutline(self, aIndex)

    def CHole(self, aOutline, aHole):
        r"""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):
        r"""CPolygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON const &"""
        return _pcbnew.SHAPE_POLY_SET_CPolygon(self, aIndex)

    def Iterate(self, *args):
        r"""
        Iterate(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> 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):
        r"""
        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):
        r"""
        CIterate(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> 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):
        r"""
        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):
        r"""IterateFromVertexWithHoles(SHAPE_POLY_SET self, int aGlobalIdx) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.SHAPE_POLY_SET_IterateFromVertexWithHoles(self, aGlobalIdx)

    def CIterateSegments(self, *args):
        r"""
        CIterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> 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):
        r"""
        IterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> 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):
        r"""
        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):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""
        Inflate(SHAPE_POLY_SET self, int aFactor, int aCircleSegmentsCount, bool aPreseveCorners=False)
        Inflate(SHAPE_POLY_SET self, int aFactor, bool aPreseveCorners)
        """
        return _pcbnew.SHAPE_POLY_SET_Inflate(self, *args)

    def InflateWithLinkedHoles(self, aFactor, aCircleSegmentsCount, aFastMode):
        r"""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):
        r"""Fracture(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Fracture(self, aFastMode)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def RemoveVertex(self, *args):
        r"""
        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):
        r"""RemoveAllContours(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_RemoveAllContours(self)

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

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

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

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

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

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

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

    def Fillet(self, aRadius, aErrorMax):
        r"""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):
        r"""
        DistanceToPolygon(SHAPE_POLY_SET self, VECTOR2I aPoint, int aIndex) -> int
        DistanceToPolygon(SHAPE_POLY_SET self, SEG aSegment, int aIndex, int aSegmentWidth=0) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_DistanceToPolygon(self, *args)

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

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

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

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

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

# Register SHAPE_POLY_SET in _pcbnew:
_pcbnew.SHAPE_POLY_SET_swigregister(SHAPE_POLY_SET)


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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _pcbnew.UTF8_swiginit(self, _pcbnew.new_UTF8(*args))
    __swig_destroy__ = _pcbnew.delete_UTF8

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

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

    def find(self, *args):
        r"""
        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):
        r"""clear(UTF8 self)"""
        return _pcbnew.UTF8_clear(self)

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

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

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

    def __eq__(self, *args):
        r"""
        __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):
        r"""find_first_of(UTF8 self, string str, std::string::size_type pos=0) -> std::string::size_type"""
        return _pcbnew.UTF8_find_first_of(self, str, pos)

    def __iadd__(self, *args):
        r"""
        __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):
        r"""substr(UTF8 self, size_t pos=0, size_t len=npos) -> string"""
        return _pcbnew.UTF8_substr(self, *args)

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

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

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

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

    def end(self):
        r"""end(UTF8 self) -> std::string::const_iterator"""
        return _pcbnew.UTF8_end(self)

    def Cast_to_CChar(self):
        r"""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()



# Register UTF8 in _pcbnew:
_pcbnew.UTF8_swigregister(UTF8)


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

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

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

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ID_SCH = _pcbnew.LIB_ID_ID_SCH
    
    ID_PCB = _pcbnew.LIB_ID_ID_PCB
    

    def __init__(self, *args):
        r"""
        __init__(LIB_ID self) -> LIB_ID
        __init__(LIB_ID self, wxString aLibName, wxString aLibItemName, wxString aRevision=wxEmptyString) -> LIB_ID
        """
        _pcbnew.LIB_ID_swiginit(self, _pcbnew.new_LIB_ID(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @staticmethod
    def FindIllegalLibNicknameChar(aNickname, aType):
        r"""FindIllegalLibNicknameChar(UTF8 aNickname, LIB_ID::LIB_ID_TYPE aType) -> unsigned int"""
        return _pcbnew.LIB_ID_FindIllegalLibNicknameChar(aNickname, aType)
    __swig_destroy__ = _pcbnew.delete_LIB_ID

# Register LIB_ID in _pcbnew:
_pcbnew.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):
    r"""
    LIB_ID_Format() -> UTF8
    LIB_ID_Format(UTF8 aLibNickname, UTF8 aLibItemName, UTF8 aRevision="") -> UTF8
    """
    return _pcbnew.LIB_ID_Format(*args)

def LIB_ID_HasIllegalChars(aLibItemName, aType):
    r"""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):
    r"""LIB_ID_FixIllegalChars(UTF8 aLibItemName, LIB_ID::LIB_ID_TYPE aType, bool aLib=False) -> UTF8"""
    return _pcbnew.LIB_ID_FixIllegalChars(aLibItemName, aType, aLib)

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

class BASE_SET(object):
    r"""Proxy of C++ BASE_SET class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register BASE_SET in _pcbnew:
_pcbnew.BASE_SET_swigregister(BASE_SET)

class IO_MGR(object):
    r"""Proxy of C++ IO_MGR class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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
    

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

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

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

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

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

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

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

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

    def __init__(self):
        r"""__init__(IO_MGR self) -> IO_MGR"""
        _pcbnew.IO_MGR_swiginit(self, _pcbnew.new_IO_MGR())
    __swig_destroy__ = _pcbnew.delete_IO_MGR

# Register IO_MGR in _pcbnew:
_pcbnew.IO_MGR_swigregister(IO_MGR)

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

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

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

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

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

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

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

class PLUGIN(object):
    r"""Proxy of C++ PLUGIN class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def PluginName(self):
        r"""PluginName(PLUGIN self) -> wxString"""
        return _pcbnew.PLUGIN_PluginName(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

    def IsFootprintLibWritable(self, aLibraryPath):
        r"""IsFootprintLibWritable(PLUGIN self, wxString aLibraryPath) -> bool"""
        return _pcbnew.PLUGIN_IsFootprintLibWritable(self, aLibraryPath)

    def FootprintLibOptions(self, aListToAppendTo):
        r"""FootprintLibOptions(PLUGIN self, PROPERTIES * aListToAppendTo)"""
        return _pcbnew.PLUGIN_FootprintLibOptions(self, aListToAppendTo)
    __swig_destroy__ = _pcbnew.delete_PLUGIN

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

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


# Register PLUGIN in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ PCB_IO class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def PluginName(self):
        r"""PluginName(PCB_IO self) -> wxString"""
        return _pcbnew.PCB_IO_PluginName(self)

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

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

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

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

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

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

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

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

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

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

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

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

    def IsFootprintLibWritable(self, aLibraryPath):
        r"""IsFootprintLibWritable(PCB_IO self, wxString aLibraryPath) -> bool"""
        return _pcbnew.PCB_IO_IsFootprintLibWritable(self, aLibraryPath)

    def __init__(self, *args):
        r"""__init__(PCB_IO self, int aControlFlags=((1 << 3))) -> PCB_IO"""
        _pcbnew.PCB_IO_swiginit(self, _pcbnew.new_PCB_IO(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_IO

    def Format(self, aItem, aNestLevel=0):
        r"""Format(PCB_IO self, BOARD_ITEM aItem, int aNestLevel=0)"""
        return _pcbnew.PCB_IO_Format(self, aItem, aNestLevel)

    def GetStringOutput(self, doClear):
        r"""GetStringOutput(PCB_IO self, bool doClear) -> string"""
        return _pcbnew.PCB_IO_GetStringOutput(self, doClear)

    def SetOutputFormatter(self, aFormatter):
        r"""SetOutputFormatter(PCB_IO self, OUTPUTFORMATTER * aFormatter)"""
        return _pcbnew.PCB_IO_SetOutputFormatter(self, aFormatter)

    def Parse(self, aClipboardSourceInput):
        r"""Parse(PCB_IO self, wxString aClipboardSourceInput) -> BOARD_ITEM"""
        return _pcbnew.PCB_IO_Parse(self, aClipboardSourceInput)

# Register PCB_IO in _pcbnew:
_pcbnew.PCB_IO_swigregister(PCB_IO)

class PLOT_CONTROLLER(object):
    r"""Proxy of C++ PLOT_CONTROLLER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aBoard):
        r"""__init__(PLOT_CONTROLLER self, BOARD aBoard) -> PLOT_CONTROLLER"""
        _pcbnew.PLOT_CONTROLLER_swiginit(self, _pcbnew.new_PLOT_CONTROLLER(aBoard))
    __swig_destroy__ = _pcbnew.delete_PLOT_CONTROLLER

    def GetPlotOptions(self):
        r"""GetPlotOptions(PLOT_CONTROLLER self) -> PCB_PLOT_PARAMS"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotOptions(self)

    def SetLayer(self, aLayer):
        r"""SetLayer(PLOT_CONTROLLER self, LAYER_NUM aLayer)"""
        return _pcbnew.PLOT_CONTROLLER_SetLayer(self, aLayer)

    def GetLayer(self):
        r"""GetLayer(PLOT_CONTROLLER self) -> LAYER_NUM"""
        return _pcbnew.PLOT_CONTROLLER_GetLayer(self)

    def IsPlotOpen(self):
        r"""IsPlotOpen(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_IsPlotOpen(self)

    def ClosePlot(self):
        r"""ClosePlot(PLOT_CONTROLLER self)"""
        return _pcbnew.PLOT_CONTROLLER_ClosePlot(self)

    def OpenPlotfile(self, aSuffix, aFormat, aSheetDesc):
        r"""OpenPlotfile(PLOT_CONTROLLER self, wxString aSuffix, PlotFormat aFormat, wxString aSheetDesc) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_OpenPlotfile(self, aSuffix, aFormat, aSheetDesc)

    def PlotLayer(self):
        r"""PlotLayer(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_PlotLayer(self)

    def GetPlotFileName(self):
        r"""GetPlotFileName(PLOT_CONTROLLER self) -> wxString"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotFileName(self)

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

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

    def GetColorMode(self):
        r"""GetColorMode(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_GetColorMode(self)

# Register PLOT_CONTROLLER in _pcbnew:
_pcbnew.PLOT_CONTROLLER_swigregister(PLOT_CONTROLLER)

class PCB_PLOT_PARAMS(object):
    r"""Proxy of C++ PCB_PLOT_PARAMS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        r"""__init__(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS"""
        _pcbnew.PCB_PLOT_PARAMS_swiginit(self, _pcbnew.new_PCB_PLOT_PARAMS())

    def SetSkipPlotNPTH_Pads(self, aSkip):
        r"""SetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self, bool aSkip)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSkipPlotNPTH_Pads(self, aSkip)

    def GetSkipPlotNPTH_Pads(self):
        r"""GetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSkipPlotNPTH_Pads(self)

    def Format(self, aFormatter, aNestLevel, aControl=0):
        r"""Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControl=0)"""
        return _pcbnew.PCB_PLOT_PARAMS_Format(self, aFormatter, aNestLevel, aControl)

    def Parse(self, aParser):
        r"""Parse(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS_PARSER * aParser)"""
        return _pcbnew.PCB_PLOT_PARAMS_Parse(self, aParser)

    def IsSameAs(self, aPcbPlotParams, aCompareOnlySavedPrms):
        r"""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):
        r"""SetColor(PCB_PLOT_PARAMS self, COLOR4D aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetColor(self, aVal)

    def GetColor(self):
        r"""GetColor(PCB_PLOT_PARAMS self) -> COLOR4D"""
        return _pcbnew.PCB_PLOT_PARAMS_GetColor(self)

    def SetTextMode(self, aVal):
        r"""SetTextMode(PCB_PLOT_PARAMS self, PlotTextMode aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetTextMode(self, aVal)

    def GetTextMode(self):
        r"""GetTextMode(PCB_PLOT_PARAMS self) -> PlotTextMode"""
        return _pcbnew.PCB_PLOT_PARAMS_GetTextMode(self)

    def SetPlotMode(self, aPlotMode):
        r"""SetPlotMode(PCB_PLOT_PARAMS self, EDA_DRAW_MODE_T aPlotMode)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotMode(self, aPlotMode)

    def GetPlotMode(self):
        r"""GetPlotMode(PCB_PLOT_PARAMS self) -> EDA_DRAW_MODE_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotMode(self)

    def SetDXFPlotPolygonMode(self, aFlag):
        r"""SetDXFPlotPolygonMode(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDXFPlotPolygonMode(self, aFlag)

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

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

    def GetDXFPlotUnits(self):
        r"""GetDXFPlotUnits(PCB_PLOT_PARAMS self) -> DXF_PLOTTER::DXF_UNITS"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDXFPlotUnits(self)

    def SetDrillMarksType(self, aVal):
        r"""SetDrillMarksType(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS::DrillMarksType aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDrillMarksType(self, aVal)

    def GetDrillMarksType(self):
        r"""GetDrillMarksType(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS::DrillMarksType"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDrillMarksType(self)

    def SetScale(self, aVal):
        r"""SetScale(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScale(self, aVal)

    def GetScale(self):
        r"""GetScale(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScale(self)

    def SetFineScaleAdjustX(self, aVal):
        r"""SetFineScaleAdjustX(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustX(self, aVal)

    def GetFineScaleAdjustX(self):
        r"""GetFineScaleAdjustX(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustX(self)

    def SetFineScaleAdjustY(self, aVal):
        r"""SetFineScaleAdjustY(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustY(self, aVal)

    def GetFineScaleAdjustY(self):
        r"""GetFineScaleAdjustY(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustY(self)

    def SetWidthAdjust(self, aVal):
        r"""SetWidthAdjust(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetWidthAdjust(self, aVal)

    def GetWidthAdjust(self):
        r"""GetWidthAdjust(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetWidthAdjust(self)

    def SetAutoScale(self, aFlag):
        r"""SetAutoScale(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetAutoScale(self, aFlag)

    def GetAutoScale(self):
        r"""GetAutoScale(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetAutoScale(self)

    def SetMirror(self, aFlag):
        r"""SetMirror(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetMirror(self, aFlag)

    def GetMirror(self):
        r"""GetMirror(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetMirror(self)

    def SetPlotPadsOnSilkLayer(self, aFlag):
        r"""SetPlotPadsOnSilkLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotPadsOnSilkLayer(self, aFlag)

    def GetPlotPadsOnSilkLayer(self):
        r"""GetPlotPadsOnSilkLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotPadsOnSilkLayer(self)

    def SetPlotInvisibleText(self, aFlag):
        r"""SetPlotInvisibleText(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotInvisibleText(self, aFlag)

    def GetPlotInvisibleText(self):
        r"""GetPlotInvisibleText(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotInvisibleText(self)

    def SetPlotValue(self, aFlag):
        r"""SetPlotValue(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotValue(self, aFlag)

    def GetPlotValue(self):
        r"""GetPlotValue(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotValue(self)

    def SetPlotReference(self, aFlag):
        r"""SetPlotReference(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotReference(self, aFlag)

    def GetPlotReference(self):
        r"""GetPlotReference(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotReference(self)

    def SetNegative(self, aFlag):
        r"""SetNegative(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetNegative(self, aFlag)

    def GetNegative(self):
        r"""GetNegative(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetNegative(self)

    def SetPlotViaOnMaskLayer(self, aFlag):
        r"""SetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotViaOnMaskLayer(self, aFlag)

    def GetPlotViaOnMaskLayer(self):
        r"""GetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotViaOnMaskLayer(self)

    def SetPlotFrameRef(self, aFlag):
        r"""SetPlotFrameRef(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotFrameRef(self, aFlag)

    def GetPlotFrameRef(self):
        r"""GetPlotFrameRef(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotFrameRef(self)

    def SetExcludeEdgeLayer(self, aFlag):
        r"""SetExcludeEdgeLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetExcludeEdgeLayer(self, aFlag)

    def GetExcludeEdgeLayer(self):
        r"""GetExcludeEdgeLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetExcludeEdgeLayer(self)

    def SetFormat(self, aFormat):
        r"""SetFormat(PCB_PLOT_PARAMS self, PlotFormat aFormat)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFormat(self, aFormat)

    def GetFormat(self):
        r"""GetFormat(PCB_PLOT_PARAMS self) -> PlotFormat"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFormat(self)

    def SetOutputDirectory(self, aDir):
        r"""SetOutputDirectory(PCB_PLOT_PARAMS self, wxString aDir)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetOutputDirectory(self, aDir)

    def GetOutputDirectory(self):
        r"""GetOutputDirectory(PCB_PLOT_PARAMS self) -> wxString"""
        return _pcbnew.PCB_PLOT_PARAMS_GetOutputDirectory(self)

    def SetUseGerberX2format(self, aUse):
        r"""SetUseGerberX2format(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberX2format(self, aUse)

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

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

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

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

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

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

    def GetUseGerberProtelExtensions(self):
        r"""GetUseGerberProtelExtensions(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberProtelExtensions(self)

    def SetGerberPrecision(self, aPrecision):
        r"""SetGerberPrecision(PCB_PLOT_PARAMS self, int aPrecision)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetGerberPrecision(self, aPrecision)

    def GetGerberPrecision(self):
        r"""GetGerberPrecision(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberPrecision(self)

    @staticmethod
    def GetGerberDefaultPrecision():
        r"""GetGerberDefaultPrecision() -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberDefaultPrecision()

    def SetSubtractMaskFromSilk(self, aSubtract):
        r"""SetSubtractMaskFromSilk(PCB_PLOT_PARAMS self, bool aSubtract)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSubtractMaskFromSilk(self, aSubtract)

    def GetSubtractMaskFromSilk(self):
        r"""GetSubtractMaskFromSilk(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSubtractMaskFromSilk(self)

    def SetLayerSelection(self, aSelection):
        r"""SetLayerSelection(PCB_PLOT_PARAMS self, LSET aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetLayerSelection(self, aSelection)

    def GetLayerSelection(self):
        r"""GetLayerSelection(PCB_PLOT_PARAMS self) -> LSET"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLayerSelection(self)

    def SetUseAuxOrigin(self, aAux):
        r"""SetUseAuxOrigin(PCB_PLOT_PARAMS self, bool aAux)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseAuxOrigin(self, aAux)

    def GetUseAuxOrigin(self):
        r"""GetUseAuxOrigin(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseAuxOrigin(self)

    def SetScaleSelection(self, aSelection):
        r"""SetScaleSelection(PCB_PLOT_PARAMS self, int aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScaleSelection(self, aSelection)

    def GetScaleSelection(self):
        r"""GetScaleSelection(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScaleSelection(self)

    def SetA4Output(self, aForce):
        r"""SetA4Output(PCB_PLOT_PARAMS self, int aForce)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetA4Output(self, aForce)

    def GetA4Output(self):
        r"""GetA4Output(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetA4Output(self)

    def GetHPGLPenDiameter(self):
        r"""GetHPGLPenDiameter(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenDiameter(self)

    def SetHPGLPenDiameter(self, aValue):
        r"""SetHPGLPenDiameter(PCB_PLOT_PARAMS self, double aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenDiameter(self, aValue)

    def GetHPGLPenSpeed(self):
        r"""GetHPGLPenSpeed(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenSpeed(self)

    def SetHPGLPenSpeed(self, aValue):
        r"""SetHPGLPenSpeed(PCB_PLOT_PARAMS self, int aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenSpeed(self, aValue)

    def SetHPGLPenNum(self, aVal):
        r"""SetHPGLPenNum(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenNum(self, aVal)

    def GetHPGLPenNum(self):
        r"""GetHPGLPenNum(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenNum(self)

    def GetLineWidth(self):
        r"""GetLineWidth(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLineWidth(self)

    def SetLineWidth(self, aValue):
        r"""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

# Register PCB_PLOT_PARAMS in _pcbnew:
_pcbnew.PCB_PLOT_PARAMS_swigregister(PCB_PLOT_PARAMS)

def PCB_PLOT_PARAMS_GetGerberDefaultPrecision():
    r"""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):
    r"""Proxy of C++ PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    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

    def GetPlotterType(self):
        r"""GetPlotterType(PLOTTER self) -> PlotFormat"""
        return _pcbnew.PLOTTER_GetPlotterType(self)

    def StartPlot(self):
        r"""StartPlot(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_EndPlot(self)

    def SetNegative(self, aNegative):
        r"""SetNegative(PLOTTER self, bool aNegative)"""
        return _pcbnew.PLOTTER_SetNegative(self, aNegative)

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

    def GetColorMode(self):
        r"""GetColorMode(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_GetColorMode(self)

    def SetPageSettings(self, aPageSettings):
        r"""SetPageSettings(PLOTTER self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.PLOTTER_SetPageSettings(self, aPageSettings)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDefaultLineWidth(self, width):
        r"""SetDefaultLineWidth(PLOTTER self, int width)"""
        return _pcbnew.PLOTTER_SetDefaultLineWidth(self, width)

    def GetCurrentLineWidth(self):
        r"""GetCurrentLineWidth(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetCurrentLineWidth(self)

    def SetColor(self, color):
        r"""SetColor(PLOTTER self, COLOR4D color)"""
        return _pcbnew.PLOTTER_SetColor(self, color)

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

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

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

    def AddLineToHeader(self, aExtraString):
        r"""AddLineToHeader(PLOTTER self, wxString aExtraString)"""
        return _pcbnew.PLOTTER_AddLineToHeader(self, aExtraString)

    def ClearHeaderLinesList(self):
        r"""ClearHeaderLinesList(PLOTTER self)"""
        return _pcbnew.PLOTTER_ClearHeaderLinesList(self)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""SetViewport(PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)

    def OpenFile(self, aFullFilename):
        r"""OpenFile(PLOTTER self, wxString aFullFilename) -> bool"""
        return _pcbnew.PLOTTER_OpenFile(self, aFullFilename)

    def GetIUsPerDecimil(self):
        r"""GetIUsPerDecimil(PLOTTER self) -> double"""
        return _pcbnew.PLOTTER_GetIUsPerDecimil(self)

    def Rect(self, *args):
        r"""Rect(PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_Circle(self, *args)

    def Arc(self, *args):
        r"""Arc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_Arc(self, *args)

    def PenTo(self, pos, plume):
        r"""PenTo(PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.PLOTTER_PenTo(self, pos, plume)

    def MoveTo(self, pos):
        r"""MoveTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_MoveTo(self, pos)

    def LineTo(self, pos):
        r"""LineTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_LineTo(self, pos)

    def FinishTo(self, pos):
        r"""FinishTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_FinishTo(self, pos)

    def PenFinish(self):
        r"""PenFinish(PLOTTER self)"""
        return _pcbnew.PLOTTER_PenFinish(self)

    def PlotPoly(self, *args):
        r"""
        PlotPoly(PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)
        PlotPoly(PLOTTER self, SHAPE_LINE_CHAIN aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)
        """
        return _pcbnew.PLOTTER_PlotPoly(self, *args)

    def PlotImage(self, aImage, aPos, aScaleFactor):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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)"""
        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):
        r"""Marker(PLOTTER self, wxPoint position, int diametre, unsigned int aShapeId)"""
        return _pcbnew.PLOTTER_Marker(self, position, diametre, aShapeId)

    def SetLayerPolarity(self, aPositive):
        r"""SetLayerPolarity(PLOTTER self, bool aPositive)"""
        return _pcbnew.PLOTTER_SetLayerPolarity(self, aPositive)

    def SetTextMode(self, mode):
        r"""SetTextMode(PLOTTER self, PlotTextMode mode)"""
        return _pcbnew.PLOTTER_SetTextMode(self, mode)

    def SetGerberCoordinatesFormat(self, aResolution, aUseInches=False):
        r"""SetGerberCoordinatesFormat(PLOTTER self, int aResolution, bool aUseInches=False)"""
        return _pcbnew.PLOTTER_SetGerberCoordinatesFormat(self, aResolution, aUseInches)

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

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

# Register PLOTTER in _pcbnew:
_pcbnew.PLOTTER_swigregister(PLOTTER)

class HPGL_PLOTTER(PLOTTER):
    r"""Proxy of C++ HPGL_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(HPGL_PLOTTER self) -> HPGL_PLOTTER"""
        _pcbnew.HPGL_PLOTTER_swiginit(self, _pcbnew.new_HPGL_PLOTTER())

    def GetPlotterType(self):
        r"""GetPlotterType(HPGL_PLOTTER self) -> PlotFormat"""
        return _pcbnew.HPGL_PLOTTER_GetPlotterType(self)

    @staticmethod
    def GetDefaultFileExtension():
        r"""GetDefaultFileExtension() -> wxString"""
        return _pcbnew.HPGL_PLOTTER_GetDefaultFileExtension()

    def StartPlot(self):
        r"""StartPlot(HPGL_PLOTTER self) -> bool"""
        return _pcbnew.HPGL_PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(HPGL_PLOTTER self) -> bool"""
        return _pcbnew.HPGL_PLOTTER_EndPlot(self)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(HPGL_PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.HPGL_PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDefaultLineWidth(self, width):
        r"""SetDefaultLineWidth(HPGL_PLOTTER self, int width)"""
        return _pcbnew.HPGL_PLOTTER_SetDefaultLineWidth(self, width)

    def SetDash(self, dashed):
        r"""SetDash(HPGL_PLOTTER self, int dashed)"""
        return _pcbnew.HPGL_PLOTTER_SetDash(self, dashed)

    def SetColor(self, color):
        r"""SetColor(HPGL_PLOTTER self, COLOR4D color)"""
        return _pcbnew.HPGL_PLOTTER_SetColor(self, color)

    def SetPenSpeed(self, speed):
        r"""SetPenSpeed(HPGL_PLOTTER self, int speed)"""
        return _pcbnew.HPGL_PLOTTER_SetPenSpeed(self, speed)

    def SetPenNumber(self, number):
        r"""SetPenNumber(HPGL_PLOTTER self, int number)"""
        return _pcbnew.HPGL_PLOTTER_SetPenNumber(self, number)

    def SetPenDiameter(self, diameter):
        r"""SetPenDiameter(HPGL_PLOTTER self, double diameter)"""
        return _pcbnew.HPGL_PLOTTER_SetPenDiameter(self, diameter)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""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):
        r"""Rect(HPGL_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.HPGL_PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(HPGL_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.HPGL_PLOTTER_Circle(self, *args)

    def PlotPoly(self, *args):
        r"""PlotPoly(HPGL_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)"""
        return _pcbnew.HPGL_PLOTTER_PlotPoly(self, *args)

    def ThickSegment(self, start, end, width, tracemode, aData):
        r"""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):
        r"""Arc(HPGL_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.HPGL_PLOTTER_Arc(self, *args)

    def PenTo(self, pos, plume):
        r"""PenTo(HPGL_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.HPGL_PLOTTER_PenTo(self, pos, plume)

    def FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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

# Register HPGL_PLOTTER in _pcbnew:
_pcbnew.HPGL_PLOTTER_swigregister(HPGL_PLOTTER)

def HPGL_PLOTTER_GetDefaultFileExtension():
    r"""HPGL_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.HPGL_PLOTTER_GetDefaultFileExtension()

class PSLIKE_PLOTTER(PLOTTER):
    r"""Proxy of C++ PSLIKE_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def SetTextMode(self, mode):
        r"""SetTextMode(PSLIKE_PLOTTER self, PlotTextMode mode)"""
        return _pcbnew.PSLIKE_PLOTTER_SetTextMode(self, mode)

    def SetDefaultLineWidth(self, width):
        r"""SetDefaultLineWidth(PSLIKE_PLOTTER self, int width)"""
        return _pcbnew.PSLIKE_PLOTTER_SetDefaultLineWidth(self, width)

    def SetScaleAdjust(self, scaleX, scaleY):
        r"""SetScaleAdjust(PSLIKE_PLOTTER self, double scaleX, double scaleY)"""
        return _pcbnew.PSLIKE_PLOTTER_SetScaleAdjust(self, scaleX, scaleY)

    def FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""SetColor(PSLIKE_PLOTTER self, COLOR4D color)"""
        return _pcbnew.PSLIKE_PLOTTER_SetColor(self, color)
    __swig_destroy__ = _pcbnew.delete_PSLIKE_PLOTTER

# Register PSLIKE_PLOTTER in _pcbnew:
_pcbnew.PSLIKE_PLOTTER_swigregister(PSLIKE_PLOTTER)

class PS_PLOTTER(PSLIKE_PLOTTER):
    r"""Proxy of C++ PS_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(PS_PLOTTER self) -> PS_PLOTTER"""
        _pcbnew.PS_PLOTTER_swiginit(self, _pcbnew.new_PS_PLOTTER())

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

    def GetPlotterType(self):
        r"""GetPlotterType(PS_PLOTTER self) -> PlotFormat"""
        return _pcbnew.PS_PLOTTER_GetPlotterType(self)

    def StartPlot(self):
        r"""StartPlot(PS_PLOTTER self) -> bool"""
        return _pcbnew.PS_PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(PS_PLOTTER self) -> bool"""
        return _pcbnew.PS_PLOTTER_EndPlot(self)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(PS_PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.PS_PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDash(self, dashed):
        r"""SetDash(PS_PLOTTER self, int dashed)"""
        return _pcbnew.PS_PLOTTER_SetDash(self, dashed)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""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):
        r"""Rect(PS_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PS_PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(PS_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PS_PLOTTER_Circle(self, *args)

    def Arc(self, *args):
        r"""Arc(PS_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PS_PLOTTER_Arc(self, *args)

    def PlotPoly(self, *args):
        r"""PlotPoly(PS_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)"""
        return _pcbnew.PS_PLOTTER_PlotPoly(self, *args)

    def PlotImage(self, aImage, aPos, aScaleFactor):
        r"""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):
        r"""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):
        r"""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)"""
        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

# Register PS_PLOTTER in _pcbnew:
_pcbnew.PS_PLOTTER_swigregister(PS_PLOTTER)

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

class PDF_PLOTTER(PSLIKE_PLOTTER):
    r"""Proxy of C++ PDF_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(PDF_PLOTTER self) -> PDF_PLOTTER"""
        _pcbnew.PDF_PLOTTER_swiginit(self, _pcbnew.new_PDF_PLOTTER())

    def GetPlotterType(self):
        r"""GetPlotterType(PDF_PLOTTER self) -> PlotFormat"""
        return _pcbnew.PDF_PLOTTER_GetPlotterType(self)

    @staticmethod
    def GetDefaultFileExtension():
        r"""GetDefaultFileExtension() -> wxString"""
        return _pcbnew.PDF_PLOTTER_GetDefaultFileExtension()

    def OpenFile(self, aFullFilename):
        r"""OpenFile(PDF_PLOTTER self, wxString aFullFilename) -> bool"""
        return _pcbnew.PDF_PLOTTER_OpenFile(self, aFullFilename)

    def StartPlot(self):
        r"""StartPlot(PDF_PLOTTER self) -> bool"""
        return _pcbnew.PDF_PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(PDF_PLOTTER self) -> bool"""
        return _pcbnew.PDF_PLOTTER_EndPlot(self)

    def StartPage(self):
        r"""StartPage(PDF_PLOTTER self)"""
        return _pcbnew.PDF_PLOTTER_StartPage(self)

    def ClosePage(self):
        r"""ClosePage(PDF_PLOTTER self)"""
        return _pcbnew.PDF_PLOTTER_ClosePage(self)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(PDF_PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.PDF_PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDash(self, dashed):
        r"""SetDash(PDF_PLOTTER self, int dashed)"""
        return _pcbnew.PDF_PLOTTER_SetDash(self, dashed)

    def SetPageSettings(self, aPageSettings):
        r"""SetPageSettings(PDF_PLOTTER self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.PDF_PLOTTER_SetPageSettings(self, aPageSettings)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""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):
        r"""Rect(PDF_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PDF_PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(PDF_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PDF_PLOTTER_Circle(self, *args)

    def Arc(self, *args):
        r"""Arc(PDF_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PDF_PLOTTER_Arc(self, *args)

    def PlotPoly(self, *args):
        r"""PlotPoly(PDF_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)"""
        return _pcbnew.PDF_PLOTTER_PlotPoly(self, *args)

    def PenTo(self, pos, plume):
        r"""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):
        r"""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)"""
        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):
        r"""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

# Register PDF_PLOTTER in _pcbnew:
_pcbnew.PDF_PLOTTER_swigregister(PDF_PLOTTER)

def PDF_PLOTTER_GetDefaultFileExtension():
    r"""PDF_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.PDF_PLOTTER_GetDefaultFileExtension()

class SVG_PLOTTER(PSLIKE_PLOTTER):
    r"""Proxy of C++ SVG_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SVG_PLOTTER self) -> SVG_PLOTTER"""
        _pcbnew.SVG_PLOTTER_swiginit(self, _pcbnew.new_SVG_PLOTTER())

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

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

    def SetColor(self, color):
        r"""SetColor(SVG_PLOTTER self, COLOR4D color)"""
        return _pcbnew.SVG_PLOTTER_SetColor(self, color)

    def StartPlot(self):
        r"""StartPlot(SVG_PLOTTER self) -> bool"""
        return _pcbnew.SVG_PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(SVG_PLOTTER self) -> bool"""
        return _pcbnew.SVG_PLOTTER_EndPlot(self)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(SVG_PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.SVG_PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDash(self, dashed):
        r"""SetDash(SVG_PLOTTER self, int dashed)"""
        return _pcbnew.SVG_PLOTTER_SetDash(self, dashed)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""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):
        r"""Rect(SVG_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.SVG_PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(SVG_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.SVG_PLOTTER_Circle(self, *args)

    def Arc(self, *args):
        r"""Arc(SVG_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.SVG_PLOTTER_Arc(self, *args)

    def PlotPoly(self, *args):
        r"""PlotPoly(SVG_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)"""
        return _pcbnew.SVG_PLOTTER_PlotPoly(self, *args)

    def PlotImage(self, aImage, aPos, aScaleFactor):
        r"""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):
        r"""PenTo(SVG_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.SVG_PLOTTER_PenTo(self, pos, plume)

    def StartBlock(self, aData):
        r"""StartBlock(SVG_PLOTTER self, void * aData)"""
        return _pcbnew.SVG_PLOTTER_StartBlock(self, aData)

    def EndBlock(self, aData):
        r"""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):
        r"""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)"""
        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

# Register SVG_PLOTTER in _pcbnew:
_pcbnew.SVG_PLOTTER_swigregister(SVG_PLOTTER)

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

FIRST_DCODE_VALUE = _pcbnew.FIRST_DCODE_VALUE

class APERTURE(object):
    r"""Proxy of C++ APERTURE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Circle = _pcbnew.APERTURE_Circle
    
    Rect = _pcbnew.APERTURE_Rect
    
    Plotting = _pcbnew.APERTURE_Plotting
    
    Oval = _pcbnew.APERTURE_Oval
    
    m_Size = property(_pcbnew.APERTURE_m_Size_get, _pcbnew.APERTURE_m_Size_set, doc=r"""m_Size : wxSize""")
    m_Type = property(_pcbnew.APERTURE_m_Type_get, _pcbnew.APERTURE_m_Type_set, doc=r"""m_Type : APERTURE::APERTURE_TYPE""")
    m_DCode = property(_pcbnew.APERTURE_m_DCode_get, _pcbnew.APERTURE_m_DCode_set, doc=r"""m_DCode : int""")
    m_ApertureAttribute = property(_pcbnew.APERTURE_m_ApertureAttribute_get, _pcbnew.APERTURE_m_ApertureAttribute_set, doc=r"""m_ApertureAttribute : int""")

    def __init__(self):
        r"""__init__(APERTURE self) -> APERTURE"""
        _pcbnew.APERTURE_swiginit(self, _pcbnew.new_APERTURE())
    __swig_destroy__ = _pcbnew.delete_APERTURE

# Register APERTURE in _pcbnew:
_pcbnew.APERTURE_swigregister(APERTURE)

class GERBER_PLOTTER(PLOTTER):
    r"""Proxy of C++ GERBER_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(GERBER_PLOTTER self) -> GERBER_PLOTTER"""
        _pcbnew.GERBER_PLOTTER_swiginit(self, _pcbnew.new_GERBER_PLOTTER())

    def GetPlotterType(self):
        r"""GetPlotterType(GERBER_PLOTTER self) -> PlotFormat"""
        return _pcbnew.GERBER_PLOTTER_GetPlotterType(self)

    @staticmethod
    def GetDefaultFileExtension():
        r"""GetDefaultFileExtension() -> wxString"""
        return _pcbnew.GERBER_PLOTTER_GetDefaultFileExtension()

    def StartPlot(self):
        r"""StartPlot(GERBER_PLOTTER self) -> bool"""
        return _pcbnew.GERBER_PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(GERBER_PLOTTER self) -> bool"""
        return _pcbnew.GERBER_PLOTTER_EndPlot(self)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(GERBER_PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.GERBER_PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDefaultLineWidth(self, width):
        r"""SetDefaultLineWidth(GERBER_PLOTTER self, int width)"""
        return _pcbnew.GERBER_PLOTTER_SetDefaultLineWidth(self, width)

    def SetDash(self, dashed):
        r"""SetDash(GERBER_PLOTTER self, int dashed)"""
        return _pcbnew.GERBER_PLOTTER_SetDash(self, dashed)

    def SetColor(self, color):
        r"""SetColor(GERBER_PLOTTER self, COLOR4D color)"""
        return _pcbnew.GERBER_PLOTTER_SetColor(self, color)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""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):
        r"""Rect(GERBER_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.GERBER_PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(GERBER_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.GERBER_PLOTTER_Circle(self, *args)

    def Arc(self, *args):
        r"""Arc(GERBER_PLOTTER self, wxPoint aCenter, double aStAngle, double aEndAngle, int aRadius, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.GERBER_PLOTTER_Arc(self, *args)

    def ThickSegment(self, start, end, width, tracemode, aData):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""PlotPoly(GERBER_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)"""
        return _pcbnew.GERBER_PLOTTER_PlotPoly(self, *args)

    def PenTo(self, pos, plume):
        r"""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):
        r"""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)"""
        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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""PlotGerberRegion(GERBER_PLOTTER self, wxPoint_Vector aCornerList, void * aData=None)"""
        return _pcbnew.GERBER_PLOTTER_PlotGerberRegion(self, aCornerList, aData)

    def SetLayerPolarity(self, aPositive):
        r"""SetLayerPolarity(GERBER_PLOTTER self, bool aPositive)"""
        return _pcbnew.GERBER_PLOTTER_SetLayerPolarity(self, aPositive)

    def SetGerberCoordinatesFormat(self, aResolution, aUseInches=False):
        r"""SetGerberCoordinatesFormat(GERBER_PLOTTER self, int aResolution, bool aUseInches=False)"""
        return _pcbnew.GERBER_PLOTTER_SetGerberCoordinatesFormat(self, aResolution, aUseInches)

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

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

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

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

# Register GERBER_PLOTTER in _pcbnew:
_pcbnew.GERBER_PLOTTER_swigregister(GERBER_PLOTTER)

def GERBER_PLOTTER_GetDefaultFileExtension():
    r"""GERBER_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.GERBER_PLOTTER_GetDefaultFileExtension()

class DXF_PLOTTER(PLOTTER):
    r"""Proxy of C++ DXF_PLOTTER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(DXF_PLOTTER self) -> DXF_PLOTTER"""
        _pcbnew.DXF_PLOTTER_swiginit(self, _pcbnew.new_DXF_PLOTTER())

    def GetPlotterType(self):
        r"""GetPlotterType(DXF_PLOTTER self) -> PlotFormat"""
        return _pcbnew.DXF_PLOTTER_GetPlotterType(self)

    @staticmethod
    def GetDefaultFileExtension():
        r"""GetDefaultFileExtension() -> wxString"""
        return _pcbnew.DXF_PLOTTER_GetDefaultFileExtension()

    def SetTextMode(self, mode):
        r"""SetTextMode(DXF_PLOTTER self, PlotTextMode mode)"""
        return _pcbnew.DXF_PLOTTER_SetTextMode(self, mode)

    def StartPlot(self):
        r"""StartPlot(DXF_PLOTTER self) -> bool"""
        return _pcbnew.DXF_PLOTTER_StartPlot(self)

    def EndPlot(self):
        r"""EndPlot(DXF_PLOTTER self) -> bool"""
        return _pcbnew.DXF_PLOTTER_EndPlot(self)

    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(DXF_PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.DXF_PLOTTER_SetCurrentLineWidth(self, width, aData)

    def SetDefaultLineWidth(self, width):
        r"""SetDefaultLineWidth(DXF_PLOTTER self, int width)"""
        return _pcbnew.DXF_PLOTTER_SetDefaultLineWidth(self, width)

    def SetDash(self, dashed):
        r"""SetDash(DXF_PLOTTER self, int dashed)"""
        return _pcbnew.DXF_PLOTTER_SetDash(self, dashed)

    def SetColor(self, color):
        r"""SetColor(DXF_PLOTTER self, COLOR4D color)"""
        return _pcbnew.DXF_PLOTTER_SetColor(self, color)

    def SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror):
        r"""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):
        r"""Rect(DXF_PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.DXF_PLOTTER_Rect(self, *args)

    def Circle(self, *args):
        r"""Circle(DXF_PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.DXF_PLOTTER_Circle(self, *args)

    def PlotPoly(self, *args):
        r"""PlotPoly(DXF_PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)"""
        return _pcbnew.DXF_PLOTTER_PlotPoly(self, *args)

    def ThickSegment(self, start, end, width, tracemode, aData):
        r"""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):
        r"""Arc(DXF_PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.DXF_PLOTTER_Arc(self, *args)

    def PenTo(self, pos, plume):
        r"""PenTo(DXF_PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.DXF_PLOTTER_PenTo(self, pos, plume)

    def FlashPadCircle(self, pos, diametre, trace_mode, aData):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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)"""
        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):
        r"""SetUnits(DXF_PLOTTER self, DXF_PLOTTER::DXF_UNITS aUnit)"""
        return _pcbnew.DXF_PLOTTER_SetUnits(self, aUnit)

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

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

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

# Register DXF_PLOTTER in _pcbnew:
_pcbnew.DXF_PLOTTER_swigregister(DXF_PLOTTER)

def DXF_PLOTTER_GetDefaultFileExtension():
    r"""DXF_PLOTTER_GetDefaultFileExtension() -> wxString"""
    return _pcbnew.DXF_PLOTTER_GetDefaultFileExtension()


def PlotWorkSheet(*args):
    r"""PlotWorkSheet(PLOTTER plotter, TITLE_BLOCK aTitleBlock, PAGE_INFO const & aPageInfo, int aSheetNumber, int aNumberOfSheets, wxString aSheetDesc, wxString aFilename, COLOR4D aColor=COLOR4D::UNSPECIFIED)"""
    return _pcbnew.PlotWorkSheet(*args)

def GetDefaultPlotExtension(aFormat):
    r"""GetDefaultPlotExtension(PlotFormat aFormat) -> wxString"""
    return _pcbnew.GetDefaultPlotExtension(aFormat)
class DRILL_TOOL(object):
    r"""Proxy of C++ DRILL_TOOL class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Diameter = property(_pcbnew.DRILL_TOOL_m_Diameter_get, _pcbnew.DRILL_TOOL_m_Diameter_set, doc=r"""m_Diameter : int""")
    m_TotalCount = property(_pcbnew.DRILL_TOOL_m_TotalCount_get, _pcbnew.DRILL_TOOL_m_TotalCount_set, doc=r"""m_TotalCount : int""")
    m_OvalCount = property(_pcbnew.DRILL_TOOL_m_OvalCount_get, _pcbnew.DRILL_TOOL_m_OvalCount_set, doc=r"""m_OvalCount : int""")
    m_Hole_NotPlated = property(_pcbnew.DRILL_TOOL_m_Hole_NotPlated_get, _pcbnew.DRILL_TOOL_m_Hole_NotPlated_set, doc=r"""m_Hole_NotPlated : bool""")

    def __init__(self, aDiameter, a_NotPlated):
        r"""__init__(DRILL_TOOL self, int aDiameter, bool a_NotPlated) -> DRILL_TOOL"""
        _pcbnew.DRILL_TOOL_swiginit(self, _pcbnew.new_DRILL_TOOL(aDiameter, a_NotPlated))
    __swig_destroy__ = _pcbnew.delete_DRILL_TOOL

# Register DRILL_TOOL in _pcbnew:
_pcbnew.DRILL_TOOL_swigregister(DRILL_TOOL)

class HOLE_INFO(object):
    r"""Proxy of C++ HOLE_INFO class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_ItemParent = property(_pcbnew.HOLE_INFO_m_ItemParent_get, _pcbnew.HOLE_INFO_m_ItemParent_set, doc=r"""m_ItemParent : p.BOARD_ITEM""")
    m_Hole_Diameter = property(_pcbnew.HOLE_INFO_m_Hole_Diameter_get, _pcbnew.HOLE_INFO_m_Hole_Diameter_set, doc=r"""m_Hole_Diameter : int""")
    m_Tool_Reference = property(_pcbnew.HOLE_INFO_m_Tool_Reference_get, _pcbnew.HOLE_INFO_m_Tool_Reference_set, doc=r"""m_Tool_Reference : int""")
    m_Hole_Size = property(_pcbnew.HOLE_INFO_m_Hole_Size_get, _pcbnew.HOLE_INFO_m_Hole_Size_set, doc=r"""m_Hole_Size : wxSize""")
    m_Hole_Orient = property(_pcbnew.HOLE_INFO_m_Hole_Orient_get, _pcbnew.HOLE_INFO_m_Hole_Orient_set, doc=r"""m_Hole_Orient : double""")
    m_Hole_Shape = property(_pcbnew.HOLE_INFO_m_Hole_Shape_get, _pcbnew.HOLE_INFO_m_Hole_Shape_set, doc=r"""m_Hole_Shape : int""")
    m_Hole_Pos = property(_pcbnew.HOLE_INFO_m_Hole_Pos_get, _pcbnew.HOLE_INFO_m_Hole_Pos_set, doc=r"""m_Hole_Pos : wxPoint""")
    m_Hole_Bottom_Layer = property(_pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_get, _pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_set, doc=r"""m_Hole_Bottom_Layer : PCB_LAYER_ID""")
    m_Hole_Top_Layer = property(_pcbnew.HOLE_INFO_m_Hole_Top_Layer_get, _pcbnew.HOLE_INFO_m_Hole_Top_Layer_set, doc=r"""m_Hole_Top_Layer : PCB_LAYER_ID""")
    m_Hole_NotPlated = property(_pcbnew.HOLE_INFO_m_Hole_NotPlated_get, _pcbnew.HOLE_INFO_m_Hole_NotPlated_set, doc=r"""m_Hole_NotPlated : bool""")

    def __init__(self):
        r"""__init__(HOLE_INFO self) -> HOLE_INFO"""
        _pcbnew.HOLE_INFO_swiginit(self, _pcbnew.new_HOLE_INFO())
    __swig_destroy__ = _pcbnew.delete_HOLE_INFO

# Register HOLE_INFO in _pcbnew:
_pcbnew.HOLE_INFO_swigregister(HOLE_INFO)

class DRILL_PRECISION(object):
    r"""Proxy of C++ DRILL_PRECISION class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_lhs = property(_pcbnew.DRILL_PRECISION_m_lhs_get, _pcbnew.DRILL_PRECISION_m_lhs_set, doc=r"""m_lhs : int""")
    m_rhs = property(_pcbnew.DRILL_PRECISION_m_rhs_get, _pcbnew.DRILL_PRECISION_m_rhs_set, doc=r"""m_rhs : int""")

    def __init__(self, l=2, r=4):
        r"""__init__(DRILL_PRECISION self, int l=2, int r=4) -> DRILL_PRECISION"""
        _pcbnew.DRILL_PRECISION_swiginit(self, _pcbnew.new_DRILL_PRECISION(l, r))

    def GetPrecisionString(self):
        r"""GetPrecisionString(DRILL_PRECISION self) -> wxString"""
        return _pcbnew.DRILL_PRECISION_GetPrecisionString(self)
    __swig_destroy__ = _pcbnew.delete_DRILL_PRECISION

# Register DRILL_PRECISION in _pcbnew:
_pcbnew.DRILL_PRECISION_swigregister(DRILL_PRECISION)

class GENDRILL_WRITER_BASE(object):
    r"""Proxy of C++ GENDRILL_WRITER_BASE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    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

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

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

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

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

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

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

# Register GENDRILL_WRITER_BASE in _pcbnew:
_pcbnew.GENDRILL_WRITER_BASE_swigregister(GENDRILL_WRITER_BASE)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aPcb):
        r"""__init__(EXCELLON_WRITER self, BOARD aPcb) -> EXCELLON_WRITER"""
        _pcbnew.EXCELLON_WRITER_swiginit(self, _pcbnew.new_EXCELLON_WRITER(aPcb))
    __swig_destroy__ = _pcbnew.delete_EXCELLON_WRITER

    def GetOffset(self):
        r"""GetOffset(EXCELLON_WRITER self) -> wxPoint"""
        return _pcbnew.EXCELLON_WRITER_GetOffset(self)

    def SetRouteModeForOvalHoles(self, aUseRouteModeForOvalHoles):
        r"""SetRouteModeForOvalHoles(EXCELLON_WRITER self, bool aUseRouteModeForOvalHoles)"""
        return _pcbnew.EXCELLON_WRITER_SetRouteModeForOvalHoles(self, aUseRouteModeForOvalHoles)

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

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

# Register EXCELLON_WRITER in _pcbnew:
_pcbnew.EXCELLON_WRITER_swigregister(EXCELLON_WRITER)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aPcb):
        r"""__init__(GERBER_WRITER self, BOARD aPcb) -> GERBER_WRITER"""
        _pcbnew.GERBER_WRITER_swiginit(self, _pcbnew.new_GERBER_WRITER(aPcb))
    __swig_destroy__ = _pcbnew.delete_GERBER_WRITER

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

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

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

# Register GERBER_WRITER in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ JOBFILE_PARAMS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_GerberFileList = property(_pcbnew.JOBFILE_PARAMS_m_GerberFileList_get, _pcbnew.JOBFILE_PARAMS_m_GerberFileList_set, doc=r"""m_GerberFileList : wxArrayString""")
    m_LayerId = property(_pcbnew.JOBFILE_PARAMS_m_LayerId_get, _pcbnew.JOBFILE_PARAMS_m_LayerId_set, doc=r"""m_LayerId : std::vector<(PCB_LAYER_ID,std::allocator<(PCB_LAYER_ID)>)>""")

    def __init__(self):
        r"""__init__(JOBFILE_PARAMS self) -> JOBFILE_PARAMS"""
        _pcbnew.JOBFILE_PARAMS_swiginit(self, _pcbnew.new_JOBFILE_PARAMS())
    __swig_destroy__ = _pcbnew.delete_JOBFILE_PARAMS

# Register JOBFILE_PARAMS in _pcbnew:
_pcbnew.JOBFILE_PARAMS_swigregister(JOBFILE_PARAMS)

class GERBER_JOBFILE_WRITER(object):
    r"""Proxy of C++ GERBER_JOBFILE_WRITER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aPcb, aReporter=None):
        r"""__init__(GERBER_JOBFILE_WRITER self, BOARD aPcb, REPORTER * aReporter=None) -> GERBER_JOBFILE_WRITER"""
        _pcbnew.GERBER_JOBFILE_WRITER_swiginit(self, _pcbnew.new_GERBER_JOBFILE_WRITER(aPcb, aReporter))
    __swig_destroy__ = _pcbnew.delete_GERBER_JOBFILE_WRITER

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

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

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

# Register GERBER_JOBFILE_WRITER in _pcbnew:
_pcbnew.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():
    r"""GetBoard() -> BOARD"""
    return _pcbnew.GetBoard()

def LoadBoard(*args):
    r"""
    LoadBoard(wxString aFileName, IO_MGR::PCB_FILE_T aFormat) -> BOARD
    LoadBoard(wxString aFileName) -> BOARD
    """
    return _pcbnew.LoadBoard(*args)

def SaveBoard(aFileName, aBoard):
    r"""SaveBoard(wxString aFileName, BOARD aBoard) -> bool"""
    return _pcbnew.SaveBoard(aFileName, aBoard)

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

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

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

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

def IsActionRunning():
    r"""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):
    r"""Proxy of C++ BOARD_ITEM class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def SetLocked(self, aLocked):
        r"""SetLocked(BOARD_ITEM self, bool aLocked)"""
        return _pcbnew.BOARD_ITEM_SetLocked(self, aLocked)

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

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

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

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

    def Rotate(self, *args):
        r"""
        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):
        r"""
        Flip(BOARD_ITEM self, wxPoint aCentre)
        Flip(BOARD_ITEM self, VECTOR2I aCentre)
        """
        return _pcbnew.BOARD_ITEM_Flip(self, *args)

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

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

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

    def ViewGetLayers(self, aLayers, aCount):
        r"""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):
        r"""TransformShapeWithClearanceToPolygon(BOARD_ITEM self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)"""
        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

# Register BOARD_ITEM in _pcbnew:
_pcbnew.BOARD_ITEM_swigregister(BOARD_ITEM)

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

class BOARD_ITEM_List(DHEAD):
    r"""Proxy of C++ DLIST< BOARD_ITEM > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def Get(self):
        r"""Get(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Get(self)

    def __deref__(self):
        r"""__deref__(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List___deref__(self)

    def GetFirst(self):
        r"""GetFirst(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_GetFirst(self)

    def GetLast(self):
        r"""GetLast(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_GetLast(self)

    def Append(self, *args):
        r"""
        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):
        r"""Insert(BOARD_ITEM_List self, BOARD_ITEM aNewElement, BOARD_ITEM aElementAfterMe)"""
        return _pcbnew.BOARD_ITEM_List_Insert(self, aNewElement, aElementAfterMe)

    def Remove(self, aElement):
        r"""Remove(BOARD_ITEM_List self, BOARD_ITEM aElement) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Remove(self, aElement)

    def begin(self):
        r"""begin(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_begin(self)

    def end(self):
        r"""end(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_end(self)

    def PopFront(self):
        r"""PopFront(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_PopFront(self)

    def PopBack(self):
        r"""PopBack(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_PopBack(self)

    def PushFront(self, aNewElement):
        r"""PushFront(BOARD_ITEM_List self, BOARD_ITEM aNewElement)"""
        return _pcbnew.BOARD_ITEM_List_PushFront(self, aNewElement)

    def PushBack(self, aNewElement):
        r"""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):
        r"""__init__(BOARD_ITEM_List self) -> BOARD_ITEM_List"""
        _pcbnew.BOARD_ITEM_List_swiginit(self, _pcbnew.new_BOARD_ITEM_List())
    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM_List

    def GetPosition(self):
        r"""GetPosition(BOARD_ITEM_List self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_List_GetPosition(self)

    def GetCenter(self):
        r"""GetCenter(BOARD_ITEM_List self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_List_GetCenter(self)

    def SetPosition(self, aPos):
        r"""SetPosition(BOARD_ITEM_List self, wxPoint aPos)"""
        return _pcbnew.BOARD_ITEM_List_SetPosition(self, aPos)

    def IsConnected(self):
        r"""IsConnected(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsConnected(self)

    def Next(self):
        r"""Next(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Next(self)

    def Back(self):
        r"""Back(BOARD_ITEM_List self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Back(self)

    def GetParent(self):
        r"""GetParent(BOARD_ITEM_List self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.BOARD_ITEM_List_GetParent(self)

    def GetLayer(self):
        r"""GetLayer(BOARD_ITEM_List self) -> PCB_LAYER_ID"""
        return _pcbnew.BOARD_ITEM_List_GetLayer(self)

    def GetLayerSet(self):
        r"""GetLayerSet(BOARD_ITEM_List self) -> LSET"""
        return _pcbnew.BOARD_ITEM_List_GetLayerSet(self)

    def SetLayer(self, aLayer):
        r"""SetLayer(BOARD_ITEM_List self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.BOARD_ITEM_List_SetLayer(self, aLayer)

    def Draw(self, *args):
        r"""Draw(BOARD_ITEM_List self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset=)"""
        return _pcbnew.BOARD_ITEM_List_Draw(self, *args)

    def SwapData(self, aImage):
        r"""SwapData(BOARD_ITEM_List self, BOARD_ITEM aImage)"""
        return _pcbnew.BOARD_ITEM_List_SwapData(self, aImage)

    def IsOnLayer(self, aLayer):
        r"""IsOnLayer(BOARD_ITEM_List self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsOnLayer(self, aLayer)

    def IsTrack(self):
        r"""IsTrack(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsTrack(self)

    def IsLocked(self):
        r"""IsLocked(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsLocked(self)

    def SetLocked(self, aLocked):
        r"""SetLocked(BOARD_ITEM_List self, bool aLocked)"""
        return _pcbnew.BOARD_ITEM_List_SetLocked(self, aLocked)

    def UnLink(self):
        r"""UnLink(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_UnLink(self)

    def DeleteStructure(self):
        r"""DeleteStructure(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_DeleteStructure(self)

    def ShowShape(self, aShape):
        r"""ShowShape(BOARD_ITEM_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_ShowShape(self, aShape)

    def Move(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""GetBoard(BOARD_ITEM_List self) -> BOARD"""
        return _pcbnew.BOARD_ITEM_List_GetBoard(self)

    def GetLayerName(self):
        r"""GetLayerName(BOARD_ITEM_List self) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetLayerName(self)

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

    def ViewGetLayers(self, aLayers, aCount):
        r"""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):
        r"""TransformShapeWithClearanceToPolygon(BOARD_ITEM_List self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)"""
        return _pcbnew.BOARD_ITEM_List_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)

    def Type(self):
        r"""Type(BOARD_ITEM_List self) -> KICAD_T"""
        return _pcbnew.BOARD_ITEM_List_Type(self)

    def SetTimeStamp(self, aNewTimeStamp):
        r"""SetTimeStamp(BOARD_ITEM_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.BOARD_ITEM_List_SetTimeStamp(self, aNewTimeStamp)

    def GetTimeStamp(self):
        r"""GetTimeStamp(BOARD_ITEM_List self) -> timestamp_t"""
        return _pcbnew.BOARD_ITEM_List_GetTimeStamp(self)

    def GetList(self):
        r"""GetList(BOARD_ITEM_List self) -> DHEAD"""
        return _pcbnew.BOARD_ITEM_List_GetList(self)

    def SetParent(self, aParent):
        r"""SetParent(BOARD_ITEM_List self, EDA_ITEM aParent)"""
        return _pcbnew.BOARD_ITEM_List_SetParent(self, aParent)

    def SetList(self, aList):
        r"""SetList(BOARD_ITEM_List self, DHEAD aList)"""
        return _pcbnew.BOARD_ITEM_List_SetList(self, aList)

    def IsNew(self):
        r"""IsNew(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsNew(self)

    def IsModified(self):
        r"""IsModified(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsModified(self)

    def IsMoving(self):
        r"""IsMoving(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsMoving(self)

    def IsDragging(self):
        r"""IsDragging(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsDragging(self)

    def IsWireImage(self):
        r"""IsWireImage(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsWireImage(self)

    def IsSelected(self):
        r"""IsSelected(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsSelected(self)

    def IsResized(self):
        r"""IsResized(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsResized(self)

    def IsHighlighted(self):
        r"""IsHighlighted(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsHighlighted(self)

    def IsBrightened(self):
        r"""IsBrightened(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsBrightened(self)

    def SetWireImage(self):
        r"""SetWireImage(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetWireImage(self)

    def SetSelected(self):
        r"""SetSelected(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetSelected(self)

    def SetHighlighted(self):
        r"""SetHighlighted(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetHighlighted(self)

    def SetBrightened(self):
        r"""SetBrightened(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetBrightened(self)

    def ClearSelected(self):
        r"""ClearSelected(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_ClearSelected(self)

    def ClearHighlighted(self):
        r"""ClearHighlighted(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_ClearHighlighted(self)

    def ClearBrightened(self):
        r"""ClearBrightened(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_ClearBrightened(self)

    def SetModified(self):
        r"""SetModified(BOARD_ITEM_List self)"""
        return _pcbnew.BOARD_ITEM_List_SetModified(self)

    def GetState(self, type):
        r"""GetState(BOARD_ITEM_List self, int type) -> int"""
        return _pcbnew.BOARD_ITEM_List_GetState(self, type)

    def SetState(self, type, state):
        r"""SetState(BOARD_ITEM_List self, int type, int state)"""
        return _pcbnew.BOARD_ITEM_List_SetState(self, type, state)

    def GetStatus(self):
        r"""GetStatus(BOARD_ITEM_List self) -> STATUS_FLAGS"""
        return _pcbnew.BOARD_ITEM_List_GetStatus(self)

    def SetStatus(self, aStatus):
        r"""SetStatus(BOARD_ITEM_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.BOARD_ITEM_List_SetStatus(self, aStatus)

    def SetFlags(self, aMask):
        r"""SetFlags(BOARD_ITEM_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.BOARD_ITEM_List_SetFlags(self, aMask)

    def ClearFlags(self, aMask=-1):
        r"""ClearFlags(BOARD_ITEM_List self, STATUS_FLAGS aMask=-1)"""
        return _pcbnew.BOARD_ITEM_List_ClearFlags(self, aMask)

    def GetFlags(self):
        r"""GetFlags(BOARD_ITEM_List self) -> STATUS_FLAGS"""
        return _pcbnew.BOARD_ITEM_List_GetFlags(self)

    def IsType(self, aScanTypes):
        r"""IsType(BOARD_ITEM_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsType(self, aScanTypes)

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

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""GetBoundingBox(BOARD_ITEM_List self) -> EDA_RECT"""
        return _pcbnew.BOARD_ITEM_List_GetBoundingBox(self)

    def Clone(self):
        r"""Clone(BOARD_ITEM_List self) -> EDA_ITEM"""
        return _pcbnew.BOARD_ITEM_List_Clone(self)

    def IterateForward(self, listStart, inspector, testData, scanTypes):
        r"""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):
        r"""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):
        r"""GetClass(BOARD_ITEM_List self) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(BOARD_ITEM_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.BOARD_ITEM_List_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(BOARD_ITEM_List self) -> BITMAP_DEF"""
        return _pcbnew.BOARD_ITEM_List_GetMenuImage(self)

    def Matches(self, aSearchData, aAuxData, aFindLocation):
        r"""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):
        r"""
        Replace(BOARD_ITEM_List self, wxFindReplaceData & aSearchData, wxString aText) -> bool
        Replace(BOARD_ITEM_List self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        """
        return _pcbnew.BOARD_ITEM_List_Replace(self, *args)

    def IsReplaceable(self):
        r"""IsReplaceable(BOARD_ITEM_List self) -> bool"""
        return _pcbnew.BOARD_ITEM_List_IsReplaceable(self)

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

    def Sort(self, aLeft, aRight):
        r"""Sort(BOARD_ITEM_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.BOARD_ITEM_List_Sort(self, aLeft, aRight)

    def ViewBBox(self):
        r"""ViewBBox(BOARD_ITEM_List self) -> BOX2I const"""
        return _pcbnew.BOARD_ITEM_List_ViewBBox(self)

# Register BOARD_ITEM_List in _pcbnew:
_pcbnew.BOARD_ITEM_List_swigregister(BOARD_ITEM_List)


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

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

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

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

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

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

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

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

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

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

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

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

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

def Cast_to_PCB_TARGET(arg1):
    r"""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):
    r"""Proxy of C++ BOARD_ITEM_CONTAINER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

    def DeleteNative(self, aItem):
        r"""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


# Register BOARD_ITEM_CONTAINER in _pcbnew:
_pcbnew.BOARD_ITEM_CONTAINER_swigregister(BOARD_ITEM_CONTAINER)

class BOARD_CONNECTED_ITEM(BOARD_ITEM):
    r"""Proxy of C++ BOARD_CONNECTED_ITEM class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

    def SetNet(self, aNetInfo):
        r"""SetNet(BOARD_CONNECTED_ITEM self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetNet(self, aNetInfo)

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

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

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

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

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

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

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

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

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

    def GetLocalRatsnestVisible(self):
        r"""GetLocalRatsnestVisible(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetLocalRatsnestVisible(self)
    __swig_destroy__ = _pcbnew.delete_BOARD_CONNECTED_ITEM

# Register BOARD_CONNECTED_ITEM in _pcbnew:
_pcbnew.BOARD_CONNECTED_ITEM_swigregister(BOARD_CONNECTED_ITEM)

def BOARD_CONNECTED_ITEM_ClassOf(aItem):
    r"""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):
    r"""Proxy of C++ VIA_DIMENSION class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Diameter = property(_pcbnew.VIA_DIMENSION_m_Diameter_get, _pcbnew.VIA_DIMENSION_m_Diameter_set, doc=r"""m_Diameter : int""")
    m_Drill = property(_pcbnew.VIA_DIMENSION_m_Drill_get, _pcbnew.VIA_DIMENSION_m_Drill_set, doc=r"""m_Drill : int""")

    def __init__(self, *args):
        r"""
        __init__(VIA_DIMENSION self) -> VIA_DIMENSION
        __init__(VIA_DIMENSION self, int aDiameter, int aDrill) -> VIA_DIMENSION
        """
        _pcbnew.VIA_DIMENSION_swiginit(self, _pcbnew.new_VIA_DIMENSION(*args))

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

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

# Register VIA_DIMENSION in _pcbnew:
_pcbnew.VIA_DIMENSION_swigregister(VIA_DIMENSION)

class DIFF_PAIR_DIMENSION(object):
    r"""Proxy of C++ DIFF_PAIR_DIMENSION class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Width = property(_pcbnew.DIFF_PAIR_DIMENSION_m_Width_get, _pcbnew.DIFF_PAIR_DIMENSION_m_Width_set, doc=r"""m_Width : int""")
    m_Gap = property(_pcbnew.DIFF_PAIR_DIMENSION_m_Gap_get, _pcbnew.DIFF_PAIR_DIMENSION_m_Gap_set, doc=r"""m_Gap : int""")
    m_ViaGap = property(_pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_get, _pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_set, doc=r"""m_ViaGap : int""")

    def __init__(self, *args):
        r"""
        __init__(DIFF_PAIR_DIMENSION self) -> DIFF_PAIR_DIMENSION
        __init__(DIFF_PAIR_DIMENSION self, int aWidth, int aGap, int aViaGap) -> DIFF_PAIR_DIMENSION
        """
        _pcbnew.DIFF_PAIR_DIMENSION_swiginit(self, _pcbnew.new_DIFF_PAIR_DIMENSION(*args))

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

    def __lt__(self, aOther):
        r"""__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

# Register DIFF_PAIR_DIMENSION in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ BOARD_DESIGN_SETTINGS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_TrackWidthList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_set, doc=r"""m_TrackWidthList : std::vector<(int,std::allocator<(int)>)>""")
    m_ViasDimensionsList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_set, doc=r"""m_ViasDimensionsList : std::vector<(VIA_DIMENSION,std::allocator<(VIA_DIMENSION)>)>""")
    m_DiffPairDimensionsList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_set, doc=r"""m_DiffPairDimensionsList : std::vector<(DIFF_PAIR_DIMENSION,std::allocator<(DIFF_PAIR_DIMENSION)>)>""")
    m_NetClasses = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_NetClasses_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_NetClasses_set, doc=r"""m_NetClasses : NETCLASSES""")
    m_MicroViasAllowed = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_set, doc=r"""m_MicroViasAllowed : bool""")
    m_BlindBuriedViaAllowed = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_set, doc=r"""m_BlindBuriedViaAllowed : bool""")
    m_CurrentViaType = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_set, doc=r"""m_CurrentViaType : VIATYPE_T""")
    m_RequireCourtyards = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RequireCourtyards_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RequireCourtyards_set, doc=r"""m_RequireCourtyards : bool""")
    m_ProhibitOverlappingCourtyards = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ProhibitOverlappingCourtyards_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ProhibitOverlappingCourtyards_set, doc=r"""m_ProhibitOverlappingCourtyards : bool""")
    m_UseConnectedTrackWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_set, doc=r"""m_UseConnectedTrackWidth : bool""")
    m_TrackMinWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_set, doc=r"""m_TrackMinWidth : int""")
    m_ViasMinSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_set, doc=r"""m_ViasMinSize : int""")
    m_ViasMinDrill = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinDrill_set, doc=r"""m_ViasMinDrill : int""")
    m_MicroViasMinSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_set, doc=r"""m_MicroViasMinSize : int""")
    m_MicroViasMinDrill = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_set, doc=r"""m_MicroViasMinDrill : int""")
    m_SolderMaskMargin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_set, doc=r"""m_SolderMaskMargin : int""")
    m_SolderMaskMinWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_set, doc=r"""m_SolderMaskMinWidth : int""")
    m_SolderPasteMargin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_set, doc=r"""m_SolderPasteMargin : int""")
    m_SolderPasteMarginRatio = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_set, doc=r"""m_SolderPasteMarginRatio : double""")
    m_HoleToHoleMin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_set, doc=r"""m_HoleToHoleMin : int""")
    m_LineThickness = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_set, doc=r"""m_LineThickness : a(LAYER_CLASS_COUNT).int""")
    m_TextSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_set, doc=r"""m_TextSize : a(LAYER_CLASS_COUNT).wxSize""")
    m_TextThickness = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_set, doc=r"""m_TextThickness : a(LAYER_CLASS_COUNT).int""")
    m_TextItalic = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_set, doc=r"""m_TextItalic : a(LAYER_CLASS_COUNT).bool""")
    m_TextUpright = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_set, doc=r"""m_TextUpright : a(LAYER_CLASS_COUNT).bool""")
    m_RefDefaultText = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultText_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultText_set, doc=r"""m_RefDefaultText : wxString""")
    m_RefDefaultVisibility = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultVisibility_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultVisibility_set, doc=r"""m_RefDefaultVisibility : bool""")
    m_RefDefaultlayer = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultlayer_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_RefDefaultlayer_set, doc=r"""m_RefDefaultlayer : int""")
    m_ValueDefaultText = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultText_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultText_set, doc=r"""m_ValueDefaultText : wxString""")
    m_ValueDefaultVisibility = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultVisibility_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultVisibility_set, doc=r"""m_ValueDefaultVisibility : bool""")
    m_ValueDefaultlayer = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultlayer_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ValueDefaultlayer_set, doc=r"""m_ValueDefaultlayer : int""")
    m_AuxOrigin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_AuxOrigin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_AuxOrigin_set, doc=r"""m_AuxOrigin : wxPoint""")
    m_GridOrigin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_GridOrigin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_GridOrigin_set, doc=r"""m_GridOrigin : wxPoint""")
    m_Pad_Master = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_Pad_Master_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_Pad_Master_set, doc=r"""m_Pad_Master : D_PAD""")

    def __init__(self):
        r"""__init__(BOARD_DESIGN_SETTINGS self) -> BOARD_DESIGN_SETTINGS"""
        _pcbnew.BOARD_DESIGN_SETTINGS_swiginit(self, _pcbnew.new_BOARD_DESIGN_SETTINGS())

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

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

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

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

    def UseNetClassDiffPair(self):
        r"""UseNetClassDiffPair(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassDiffPair(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def GetDiffPairIndex(self):
        r"""GetDiffPairIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDiffPairIndex(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def GetLayerClass(self, aLayer):
        r"""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

# Register BOARD_DESIGN_SETTINGS in _pcbnew:
_pcbnew.BOARD_DESIGN_SETTINGS_swigregister(BOARD_DESIGN_SETTINGS)

class CN_DISJOINT_NET_ENTRY(object):
    r"""Proxy of C++ CN_DISJOINT_NET_ENTRY class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    net = property(_pcbnew.CN_DISJOINT_NET_ENTRY_net_get, _pcbnew.CN_DISJOINT_NET_ENTRY_net_set, doc=r"""net : int""")
    a = property(_pcbnew.CN_DISJOINT_NET_ENTRY_a_get, _pcbnew.CN_DISJOINT_NET_ENTRY_a_set, doc=r"""a : p.BOARD_CONNECTED_ITEM""")
    b = property(_pcbnew.CN_DISJOINT_NET_ENTRY_b_get, _pcbnew.CN_DISJOINT_NET_ENTRY_b_set, doc=r"""b : p.BOARD_CONNECTED_ITEM""")
    anchorA = property(_pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_get, _pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_set, doc=r"""anchorA : VECTOR2I""")
    anchorB = property(_pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_get, _pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_set, doc=r"""anchorB : VECTOR2I""")

    def __init__(self):
        r"""__init__(CN_DISJOINT_NET_ENTRY self) -> CN_DISJOINT_NET_ENTRY"""
        _pcbnew.CN_DISJOINT_NET_ENTRY_swiginit(self, _pcbnew.new_CN_DISJOINT_NET_ENTRY())
    __swig_destroy__ = _pcbnew.delete_CN_DISJOINT_NET_ENTRY

# Register CN_DISJOINT_NET_ENTRY in _pcbnew:
_pcbnew.CN_DISJOINT_NET_ENTRY_swigregister(CN_DISJOINT_NET_ENTRY)

class CN_ZONE_ISOLATED_ISLAND_LIST(object):
    r"""Proxy of C++ CN_ZONE_ISOLATED_ISLAND_LIST class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aZone):
        r"""__init__(CN_ZONE_ISOLATED_ISLAND_LIST self, ZONE_CONTAINER aZone) -> CN_ZONE_ISOLATED_ISLAND_LIST"""
        _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_swiginit(self, _pcbnew.new_CN_ZONE_ISOLATED_ISLAND_LIST(aZone))
    m_zone = property(_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_get, _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_set, doc=r"""m_zone : p.ZONE_CONTAINER""")
    m_islands = property(_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_get, _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_set, doc=r"""m_islands : std::vector<(int,std::allocator<(int)>)>""")
    __swig_destroy__ = _pcbnew.delete_CN_ZONE_ISOLATED_ISLAND_LIST

# Register CN_ZONE_ISOLATED_ISLAND_LIST in _pcbnew:
_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_swigregister(CN_ZONE_ISOLATED_ISLAND_LIST)

class RN_DYNAMIC_LINE(object):
    r"""Proxy of C++ RN_DYNAMIC_LINE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    netCode = property(_pcbnew.RN_DYNAMIC_LINE_netCode_get, _pcbnew.RN_DYNAMIC_LINE_netCode_set, doc=r"""netCode : int""")
    a = property(_pcbnew.RN_DYNAMIC_LINE_a_get, _pcbnew.RN_DYNAMIC_LINE_a_set, doc=r"""a : VECTOR2I""")
    b = property(_pcbnew.RN_DYNAMIC_LINE_b_get, _pcbnew.RN_DYNAMIC_LINE_b_set, doc=r"""b : VECTOR2I""")

    def __init__(self):
        r"""__init__(RN_DYNAMIC_LINE self) -> RN_DYNAMIC_LINE"""
        _pcbnew.RN_DYNAMIC_LINE_swiginit(self, _pcbnew.new_RN_DYNAMIC_LINE())
    __swig_destroy__ = _pcbnew.delete_RN_DYNAMIC_LINE

# Register RN_DYNAMIC_LINE in _pcbnew:
_pcbnew.RN_DYNAMIC_LINE_swigregister(RN_DYNAMIC_LINE)

class CONNECTIVITY_DATA(object):
    r"""Proxy of C++ CONNECTIVITY_DATA class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _pcbnew.delete_CONNECTIVITY_DATA

    def __init__(self, *args):
        r"""
        __init__(CONNECTIVITY_DATA self) -> CONNECTIVITY_DATA
        __init__(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems) -> CONNECTIVITY_DATA
        """
        _pcbnew.CONNECTIVITY_DATA_swiginit(self, _pcbnew.new_CONNECTIVITY_DATA(*args))

    def Build(self, *args):
        r"""
        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):
        r"""Add(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Add(self, aItem)

    def Remove(self, aItem):
        r"""Remove(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Remove(self, aItem)

    def Update(self, aItem):
        r"""Update(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Update(self, aItem)

    def Clear(self):
        r"""Clear(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_Clear(self)

    def GetNetCount(self):
        r"""GetNetCount(CONNECTIVITY_DATA self) -> int"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetCount(self)

    def GetRatsnestForNet(self, aNet):
        r"""GetRatsnestForNet(CONNECTIVITY_DATA self, int aNet) -> RN_NET *"""
        return _pcbnew.CONNECTIVITY_DATA_GetRatsnestForNet(self, aNet)

    def PropagateNets(self):
        r"""PropagateNets(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_PropagateNets(self)

    def CheckConnectivity(self, aReport):
        r"""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):
        r"""
        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):
        r"""RecalculateRatsnest(CONNECTIVITY_DATA self, BOARD_COMMIT * aCommit=None)"""
        return _pcbnew.CONNECTIVITY_DATA_RecalculateRatsnest(self, aCommit)

    def GetUnconnectedCount(self):
        r"""GetUnconnectedCount(CONNECTIVITY_DATA self) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedCount(self)

    def GetNodeCount(self, aNet=-1):
        r"""GetNodeCount(CONNECTIVITY_DATA self, int aNet=-1) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetNodeCount(self, aNet)

    def GetPadCount(self, aNet=-1):
        r"""GetPadCount(CONNECTIVITY_DATA self, int aNet=-1) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetPadCount(self, aNet)

    def GetConnectedTracks(self, aItem):
        r"""GetConnectedTracks(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem) -> TRACKS"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedTracks(self, aItem)

    def GetConnectedPads(self, *args):
        r"""
        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):
        r"""GetUnconnectedEdges(CONNECTIVITY_DATA self, std::vector< CN_EDGE,std::allocator< CN_EDGE > > & aEdges)"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedEdges(self, aEdges)

    def ClearDynamicRatsnest(self):
        r"""ClearDynamicRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_ClearDynamicRatsnest(self)

    def HideDynamicRatsnest(self):
        r"""HideDynamicRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_HideDynamicRatsnest(self)

    def ComputeDynamicRatsnest(self, aItems):
        r"""ComputeDynamicRatsnest(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)"""
        return _pcbnew.CONNECTIVITY_DATA_ComputeDynamicRatsnest(self, aItems)

    def GetDynamicRatsnest(self):
        r"""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):
        r"""
        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
        """
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedItems(self, *args)

    def GetNetItems(self, aNetCode, aTypes):
        r"""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):
        r"""NearestUnconnectedTargets(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aRef, VECTOR2I aPos, int aMaxCount=-1) -> std::vector< VECTOR2I,std::allocator< VECTOR2I > > const"""
        return _pcbnew.CONNECTIVITY_DATA_NearestUnconnectedTargets(self, aRef, aPos, aMaxCount)

    def BlockRatsnestItems(self, aItems):
        r"""BlockRatsnestItems(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)"""
        return _pcbnew.CONNECTIVITY_DATA_BlockRatsnestItems(self, aItems)

    def GetConnectivityAlgo(self):
        r"""GetConnectivityAlgo(CONNECTIVITY_DATA self) -> std::shared_ptr< CN_CONNECTIVITY_ALGO >"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectivityAlgo(self)

    def GetLock(self):
        r"""GetLock(CONNECTIVITY_DATA self) -> std::mutex &"""
        return _pcbnew.CONNECTIVITY_DATA_GetLock(self)

    def MarkItemNetAsDirty(self, aItem):
        r"""MarkItemNetAsDirty(CONNECTIVITY_DATA self, BOARD_ITEM aItem)"""
        return _pcbnew.CONNECTIVITY_DATA_MarkItemNetAsDirty(self, aItem)

    def SetProgressReporter(self, aReporter):
        r"""SetProgressReporter(CONNECTIVITY_DATA self, PROGRESS_REPORTER * aReporter)"""
        return _pcbnew.CONNECTIVITY_DATA_SetProgressReporter(self, aReporter)

# Register CONNECTIVITY_DATA in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ PAD_DRAWINFO class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_DrawPanel = property(_pcbnew.PAD_DRAWINFO_m_DrawPanel_get, _pcbnew.PAD_DRAWINFO_m_DrawPanel_set, doc=r"""m_DrawPanel : p.EDA_DRAW_PANEL""")
    m_DrawMode = property(_pcbnew.PAD_DRAWINFO_m_DrawMode_get, _pcbnew.PAD_DRAWINFO_m_DrawMode_set, doc=r"""m_DrawMode : GR_DRAWMODE""")
    m_Color = property(_pcbnew.PAD_DRAWINFO_m_Color_get, _pcbnew.PAD_DRAWINFO_m_Color_set, doc=r"""m_Color : COLOR4D""")
    m_HoleColor = property(_pcbnew.PAD_DRAWINFO_m_HoleColor_get, _pcbnew.PAD_DRAWINFO_m_HoleColor_set, doc=r"""m_HoleColor : COLOR4D""")
    m_NPHoleColor = property(_pcbnew.PAD_DRAWINFO_m_NPHoleColor_get, _pcbnew.PAD_DRAWINFO_m_NPHoleColor_set, doc=r"""m_NPHoleColor : COLOR4D""")
    m_NoNetMarkColor = property(_pcbnew.PAD_DRAWINFO_m_NoNetMarkColor_get, _pcbnew.PAD_DRAWINFO_m_NoNetMarkColor_set, doc=r"""m_NoNetMarkColor : COLOR4D""")
    m_PadClearance = property(_pcbnew.PAD_DRAWINFO_m_PadClearance_get, _pcbnew.PAD_DRAWINFO_m_PadClearance_set, doc=r"""m_PadClearance : int""")
    m_Mask_margin = property(_pcbnew.PAD_DRAWINFO_m_Mask_margin_get, _pcbnew.PAD_DRAWINFO_m_Mask_margin_set, doc=r"""m_Mask_margin : wxSize""")
    m_Display_padnum = property(_pcbnew.PAD_DRAWINFO_m_Display_padnum_get, _pcbnew.PAD_DRAWINFO_m_Display_padnum_set, doc=r"""m_Display_padnum : bool""")
    m_Display_netname = property(_pcbnew.PAD_DRAWINFO_m_Display_netname_get, _pcbnew.PAD_DRAWINFO_m_Display_netname_set, doc=r"""m_Display_netname : bool""")
    m_ShowPadFilled = property(_pcbnew.PAD_DRAWINFO_m_ShowPadFilled_get, _pcbnew.PAD_DRAWINFO_m_ShowPadFilled_set, doc=r"""m_ShowPadFilled : bool""")
    m_ShowNCMark = property(_pcbnew.PAD_DRAWINFO_m_ShowNCMark_get, _pcbnew.PAD_DRAWINFO_m_ShowNCMark_set, doc=r"""m_ShowNCMark : bool""")
    m_ShowNotPlatedHole = property(_pcbnew.PAD_DRAWINFO_m_ShowNotPlatedHole_get, _pcbnew.PAD_DRAWINFO_m_ShowNotPlatedHole_set, doc=r"""m_ShowNotPlatedHole : bool""")
    m_IsPrinting = property(_pcbnew.PAD_DRAWINFO_m_IsPrinting_get, _pcbnew.PAD_DRAWINFO_m_IsPrinting_set, doc=r"""m_IsPrinting : bool""")
    m_Offset = property(_pcbnew.PAD_DRAWINFO_m_Offset_get, _pcbnew.PAD_DRAWINFO_m_Offset_set, doc=r"""m_Offset : wxPoint""")

    def __init__(self):
        r"""__init__(PAD_DRAWINFO self) -> PAD_DRAWINFO"""
        _pcbnew.PAD_DRAWINFO_swiginit(self, _pcbnew.new_PAD_DRAWINFO())
    __swig_destroy__ = _pcbnew.delete_PAD_DRAWINFO

# Register PAD_DRAWINFO in _pcbnew:
_pcbnew.PAD_DRAWINFO_swigregister(PAD_DRAWINFO)

class PAD_CS_PRIMITIVE(object):
    r"""Proxy of C++ PAD_CS_PRIMITIVE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Shape = property(_pcbnew.PAD_CS_PRIMITIVE_m_Shape_get, _pcbnew.PAD_CS_PRIMITIVE_m_Shape_set, doc=r"""m_Shape : STROKE_T""")
    m_Thickness = property(_pcbnew.PAD_CS_PRIMITIVE_m_Thickness_get, _pcbnew.PAD_CS_PRIMITIVE_m_Thickness_set, doc=r"""m_Thickness : int""")
    m_Radius = property(_pcbnew.PAD_CS_PRIMITIVE_m_Radius_get, _pcbnew.PAD_CS_PRIMITIVE_m_Radius_set, doc=r"""m_Radius : int""")
    m_ArcAngle = property(_pcbnew.PAD_CS_PRIMITIVE_m_ArcAngle_get, _pcbnew.PAD_CS_PRIMITIVE_m_ArcAngle_set, doc=r"""m_ArcAngle : double""")
    m_Start = property(_pcbnew.PAD_CS_PRIMITIVE_m_Start_get, _pcbnew.PAD_CS_PRIMITIVE_m_Start_set, doc=r"""m_Start : wxPoint""")
    m_End = property(_pcbnew.PAD_CS_PRIMITIVE_m_End_get, _pcbnew.PAD_CS_PRIMITIVE_m_End_set, doc=r"""m_End : wxPoint""")
    m_Poly = property(_pcbnew.PAD_CS_PRIMITIVE_m_Poly_get, _pcbnew.PAD_CS_PRIMITIVE_m_Poly_set, doc=r"""m_Poly : std::vector<(wxPoint,std::allocator<(wxPoint)>)>""")

    def __init__(self, aShape):
        r"""__init__(PAD_CS_PRIMITIVE self, STROKE_T aShape) -> PAD_CS_PRIMITIVE"""
        _pcbnew.PAD_CS_PRIMITIVE_swiginit(self, _pcbnew.new_PAD_CS_PRIMITIVE(aShape))

    def GetCenter(self):
        r"""GetCenter(PAD_CS_PRIMITIVE self) -> wxPoint"""
        return _pcbnew.PAD_CS_PRIMITIVE_GetCenter(self)

    def GetArcStart(self):
        r"""GetArcStart(PAD_CS_PRIMITIVE self) -> wxPoint"""
        return _pcbnew.PAD_CS_PRIMITIVE_GetArcStart(self)

    def Move(self, aMoveVector):
        r"""Move(PAD_CS_PRIMITIVE self, wxPoint aMoveVector)"""
        return _pcbnew.PAD_CS_PRIMITIVE_Move(self, aMoveVector)

    def ExportTo(self, *args):
        r"""
        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

# Register PAD_CS_PRIMITIVE in _pcbnew:
_pcbnew.PAD_CS_PRIMITIVE_swigregister(PAD_CS_PRIMITIVE)

class D_PAD(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ D_PAD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, parent):
        r"""__init__(D_PAD self, MODULE parent) -> D_PAD"""
        _pcbnew.D_PAD_swiginit(self, _pcbnew.new_D_PAD(parent))

    @staticmethod
    def StandardMask():
        r"""StandardMask() -> LSET"""
        return _pcbnew.D_PAD_StandardMask()

    @staticmethod
    def SMDMask():
        r"""SMDMask() -> LSET"""
        return _pcbnew.D_PAD_SMDMask()

    @staticmethod
    def ConnSMDMask():
        r"""ConnSMDMask() -> LSET"""
        return _pcbnew.D_PAD_ConnSMDMask()

    @staticmethod
    def UnplatedHoleMask():
        r"""UnplatedHoleMask() -> LSET"""
        return _pcbnew.D_PAD_UnplatedHoleMask()

    @staticmethod
    def ApertureMask():
        r"""ApertureMask() -> LSET"""
        return _pcbnew.D_PAD_ApertureMask()

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.D_PAD_ClassOf(aItem)

    def Next(self):
        r"""Next(D_PAD self) -> D_PAD"""
        return _pcbnew.D_PAD_Next(self)

    def GetParent(self):
        r"""GetParent(D_PAD self) -> MODULE"""
        return _pcbnew.D_PAD_GetParent(self)

    def ImportSettingsFromMaster(self, aMasterPad):
        r"""ImportSettingsFromMaster(D_PAD self, D_PAD aMasterPad)"""
        return _pcbnew.D_PAD_ImportSettingsFromMaster(self, aMasterPad)

    def IsFlipped(self):
        r"""IsFlipped(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_IsFlipped(self)

    def SetName(self, aName):
        r"""SetName(D_PAD self, wxString aName)"""
        return _pcbnew.D_PAD_SetName(self, aName)

    def GetName(self):
        r"""GetName(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_GetName(self)

    def IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps):
        r"""IncrementPadName(D_PAD self, bool aSkipUnconnectable, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.D_PAD_IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps)

    def PadNameEqual(self, other):
        r"""PadNameEqual(D_PAD self, D_PAD other) -> bool"""
        return _pcbnew.D_PAD_PadNameEqual(self, other)

    def GetShape(self):
        r"""GetShape(D_PAD self) -> PAD_SHAPE_T"""
        return _pcbnew.D_PAD_GetShape(self)

    def SetShape(self, aShape):
        r"""SetShape(D_PAD self, PAD_SHAPE_T aShape)"""
        return _pcbnew.D_PAD_SetShape(self, aShape)

    def SetPosition(self, aPos):
        r"""SetPosition(D_PAD self, wxPoint aPos)"""
        return _pcbnew.D_PAD_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_GetPosition(self)

    def GetAnchorPadShape(self):
        r"""GetAnchorPadShape(D_PAD self) -> PAD_SHAPE_T"""
        return _pcbnew.D_PAD_GetAnchorPadShape(self)

    def GetCustomShapeInZoneOpt(self):
        r"""GetCustomShapeInZoneOpt(D_PAD self) -> CUST_PAD_SHAPE_IN_ZONE"""
        return _pcbnew.D_PAD_GetCustomShapeInZoneOpt(self)

    def SetCustomShapeInZoneOpt(self, aOption):
        r"""SetCustomShapeInZoneOpt(D_PAD self, CUST_PAD_SHAPE_IN_ZONE aOption)"""
        return _pcbnew.D_PAD_SetCustomShapeInZoneOpt(self, aOption)

    def SetAnchorPadShape(self, aShape):
        r"""SetAnchorPadShape(D_PAD self, PAD_SHAPE_T aShape)"""
        return _pcbnew.D_PAD_SetAnchorPadShape(self, aShape)

    def SetY(self, y):
        r"""SetY(D_PAD self, int y)"""
        return _pcbnew.D_PAD_SetY(self, y)

    def SetX(self, x):
        r"""SetX(D_PAD self, int x)"""
        return _pcbnew.D_PAD_SetX(self, x)

    def SetPos0(self, aPos):
        r"""SetPos0(D_PAD self, wxPoint aPos)"""
        return _pcbnew.D_PAD_SetPos0(self, aPos)

    def GetPos0(self):
        r"""GetPos0(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_GetPos0(self)

    def SetY0(self, y):
        r"""SetY0(D_PAD self, int y)"""
        return _pcbnew.D_PAD_SetY0(self, y)

    def SetX0(self, x):
        r"""SetX0(D_PAD self, int x)"""
        return _pcbnew.D_PAD_SetX0(self, x)

    def SetSize(self, aSize):
        r"""SetSize(D_PAD self, wxSize aSize)"""
        return _pcbnew.D_PAD_SetSize(self, aSize)

    def GetSize(self):
        r"""GetSize(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetSize(self)

    def SetDelta(self, aSize):
        r"""SetDelta(D_PAD self, wxSize aSize)"""
        return _pcbnew.D_PAD_SetDelta(self, aSize)

    def GetDelta(self):
        r"""GetDelta(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetDelta(self)

    def SetDrillSize(self, aSize):
        r"""SetDrillSize(D_PAD self, wxSize aSize)"""
        return _pcbnew.D_PAD_SetDrillSize(self, aSize)

    def GetDrillSize(self):
        r"""GetDrillSize(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetDrillSize(self)

    def SetOffset(self, aOffset):
        r"""SetOffset(D_PAD self, wxPoint aOffset)"""
        return _pcbnew.D_PAD_SetOffset(self, aOffset)

    def GetOffset(self):
        r"""GetOffset(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_GetOffset(self)

    def AddPrimitive(self, *args):
        r"""
        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):
        r"""GetBestAnchorPosition(D_PAD self, VECTOR2I aPos) -> bool"""
        return _pcbnew.D_PAD_GetBestAnchorPosition(self, aPos)

    def MergePrimitivesAsPolygon(self, *args):
        r"""MergePrimitivesAsPolygon(D_PAD self, SHAPE_POLY_SET aMergedPolygon=None, int aCircleToSegmentsCount=ARC_APPROX_SEGMENTS_COUNT_HIGH_DEF) -> bool"""
        return _pcbnew.D_PAD_MergePrimitivesAsPolygon(self, *args)

    def DeletePrimitivesList(self):
        r"""DeletePrimitivesList(D_PAD self)"""
        return _pcbnew.D_PAD_DeletePrimitivesList(self)

    def CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation):
        r"""CustomShapeAsPolygonToBoardPosition(D_PAD self, SHAPE_POLY_SET aMergedPolygon, wxPoint aPosition, double aRotation)"""
        return _pcbnew.D_PAD_CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation)

    def GetPrimitives(self):
        r"""GetPrimitives(D_PAD self) -> std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const &"""
        return _pcbnew.D_PAD_GetPrimitives(self)

    def GetCustomShapeAsPolygon(self):
        r"""GetCustomShapeAsPolygon(D_PAD self) -> SHAPE_POLY_SET"""
        return _pcbnew.D_PAD_GetCustomShapeAsPolygon(self)

    def Flip(self, aCentre):
        r"""Flip(D_PAD self, wxPoint aCentre)"""
        return _pcbnew.D_PAD_Flip(self, aCentre)

    def FlipPrimitives(self):
        r"""FlipPrimitives(D_PAD self)"""
        return _pcbnew.D_PAD_FlipPrimitives(self)

    def MirrorXPrimitives(self, aX):
        r"""MirrorXPrimitives(D_PAD self, int aX)"""
        return _pcbnew.D_PAD_MirrorXPrimitives(self, aX)

    def SetPrimitives(self, aPrimitivesList):
        r"""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):
        r"""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):
        r"""SetOrientation(D_PAD self, double aAngle)"""
        return _pcbnew.D_PAD_SetOrientation(self, aAngle)

    def SetOrientationDegrees(self, aOrientation):
        r"""SetOrientationDegrees(D_PAD self, double aOrientation)"""
        return _pcbnew.D_PAD_SetOrientationDegrees(self, aOrientation)

    def GetOrientation(self):
        r"""GetOrientation(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientation(self)

    def GetOrientationDegrees(self):
        r"""GetOrientationDegrees(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientationDegrees(self)

    def GetOrientationRadians(self):
        r"""GetOrientationRadians(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetOrientationRadians(self)

    def SetDrillShape(self, aDrillShape):
        r"""SetDrillShape(D_PAD self, PAD_DRILL_SHAPE_T aDrillShape)"""
        return _pcbnew.D_PAD_SetDrillShape(self, aDrillShape)

    def GetDrillShape(self):
        r"""GetDrillShape(D_PAD self) -> PAD_DRILL_SHAPE_T"""
        return _pcbnew.D_PAD_GetDrillShape(self)

    def GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth):
        r"""GetOblongDrillGeometry(D_PAD self, wxPoint aStartPoint, wxPoint aEndPoint, int & aWidth)"""
        return _pcbnew.D_PAD_GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth)

    def SetLayerSet(self, aLayerMask):
        r"""SetLayerSet(D_PAD self, LSET aLayerMask)"""
        return _pcbnew.D_PAD_SetLayerSet(self, aLayerMask)

    def GetLayerSet(self):
        r"""GetLayerSet(D_PAD self) -> LSET"""
        return _pcbnew.D_PAD_GetLayerSet(self)

    def SetAttribute(self, aAttribute):
        r"""SetAttribute(D_PAD self, PAD_ATTR_T aAttribute)"""
        return _pcbnew.D_PAD_SetAttribute(self, aAttribute)

    def GetAttribute(self):
        r"""GetAttribute(D_PAD self) -> PAD_ATTR_T"""
        return _pcbnew.D_PAD_GetAttribute(self)

    def IsAperturePad(self):
        r"""IsAperturePad(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_IsAperturePad(self)

    def SetPadToDieLength(self, aLength):
        r"""SetPadToDieLength(D_PAD self, int aLength)"""
        return _pcbnew.D_PAD_SetPadToDieLength(self, aLength)

    def GetPadToDieLength(self):
        r"""GetPadToDieLength(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetPadToDieLength(self)

    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetLocalSolderMaskMargin(self)

    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(D_PAD self, int aMargin)"""
        return _pcbnew.D_PAD_SetLocalSolderMaskMargin(self, aMargin)

    def GetLocalClearance(self):
        r"""GetLocalClearance(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetLocalClearance(self)

    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(D_PAD self, int aClearance)"""
        return _pcbnew.D_PAD_SetLocalClearance(self, aClearance)

    def GetLocalSolderPasteMargin(self):
        r"""GetLocalSolderPasteMargin(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetLocalSolderPasteMargin(self)

    def SetLocalSolderPasteMargin(self, aMargin):
        r"""SetLocalSolderPasteMargin(D_PAD self, int aMargin)"""
        return _pcbnew.D_PAD_SetLocalSolderPasteMargin(self, aMargin)

    def GetLocalSolderPasteMarginRatio(self):
        r"""GetLocalSolderPasteMarginRatio(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetLocalSolderPasteMarginRatio(self)

    def SetLocalSolderPasteMarginRatio(self, aRatio):
        r"""SetLocalSolderPasteMarginRatio(D_PAD self, double aRatio)"""
        return _pcbnew.D_PAD_SetLocalSolderPasteMarginRatio(self, aRatio)

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

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

    def GetSolderMaskMargin(self):
        r"""GetSolderMaskMargin(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetSolderMaskMargin(self)

    def GetSolderPasteMargin(self):
        r"""GetSolderPasteMargin(D_PAD self) -> wxSize"""
        return _pcbnew.D_PAD_GetSolderPasteMargin(self)

    def SetZoneConnection(self, aType):
        r"""SetZoneConnection(D_PAD self, ZoneConnection aType)"""
        return _pcbnew.D_PAD_SetZoneConnection(self, aType)

    def GetZoneConnection(self):
        r"""GetZoneConnection(D_PAD self) -> ZoneConnection"""
        return _pcbnew.D_PAD_GetZoneConnection(self)

    def SetThermalWidth(self, aWidth):
        r"""SetThermalWidth(D_PAD self, int aWidth)"""
        return _pcbnew.D_PAD_SetThermalWidth(self, aWidth)

    def GetThermalWidth(self):
        r"""GetThermalWidth(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetThermalWidth(self)

    def SetThermalGap(self, aGap):
        r"""SetThermalGap(D_PAD self, int aGap)"""
        return _pcbnew.D_PAD_SetThermalGap(self, aGap)

    def GetThermalGap(self):
        r"""GetThermalGap(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetThermalGap(self)

    def Draw(self, *args):
        r"""Draw(D_PAD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.D_PAD_Draw(self, *args)

    def DrawShape(self, aClipBox, aDC, aDrawInfo):
        r"""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):
        r"""BuildPadPolygon(D_PAD self, wxPoint aCoord, wxSize aInflateValue, double aRotation)"""
        return _pcbnew.D_PAD_BuildPadPolygon(self, aCoord, aInflateValue, aRotation)

    def GetRoundRectCornerRadius(self, *args):
        r"""
        GetRoundRectCornerRadius(D_PAD self) -> int
        GetRoundRectCornerRadius(D_PAD self, wxSize aSize) -> int
        """
        return _pcbnew.D_PAD_GetRoundRectCornerRadius(self, *args)

    def SetRoundRectCornerRadius(self, aRadius):
        r"""SetRoundRectCornerRadius(D_PAD self, double aRadius)"""
        return _pcbnew.D_PAD_SetRoundRectCornerRadius(self, aRadius)

    def BuildPadShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle, aCorrectionFactor):
        r"""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):
        r"""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):
        r"""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):
        r"""GetBoundingRadius(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetBoundingRadius(self)

    def ShapePos(self):
        r"""ShapePos(D_PAD self) -> wxPoint"""
        return _pcbnew.D_PAD_ShapePos(self)

    def GetRoundRectRadiusRatio(self):
        r"""GetRoundRectRadiusRatio(D_PAD self) -> double"""
        return _pcbnew.D_PAD_GetRoundRectRadiusRatio(self)

    def SetRoundRectRadiusRatio(self, aRadiusScale):
        r"""SetRoundRectRadiusRatio(D_PAD self, double aRadiusScale)"""
        return _pcbnew.D_PAD_SetRoundRectRadiusRatio(self, aRadiusScale)

    def GetSubRatsnest(self):
        r"""GetSubRatsnest(D_PAD self) -> int"""
        return _pcbnew.D_PAD_GetSubRatsnest(self)

    def SetSubRatsnest(self, aSubRatsnest):
        r"""SetSubRatsnest(D_PAD self, int aSubRatsnest)"""
        return _pcbnew.D_PAD_SetSubRatsnest(self, aSubRatsnest)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""IsOnLayer(D_PAD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.D_PAD_IsOnLayer(self, aLayer)

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

    def GetClass(self):
        r"""GetClass(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_GetClass(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(D_PAD self) -> EDA_RECT"""
        return _pcbnew.D_PAD_GetBoundingBox(self)

    def SetDrawCoord(self):
        r"""SetDrawCoord(D_PAD self)"""
        return _pcbnew.D_PAD_SetDrawCoord(self)

    def SetLocalCoord(self):
        r"""SetLocalCoord(D_PAD self)"""
        return _pcbnew.D_PAD_SetLocalCoord(self)

    @staticmethod
    def Compare(padref, padcmp):
        r"""Compare(D_PAD padref, D_PAD padcmp) -> int"""
        return _pcbnew.D_PAD_Compare(padref, padcmp)

    def Move(self, aMoveVector):
        r"""Move(D_PAD self, wxPoint aMoveVector)"""
        return _pcbnew.D_PAD_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(D_PAD self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.D_PAD_Rotate(self, aRotCentre, aAngle)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(D_PAD self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.D_PAD_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(D_PAD self) -> BITMAP_DEF"""
        return _pcbnew.D_PAD_GetMenuImage(self)

    def ShowPadShape(self):
        r"""ShowPadShape(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_ShowPadShape(self)

    def ShowPadAttr(self):
        r"""ShowPadAttr(D_PAD self) -> wxString"""
        return _pcbnew.D_PAD_ShowPadAttr(self)

    def AppendConfigs(self, aResult):
        r"""AppendConfigs(D_PAD self, PARAM_CFG_ARRAY * aResult)"""
        return _pcbnew.D_PAD_AppendConfigs(self, aResult)

    def Clone(self):
        r"""Clone(D_PAD self) -> EDA_ITEM"""
        return _pcbnew.D_PAD_Clone(self)

    def Duplicate(self):
        r"""Duplicate(D_PAD self) -> D_PAD"""
        return _pcbnew.D_PAD_Duplicate(self)

    def PadShouldBeNPTH(self):
        r"""PadShouldBeNPTH(D_PAD self) -> bool"""
        return _pcbnew.D_PAD_PadShouldBeNPTH(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(D_PAD self, int [] aLayers, int & aCount)"""
        return _pcbnew.D_PAD_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(D_PAD self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.D_PAD_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self):
        r"""ViewBBox(D_PAD self) -> BOX2I const"""
        return _pcbnew.D_PAD_ViewBBox(self)

    def CopyNetlistSettings(self, aPad, aCopyLocalSettings):
        r"""CopyNetlistSettings(D_PAD self, D_PAD aPad, bool aCopyLocalSettings)"""
        return _pcbnew.D_PAD_CopyNetlistSettings(self, aPad, aCopyLocalSettings)

    def SwapData(self, aImage):
        r"""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

# Register D_PAD in _pcbnew:
_pcbnew.D_PAD_swigregister(D_PAD)

def D_PAD_StandardMask():
    r"""D_PAD_StandardMask() -> LSET"""
    return _pcbnew.D_PAD_StandardMask()

def D_PAD_SMDMask():
    r"""D_PAD_SMDMask() -> LSET"""
    return _pcbnew.D_PAD_SMDMask()

def D_PAD_ConnSMDMask():
    r"""D_PAD_ConnSMDMask() -> LSET"""
    return _pcbnew.D_PAD_ConnSMDMask()

def D_PAD_UnplatedHoleMask():
    r"""D_PAD_UnplatedHoleMask() -> LSET"""
    return _pcbnew.D_PAD_UnplatedHoleMask()

def D_PAD_ApertureMask():
    r"""D_PAD_ApertureMask() -> LSET"""
    return _pcbnew.D_PAD_ApertureMask()

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

def D_PAD_Compare(padref, padcmp):
    r"""D_PAD_Compare(D_PAD padref, D_PAD padcmp) -> int"""
    return _pcbnew.D_PAD_Compare(padref, padcmp)

class PAD_List(DHEAD):
    r"""Proxy of C++ DLIST< D_PAD > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def Get(self):
        r"""Get(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Get(self)

    def __deref__(self):
        r"""__deref__(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List___deref__(self)

    def GetFirst(self):
        r"""GetFirst(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_GetFirst(self)

    def GetLast(self):
        r"""GetLast(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_GetLast(self)

    def Append(self, *args):
        r"""
        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):
        r"""Insert(PAD_List self, D_PAD aNewElement, D_PAD aElementAfterMe)"""
        return _pcbnew.PAD_List_Insert(self, aNewElement, aElementAfterMe)

    def Remove(self, aElement):
        r"""Remove(PAD_List self, D_PAD aElement) -> D_PAD"""
        return _pcbnew.PAD_List_Remove(self, aElement)

    def begin(self):
        r"""begin(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_begin(self)

    def end(self):
        r"""end(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_end(self)

    def PopFront(self):
        r"""PopFront(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_PopFront(self)

    def PopBack(self):
        r"""PopBack(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_PopBack(self)

    def PushFront(self, aNewElement):
        r"""PushFront(PAD_List self, D_PAD aNewElement)"""
        return _pcbnew.PAD_List_PushFront(self, aNewElement)

    def PushBack(self, aNewElement):
        r"""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):
        r"""__init__(PAD_List self) -> PAD_List"""
        _pcbnew.PAD_List_swiginit(self, _pcbnew.new_PAD_List())
    __swig_destroy__ = _pcbnew.delete_PAD_List

    def StandardMask(self):
        r"""StandardMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_StandardMask(self)

    def SMDMask(self):
        r"""SMDMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_SMDMask(self)

    def ConnSMDMask(self):
        r"""ConnSMDMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_ConnSMDMask(self)

    def UnplatedHoleMask(self):
        r"""UnplatedHoleMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_UnplatedHoleMask(self)

    def ApertureMask(self):
        r"""ApertureMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_ApertureMask(self)

    def ClassOf(self, aItem):
        r"""ClassOf(PAD_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_List_ClassOf(self, aItem)

    def Next(self):
        r"""Next(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Next(self)

    def GetParent(self):
        r"""GetParent(PAD_List self) -> MODULE"""
        return _pcbnew.PAD_List_GetParent(self)

    def ImportSettingsFromMaster(self, aMasterPad):
        r"""ImportSettingsFromMaster(PAD_List self, D_PAD aMasterPad)"""
        return _pcbnew.PAD_List_ImportSettingsFromMaster(self, aMasterPad)

    def IsFlipped(self):
        r"""IsFlipped(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsFlipped(self)

    def SetName(self, aName):
        r"""SetName(PAD_List self, wxString aName)"""
        return _pcbnew.PAD_List_SetName(self, aName)

    def GetName(self):
        r"""GetName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetName(self)

    def IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps):
        r"""IncrementPadName(PAD_List self, bool aSkipUnconnectable, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.PAD_List_IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps)

    def PadNameEqual(self, other):
        r"""PadNameEqual(PAD_List self, D_PAD other) -> bool"""
        return _pcbnew.PAD_List_PadNameEqual(self, other)

    def GetShape(self):
        r"""GetShape(PAD_List self) -> PAD_SHAPE_T"""
        return _pcbnew.PAD_List_GetShape(self)

    def SetShape(self, aShape):
        r"""SetShape(PAD_List self, PAD_SHAPE_T aShape)"""
        return _pcbnew.PAD_List_SetShape(self, aShape)

    def SetPosition(self, aPos):
        r"""SetPosition(PAD_List self, wxPoint aPos)"""
        return _pcbnew.PAD_List_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetPosition(self)

    def GetAnchorPadShape(self):
        r"""GetAnchorPadShape(PAD_List self) -> PAD_SHAPE_T"""
        return _pcbnew.PAD_List_GetAnchorPadShape(self)

    def GetCustomShapeInZoneOpt(self):
        r"""GetCustomShapeInZoneOpt(PAD_List self) -> CUST_PAD_SHAPE_IN_ZONE"""
        return _pcbnew.PAD_List_GetCustomShapeInZoneOpt(self)

    def SetCustomShapeInZoneOpt(self, aOption):
        r"""SetCustomShapeInZoneOpt(PAD_List self, CUST_PAD_SHAPE_IN_ZONE aOption)"""
        return _pcbnew.PAD_List_SetCustomShapeInZoneOpt(self, aOption)

    def SetAnchorPadShape(self, aShape):
        r"""SetAnchorPadShape(PAD_List self, PAD_SHAPE_T aShape)"""
        return _pcbnew.PAD_List_SetAnchorPadShape(self, aShape)

    def SetY(self, y):
        r"""SetY(PAD_List self, int y)"""
        return _pcbnew.PAD_List_SetY(self, y)

    def SetX(self, x):
        r"""SetX(PAD_List self, int x)"""
        return _pcbnew.PAD_List_SetX(self, x)

    def SetPos0(self, aPos):
        r"""SetPos0(PAD_List self, wxPoint aPos)"""
        return _pcbnew.PAD_List_SetPos0(self, aPos)

    def GetPos0(self):
        r"""GetPos0(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetPos0(self)

    def SetY0(self, y):
        r"""SetY0(PAD_List self, int y)"""
        return _pcbnew.PAD_List_SetY0(self, y)

    def SetX0(self, x):
        r"""SetX0(PAD_List self, int x)"""
        return _pcbnew.PAD_List_SetX0(self, x)

    def SetSize(self, aSize):
        r"""SetSize(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetSize(self, aSize)

    def GetSize(self):
        r"""GetSize(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetSize(self)

    def SetDelta(self, aSize):
        r"""SetDelta(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetDelta(self, aSize)

    def GetDelta(self):
        r"""GetDelta(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetDelta(self)

    def SetDrillSize(self, aSize):
        r"""SetDrillSize(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetDrillSize(self, aSize)

    def GetDrillSize(self):
        r"""GetDrillSize(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetDrillSize(self)

    def SetOffset(self, aOffset):
        r"""SetOffset(PAD_List self, wxPoint aOffset)"""
        return _pcbnew.PAD_List_SetOffset(self, aOffset)

    def GetOffset(self):
        r"""GetOffset(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetOffset(self)

    def AddPrimitive(self, *args):
        r"""
        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):
        r"""GetBestAnchorPosition(PAD_List self, VECTOR2I aPos) -> bool"""
        return _pcbnew.PAD_List_GetBestAnchorPosition(self, aPos)

    def MergePrimitivesAsPolygon(self, *args):
        r"""MergePrimitivesAsPolygon(PAD_List self, SHAPE_POLY_SET aMergedPolygon=None, int aCircleToSegmentsCount=ARC_APPROX_SEGMENTS_COUNT_HIGH_DEF) -> bool"""
        return _pcbnew.PAD_List_MergePrimitivesAsPolygon(self, *args)

    def DeletePrimitivesList(self):
        r"""DeletePrimitivesList(PAD_List self)"""
        return _pcbnew.PAD_List_DeletePrimitivesList(self)

    def CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation):
        r"""CustomShapeAsPolygonToBoardPosition(PAD_List self, SHAPE_POLY_SET aMergedPolygon, wxPoint aPosition, double aRotation)"""
        return _pcbnew.PAD_List_CustomShapeAsPolygonToBoardPosition(self, aMergedPolygon, aPosition, aRotation)

    def GetPrimitives(self):
        r"""GetPrimitives(PAD_List self) -> std::vector< PAD_CS_PRIMITIVE,std::allocator< PAD_CS_PRIMITIVE > > const &"""
        return _pcbnew.PAD_List_GetPrimitives(self)

    def GetCustomShapeAsPolygon(self):
        r"""GetCustomShapeAsPolygon(PAD_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.PAD_List_GetCustomShapeAsPolygon(self)

    def Flip(self, aCentre):
        r"""Flip(PAD_List self, wxPoint aCentre)"""
        return _pcbnew.PAD_List_Flip(self, aCentre)

    def FlipPrimitives(self):
        r"""FlipPrimitives(PAD_List self)"""
        return _pcbnew.PAD_List_FlipPrimitives(self)

    def MirrorXPrimitives(self, aX):
        r"""MirrorXPrimitives(PAD_List self, int aX)"""
        return _pcbnew.PAD_List_MirrorXPrimitives(self, aX)

    def SetPrimitives(self, aPrimitivesList):
        r"""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):
        r"""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):
        r"""SetOrientation(PAD_List self, double aAngle)"""
        return _pcbnew.PAD_List_SetOrientation(self, aAngle)

    def SetOrientationDegrees(self, aOrientation):
        r"""SetOrientationDegrees(PAD_List self, double aOrientation)"""
        return _pcbnew.PAD_List_SetOrientationDegrees(self, aOrientation)

    def GetOrientation(self):
        r"""GetOrientation(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientation(self)

    def GetOrientationDegrees(self):
        r"""GetOrientationDegrees(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientationDegrees(self)

    def GetOrientationRadians(self):
        r"""GetOrientationRadians(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientationRadians(self)

    def SetDrillShape(self, aDrillShape):
        r"""SetDrillShape(PAD_List self, PAD_DRILL_SHAPE_T aDrillShape)"""
        return _pcbnew.PAD_List_SetDrillShape(self, aDrillShape)

    def GetDrillShape(self):
        r"""GetDrillShape(PAD_List self) -> PAD_DRILL_SHAPE_T"""
        return _pcbnew.PAD_List_GetDrillShape(self)

    def GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth):
        r"""GetOblongDrillGeometry(PAD_List self, wxPoint aStartPoint, wxPoint aEndPoint, int & aWidth)"""
        return _pcbnew.PAD_List_GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth)

    def SetLayerSet(self, aLayerMask):
        r"""SetLayerSet(PAD_List self, LSET aLayerMask)"""
        return _pcbnew.PAD_List_SetLayerSet(self, aLayerMask)

    def GetLayerSet(self):
        r"""GetLayerSet(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_GetLayerSet(self)

    def SetAttribute(self, aAttribute):
        r"""SetAttribute(PAD_List self, PAD_ATTR_T aAttribute)"""
        return _pcbnew.PAD_List_SetAttribute(self, aAttribute)

    def GetAttribute(self):
        r"""GetAttribute(PAD_List self) -> PAD_ATTR_T"""
        return _pcbnew.PAD_List_GetAttribute(self)

    def IsAperturePad(self):
        r"""IsAperturePad(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsAperturePad(self)

    def SetPadToDieLength(self, aLength):
        r"""SetPadToDieLength(PAD_List self, int aLength)"""
        return _pcbnew.PAD_List_SetPadToDieLength(self, aLength)

    def GetPadToDieLength(self):
        r"""GetPadToDieLength(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetPadToDieLength(self)

    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalSolderMaskMargin(self)

    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(PAD_List self, int aMargin)"""
        return _pcbnew.PAD_List_SetLocalSolderMaskMargin(self, aMargin)

    def GetLocalClearance(self):
        r"""GetLocalClearance(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalClearance(self)

    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(PAD_List self, int aClearance)"""
        return _pcbnew.PAD_List_SetLocalClearance(self, aClearance)

    def GetLocalSolderPasteMargin(self):
        r"""GetLocalSolderPasteMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalSolderPasteMargin(self)

    def SetLocalSolderPasteMargin(self, aMargin):
        r"""SetLocalSolderPasteMargin(PAD_List self, int aMargin)"""
        return _pcbnew.PAD_List_SetLocalSolderPasteMargin(self, aMargin)

    def GetLocalSolderPasteMarginRatio(self):
        r"""GetLocalSolderPasteMarginRatio(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetLocalSolderPasteMarginRatio(self)

    def SetLocalSolderPasteMarginRatio(self, aRatio):
        r"""SetLocalSolderPasteMarginRatio(PAD_List self, double aRatio)"""
        return _pcbnew.PAD_List_SetLocalSolderPasteMarginRatio(self, aRatio)

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

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

    def GetSolderMaskMargin(self):
        r"""GetSolderMaskMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetSolderMaskMargin(self)

    def GetSolderPasteMargin(self):
        r"""GetSolderPasteMargin(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetSolderPasteMargin(self)

    def SetZoneConnection(self, aType):
        r"""SetZoneConnection(PAD_List self, ZoneConnection aType)"""
        return _pcbnew.PAD_List_SetZoneConnection(self, aType)

    def GetZoneConnection(self):
        r"""GetZoneConnection(PAD_List self) -> ZoneConnection"""
        return _pcbnew.PAD_List_GetZoneConnection(self)

    def SetThermalWidth(self, aWidth):
        r"""SetThermalWidth(PAD_List self, int aWidth)"""
        return _pcbnew.PAD_List_SetThermalWidth(self, aWidth)

    def GetThermalWidth(self):
        r"""GetThermalWidth(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetThermalWidth(self)

    def SetThermalGap(self, aGap):
        r"""SetThermalGap(PAD_List self, int aGap)"""
        return _pcbnew.PAD_List_SetThermalGap(self, aGap)

    def GetThermalGap(self):
        r"""GetThermalGap(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetThermalGap(self)

    def Draw(self, *args):
        r"""Draw(PAD_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.PAD_List_Draw(self, *args)

    def DrawShape(self, aClipBox, aDC, aDrawInfo):
        r"""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):
        r"""BuildPadPolygon(PAD_List self, wxPoint aCoord, wxSize aInflateValue, double aRotation)"""
        return _pcbnew.PAD_List_BuildPadPolygon(self, aCoord, aInflateValue, aRotation)

    def GetRoundRectCornerRadius(self, *args):
        r"""
        GetRoundRectCornerRadius(PAD_List self) -> int
        GetRoundRectCornerRadius(PAD_List self, wxSize aSize) -> int
        """
        return _pcbnew.PAD_List_GetRoundRectCornerRadius(self, *args)

    def SetRoundRectCornerRadius(self, aRadius):
        r"""SetRoundRectCornerRadius(PAD_List self, double aRadius)"""
        return _pcbnew.PAD_List_SetRoundRectCornerRadius(self, aRadius)

    def BuildPadShapePolygon(self, aCornerBuffer, aInflateValue, aSegmentsPerCircle, aCorrectionFactor):
        r"""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):
        r"""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):
        r"""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):
        r"""GetBoundingRadius(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetBoundingRadius(self)

    def ShapePos(self):
        r"""ShapePos(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_ShapePos(self)

    def GetRoundRectRadiusRatio(self):
        r"""GetRoundRectRadiusRatio(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetRoundRectRadiusRatio(self)

    def SetRoundRectRadiusRatio(self, aRadiusScale):
        r"""SetRoundRectRadiusRatio(PAD_List self, double aRadiusScale)"""
        return _pcbnew.PAD_List_SetRoundRectRadiusRatio(self, aRadiusScale)

    def GetSubRatsnest(self):
        r"""GetSubRatsnest(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetSubRatsnest(self)

    def SetSubRatsnest(self, aSubRatsnest):
        r"""SetSubRatsnest(PAD_List self, int aSubRatsnest)"""
        return _pcbnew.PAD_List_SetSubRatsnest(self, aSubRatsnest)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""IsOnLayer(PAD_List self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PAD_List_IsOnLayer(self, aLayer)

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

    def GetClass(self):
        r"""GetClass(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetClass(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(PAD_List self) -> EDA_RECT"""
        return _pcbnew.PAD_List_GetBoundingBox(self)

    def SetDrawCoord(self):
        r"""SetDrawCoord(PAD_List self)"""
        return _pcbnew.PAD_List_SetDrawCoord(self)

    def SetLocalCoord(self):
        r"""SetLocalCoord(PAD_List self)"""
        return _pcbnew.PAD_List_SetLocalCoord(self)

    def Compare(self, padref, padcmp):
        r"""Compare(PAD_List self, D_PAD padref, D_PAD padcmp) -> int"""
        return _pcbnew.PAD_List_Compare(self, padref, padcmp)

    def Move(self, aMoveVector):
        r"""Move(PAD_List self, wxPoint aMoveVector)"""
        return _pcbnew.PAD_List_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(PAD_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PAD_List_Rotate(self, aRotCentre, aAngle)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(PAD_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.PAD_List_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(PAD_List self) -> BITMAP_DEF"""
        return _pcbnew.PAD_List_GetMenuImage(self)

    def ShowPadShape(self):
        r"""ShowPadShape(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_ShowPadShape(self)

    def ShowPadAttr(self):
        r"""ShowPadAttr(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_ShowPadAttr(self)

    def AppendConfigs(self, aResult):
        r"""AppendConfigs(PAD_List self, PARAM_CFG_ARRAY * aResult)"""
        return _pcbnew.PAD_List_AppendConfigs(self, aResult)

    def Clone(self):
        r"""Clone(PAD_List self) -> EDA_ITEM"""
        return _pcbnew.PAD_List_Clone(self)

    def Duplicate(self):
        r"""Duplicate(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Duplicate(self)

    def PadShouldBeNPTH(self):
        r"""PadShouldBeNPTH(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_PadShouldBeNPTH(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(PAD_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.PAD_List_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PAD_List self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.PAD_List_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self):
        r"""ViewBBox(PAD_List self) -> BOX2I const"""
        return _pcbnew.PAD_List_ViewBBox(self)

    def CopyNetlistSettings(self, aPad, aCopyLocalSettings):
        r"""CopyNetlistSettings(PAD_List self, D_PAD aPad, bool aCopyLocalSettings)"""
        return _pcbnew.PAD_List_CopyNetlistSettings(self, aPad, aCopyLocalSettings)

    def SwapData(self, aImage):
        r"""SwapData(PAD_List self, BOARD_ITEM aImage)"""
        return _pcbnew.PAD_List_SwapData(self, aImage)

    def IsConnected(self):
        r"""IsConnected(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsConnected(self)

    def GetNet(self):
        r"""GetNet(PAD_List self) -> NETINFO_ITEM"""
        return _pcbnew.PAD_List_GetNet(self)

    def SetNet(self, aNetInfo):
        r"""SetNet(PAD_List self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.PAD_List_SetNet(self, aNetInfo)

    def GetNetCode(self):
        r"""GetNetCode(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetNetCode(self)

    def SetNetCode(self, aNetCode, aNoAssert=False):
        r"""SetNetCode(PAD_List self, int aNetCode, bool aNoAssert=False) -> bool"""
        return _pcbnew.PAD_List_SetNetCode(self, aNetCode, aNoAssert)

    def GetNetname(self):
        r"""GetNetname(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetname(self)

    def GetNetnameMsg(self):
        r"""GetNetnameMsg(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetnameMsg(self)

    def GetShortNetname(self):
        r"""GetShortNetname(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetShortNetname(self)

    def GetNetClass(self):
        r"""GetNetClass(PAD_List self) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.PAD_List_GetNetClass(self)

    def GetNetClassName(self):
        r"""GetNetClassName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetNetClassName(self)

    def SetLocalRatsnestVisible(self, aVisible):
        r"""SetLocalRatsnestVisible(PAD_List self, bool aVisible)"""
        return _pcbnew.PAD_List_SetLocalRatsnestVisible(self, aVisible)

    def GetLocalRatsnestVisible(self):
        r"""GetLocalRatsnestVisible(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_GetLocalRatsnestVisible(self)

    def GetCenter(self):
        r"""GetCenter(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetCenter(self)

    def Back(self):
        r"""Back(PAD_List self) -> BOARD_ITEM"""
        return _pcbnew.PAD_List_Back(self)

    def GetLayer(self):
        r"""GetLayer(PAD_List self) -> PCB_LAYER_ID"""
        return _pcbnew.PAD_List_GetLayer(self)

    def SetLayer(self, aLayer):
        r"""SetLayer(PAD_List self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PAD_List_SetLayer(self, aLayer)

    def IsTrack(self):
        r"""IsTrack(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsTrack(self)

    def IsLocked(self):
        r"""IsLocked(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsLocked(self)

    def SetLocked(self, aLocked):
        r"""SetLocked(PAD_List self, bool aLocked)"""
        return _pcbnew.PAD_List_SetLocked(self, aLocked)

    def UnLink(self):
        r"""UnLink(PAD_List self)"""
        return _pcbnew.PAD_List_UnLink(self)

    def DeleteStructure(self):
        r"""DeleteStructure(PAD_List self)"""
        return _pcbnew.PAD_List_DeleteStructure(self)

    def ShowShape(self, aShape):
        r"""ShowShape(PAD_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.PAD_List_ShowShape(self, aShape)

    def GetBoard(self):
        r"""GetBoard(PAD_List self) -> BOARD"""
        return _pcbnew.PAD_List_GetBoard(self)

    def GetLayerName(self):
        r"""GetLayerName(PAD_List self) -> wxString"""
        return _pcbnew.PAD_List_GetLayerName(self)

    def Type(self):
        r"""Type(PAD_List self) -> KICAD_T"""
        return _pcbnew.PAD_List_Type(self)

    def SetTimeStamp(self, aNewTimeStamp):
        r"""SetTimeStamp(PAD_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.PAD_List_SetTimeStamp(self, aNewTimeStamp)

    def GetTimeStamp(self):
        r"""GetTimeStamp(PAD_List self) -> timestamp_t"""
        return _pcbnew.PAD_List_GetTimeStamp(self)

    def GetList(self):
        r"""GetList(PAD_List self) -> DHEAD"""
        return _pcbnew.PAD_List_GetList(self)

    def SetParent(self, aParent):
        r"""SetParent(PAD_List self, EDA_ITEM aParent)"""
        return _pcbnew.PAD_List_SetParent(self, aParent)

    def SetList(self, aList):
        r"""SetList(PAD_List self, DHEAD aList)"""
        return _pcbnew.PAD_List_SetList(self, aList)

    def IsNew(self):
        r"""IsNew(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsNew(self)

    def IsModified(self):
        r"""IsModified(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsModified(self)

    def IsMoving(self):
        r"""IsMoving(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsMoving(self)

    def IsDragging(self):
        r"""IsDragging(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsDragging(self)

    def IsWireImage(self):
        r"""IsWireImage(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsWireImage(self)

    def IsSelected(self):
        r"""IsSelected(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsSelected(self)

    def IsResized(self):
        r"""IsResized(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsResized(self)

    def IsHighlighted(self):
        r"""IsHighlighted(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsHighlighted(self)

    def IsBrightened(self):
        r"""IsBrightened(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsBrightened(self)

    def SetWireImage(self):
        r"""SetWireImage(PAD_List self)"""
        return _pcbnew.PAD_List_SetWireImage(self)

    def SetSelected(self):
        r"""SetSelected(PAD_List self)"""
        return _pcbnew.PAD_List_SetSelected(self)

    def SetHighlighted(self):
        r"""SetHighlighted(PAD_List self)"""
        return _pcbnew.PAD_List_SetHighlighted(self)

    def SetBrightened(self):
        r"""SetBrightened(PAD_List self)"""
        return _pcbnew.PAD_List_SetBrightened(self)

    def ClearSelected(self):
        r"""ClearSelected(PAD_List self)"""
        return _pcbnew.PAD_List_ClearSelected(self)

    def ClearHighlighted(self):
        r"""ClearHighlighted(PAD_List self)"""
        return _pcbnew.PAD_List_ClearHighlighted(self)

    def ClearBrightened(self):
        r"""ClearBrightened(PAD_List self)"""
        return _pcbnew.PAD_List_ClearBrightened(self)

    def SetModified(self):
        r"""SetModified(PAD_List self)"""
        return _pcbnew.PAD_List_SetModified(self)

    def GetState(self, type):
        r"""GetState(PAD_List self, int type) -> int"""
        return _pcbnew.PAD_List_GetState(self, type)

    def SetState(self, type, state):
        r"""SetState(PAD_List self, int type, int state)"""
        return _pcbnew.PAD_List_SetState(self, type, state)

    def GetStatus(self):
        r"""GetStatus(PAD_List self) -> STATUS_FLAGS"""
        return _pcbnew.PAD_List_GetStatus(self)

    def SetStatus(self, aStatus):
        r"""SetStatus(PAD_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.PAD_List_SetStatus(self, aStatus)

    def SetFlags(self, aMask):
        r"""SetFlags(PAD_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.PAD_List_SetFlags(self, aMask)

    def ClearFlags(self, aMask=-1):
        r"""ClearFlags(PAD_List self, STATUS_FLAGS aMask=-1)"""
        return _pcbnew.PAD_List_ClearFlags(self, aMask)

    def GetFlags(self):
        r"""GetFlags(PAD_List self) -> STATUS_FLAGS"""
        return _pcbnew.PAD_List_GetFlags(self)

    def IsType(self, aScanTypes):
        r"""IsType(PAD_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PAD_List_IsType(self, aScanTypes)

    def SetForceVisible(self, aEnable):
        r"""SetForceVisible(PAD_List self, bool aEnable)"""
        return _pcbnew.PAD_List_SetForceVisible(self, aEnable)

    def IterateForward(self, listStart, inspector, testData, scanTypes):
        r"""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):
        r"""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):
        r"""Matches(PAD_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.PAD_List_Matches(self, aSearchData, aAuxData, aFindLocation)

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

    def IsReplaceable(self):
        r"""IsReplaceable(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IsReplaceable(self)

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

    def Sort(self, aLeft, aRight):
        r"""Sort(PAD_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.PAD_List_Sort(self, aLeft, aRight)

# Register PAD_List in _pcbnew:
_pcbnew.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):
    r"""GetTrack(TRACK aStartTrace, TRACK aEndTrace, wxPoint aPosition, LSET aLayerMask) -> TRACK"""
    return _pcbnew.GetTrack(aStartTrace, aEndTrace, aPosition, aLayerMask)
class TRACK(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ TRACK class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_ClassOf(aItem)
    start = property(_pcbnew.TRACK_start_get, _pcbnew.TRACK_start_set, doc=r"""start : p.BOARD_CONNECTED_ITEM""")
    end = property(_pcbnew.TRACK_end_get, _pcbnew.TRACK_end_set, doc=r"""end : p.BOARD_CONNECTED_ITEM""")
    m_Param = property(_pcbnew.TRACK_m_Param_get, _pcbnew.TRACK_m_Param_set, doc=r"""m_Param : double""")

    def __init__(self, aParent, idtype=PCB_TRACE_T):
        r"""__init__(TRACK self, BOARD_ITEM aParent, KICAD_T idtype=PCB_TRACE_T) -> TRACK"""
        _pcbnew.TRACK_swiginit(self, _pcbnew.new_TRACK(aParent, idtype))

    def Next(self):
        r"""Next(TRACK self) -> TRACK"""
        return _pcbnew.TRACK_Next(self)

    def Back(self):
        r"""Back(TRACK self) -> TRACK"""
        return _pcbnew.TRACK_Back(self)

    def Move(self, aMoveVector):
        r"""Move(TRACK self, wxPoint aMoveVector)"""
        return _pcbnew.TRACK_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(TRACK self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TRACK_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(TRACK self, wxPoint aCentre)"""
        return _pcbnew.TRACK_Flip(self, aCentre)

    def SetPosition(self, aPos):
        r"""SetPosition(TRACK self, wxPoint aPos)"""
        return _pcbnew.TRACK_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetPosition(self)

    def SetWidth(self, aWidth):
        r"""SetWidth(TRACK self, int aWidth)"""
        return _pcbnew.TRACK_SetWidth(self, aWidth)

    def GetWidth(self):
        r"""GetWidth(TRACK self) -> int"""
        return _pcbnew.TRACK_GetWidth(self)

    def SetEnd(self, aEnd):
        r"""SetEnd(TRACK self, wxPoint aEnd)"""
        return _pcbnew.TRACK_SetEnd(self, aEnd)

    def GetEnd(self):
        r"""GetEnd(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetEnd(self)

    def SetStart(self, aStart):
        r"""SetStart(TRACK self, wxPoint aStart)"""
        return _pcbnew.TRACK_SetStart(self, aStart)

    def GetStart(self):
        r"""GetStart(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetStart(self)

    def GetEndPoint(self, aEndPoint):
        r"""GetEndPoint(TRACK self, ENDPOINT_T aEndPoint) -> wxPoint"""
        return _pcbnew.TRACK_GetEndPoint(self, aEndPoint)

    def GetBoundingBox(self):
        r"""GetBoundingBox(TRACK self) -> EDA_RECT"""
        return _pcbnew.TRACK_GetBoundingBox(self)

    def IsLocked(self):
        r"""IsLocked(TRACK self) -> bool"""
        return _pcbnew.TRACK_IsLocked(self)

    def SetLocked(self, aLocked):
        r"""SetLocked(TRACK self, bool aLocked)"""
        return _pcbnew.TRACK_SetLocked(self, aLocked)

    def GetBestInsertPoint(self, aPcb):
        r"""GetBestInsertPoint(TRACK self, BOARD aPcb) -> TRACK"""
        return _pcbnew.TRACK_GetBestInsertPoint(self, aPcb)

    def GetStartNetCode(self, NetCode):
        r"""GetStartNetCode(TRACK self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_GetStartNetCode(self, NetCode)

    def GetEndNetCode(self, NetCode):
        r"""GetEndNetCode(TRACK self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_GetEndNetCode(self, NetCode)

    def GetLength(self):
        r"""GetLength(TRACK self) -> double"""
        return _pcbnew.TRACK_GetLength(self)

    def Draw(self, *args):
        r"""Draw(TRACK self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.TRACK_Draw(self, *args)

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

    def IsPointOnEnds(self, point, min_dist=0):
        r"""IsPointOnEnds(TRACK self, wxPoint point, int min_dist=0) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_IsPointOnEnds(self, point, min_dist)

    def IsNull(self):
        r"""IsNull(TRACK self) -> bool"""
        return _pcbnew.TRACK_IsNull(self)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""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):
        r"""
        HitTest(TRACK self, wxPoint aPosition) -> bool
        HitTest(TRACK self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.TRACK_HitTest(self, *args)

    def GetVia(self, *args):
        r"""
        GetVia(TRACK self, wxPoint aPosition, PCB_LAYER_ID aLayer=UNDEFINED_LAYER) -> 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):
        r"""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):
        r"""GetEndSegments(TRACK self, int NbSegm, TRACK ** StartTrack, TRACK ** EndTrack) -> int"""
        return _pcbnew.TRACK_GetEndSegments(self, NbSegm, StartTrack, EndTrack)

    def GetClass(self):
        r"""GetClass(TRACK self) -> wxString"""
        return _pcbnew.TRACK_GetClass(self)

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

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(TRACK self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TRACK_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(TRACK self) -> BITMAP_DEF"""
        return _pcbnew.TRACK_GetMenuImage(self)

    def Clone(self):
        r"""Clone(TRACK self) -> EDA_ITEM"""
        return _pcbnew.TRACK_Clone(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(TRACK self, int [] aLayers, int & aCount)"""
        return _pcbnew.TRACK_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(TRACK self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.TRACK_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self):
        r"""ViewBBox(TRACK self) -> BOX2I const"""
        return _pcbnew.TRACK_ViewBBox(self)

    def SwapData(self, aImage):
        r"""SwapData(TRACK self, BOARD_ITEM aImage)"""
        return _pcbnew.TRACK_SwapData(self, aImage)
    __swig_destroy__ = _pcbnew.delete_TRACK

# Register TRACK in _pcbnew:
_pcbnew.TRACK_swigregister(TRACK)

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

class SEGZONE(TRACK):
    r"""Proxy of C++ SEGZONE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aParent):
        r"""__init__(SEGZONE self, BOARD_ITEM aParent) -> SEGZONE"""
        _pcbnew.SEGZONE_swiginit(self, _pcbnew.new_SEGZONE(aParent))

    def GetClass(self):
        r"""GetClass(SEGZONE self) -> wxString"""
        return _pcbnew.SEGZONE_GetClass(self)

    def Next(self):
        r"""Next(SEGZONE self) -> SEGZONE"""
        return _pcbnew.SEGZONE_Next(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(SEGZONE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.SEGZONE_GetSelectMenuText(self, aUnits)

    def Draw(self, *args):
        r"""Draw(SEGZONE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.SEGZONE_Draw(self, *args)

    def GetMenuImage(self):
        r"""GetMenuImage(SEGZONE self) -> BITMAP_DEF"""
        return _pcbnew.SEGZONE_GetMenuImage(self)

    def Clone(self):
        r"""Clone(SEGZONE self) -> EDA_ITEM"""
        return _pcbnew.SEGZONE_Clone(self)
    __swig_destroy__ = _pcbnew.delete_SEGZONE

# Register SEGZONE in _pcbnew:
_pcbnew.SEGZONE_swigregister(SEGZONE)

class VIA(TRACK):
    r"""Proxy of C++ VIA class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aParent):
        r"""__init__(VIA self, BOARD_ITEM aParent) -> VIA"""
        _pcbnew.VIA_swiginit(self, _pcbnew.new_VIA(aParent))

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.VIA_ClassOf(aItem)

    def Draw(self, *args):
        r"""Draw(VIA self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.VIA_Draw(self, *args)

    def IsOnLayer(self, aLayer):
        r"""IsOnLayer(VIA self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.VIA_IsOnLayer(self, aLayer)

    def GetLayerSet(self):
        r"""GetLayerSet(VIA self) -> LSET"""
        return _pcbnew.VIA_GetLayerSet(self)

    def SetLayerPair(self, aTopLayer, aBottomLayer):
        r"""SetLayerPair(VIA self, PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)"""
        return _pcbnew.VIA_SetLayerPair(self, aTopLayer, aBottomLayer)

    def SetBottomLayer(self, aLayer):
        r"""SetBottomLayer(VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.VIA_SetBottomLayer(self, aLayer)

    def SetTopLayer(self, aLayer):
        r"""SetTopLayer(VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.VIA_SetTopLayer(self, aLayer)

    def LayerPair(self, top_layer, bottom_layer):
        r"""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):
        r"""TopLayer(VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.VIA_TopLayer(self)

    def BottomLayer(self):
        r"""BottomLayer(VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.VIA_BottomLayer(self)

    def SanitizeLayers(self):
        r"""SanitizeLayers(VIA self)"""
        return _pcbnew.VIA_SanitizeLayers(self)

    def GetPosition(self):
        r"""GetPosition(VIA self) -> wxPoint"""
        return _pcbnew.VIA_GetPosition(self)

    def SetPosition(self, aPoint):
        r"""SetPosition(VIA self, wxPoint aPoint)"""
        return _pcbnew.VIA_SetPosition(self, aPoint)

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

    def GetClass(self):
        r"""GetClass(VIA self) -> wxString"""
        return _pcbnew.VIA_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(VIA self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.VIA_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(VIA self) -> BITMAP_DEF"""
        return _pcbnew.VIA_GetMenuImage(self)

    def Clone(self):
        r"""Clone(VIA self) -> EDA_ITEM"""
        return _pcbnew.VIA_Clone(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(VIA self, int [] aLayers, int & aCount)"""
        return _pcbnew.VIA_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(VIA self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.VIA_ViewGetLOD(self, aLayer, aView)

    def Flip(self, aCentre):
        r"""Flip(VIA self, wxPoint aCentre)"""
        return _pcbnew.VIA_Flip(self, aCentre)

    def GetViaType(self):
        r"""GetViaType(VIA self) -> VIATYPE_T"""
        return _pcbnew.VIA_GetViaType(self)

    def SetViaType(self, aViaType):
        r"""SetViaType(VIA self, VIATYPE_T aViaType)"""
        return _pcbnew.VIA_SetViaType(self, aViaType)

    def SetDrill(self, aDrill):
        r"""SetDrill(VIA self, int aDrill)"""
        return _pcbnew.VIA_SetDrill(self, aDrill)

    def GetDrill(self):
        r"""GetDrill(VIA self) -> int"""
        return _pcbnew.VIA_GetDrill(self)

    def GetDrillValue(self):
        r"""GetDrillValue(VIA self) -> int"""
        return _pcbnew.VIA_GetDrillValue(self)

    def SetDrillDefault(self):
        r"""SetDrillDefault(VIA self)"""
        return _pcbnew.VIA_SetDrillDefault(self)

    def IsDrillDefault(self):
        r"""IsDrillDefault(VIA self) -> bool"""
        return _pcbnew.VIA_IsDrillDefault(self)

    def SwapData(self, aImage):
        r"""SwapData(VIA self, BOARD_ITEM aImage)"""
        return _pcbnew.VIA_SwapData(self, aImage)
    __swig_destroy__ = _pcbnew.delete_VIA

# Register VIA in _pcbnew:
_pcbnew.VIA_swigregister(VIA)

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


def GetFirstVia(aTrk, aStopPoint=None):
    r"""GetFirstVia(TRACK aTrk, TRACK aStopPoint=None) -> VIA"""
    return _pcbnew.GetFirstVia(aTrk, aStopPoint)

def GetFirstTrack(aTrk, aStopPoint=None):
    r"""GetFirstTrack(TRACK aTrk, TRACK aStopPoint=None) -> TRACK"""
    return _pcbnew.GetFirstTrack(aTrk, aStopPoint)
class TRACK_List(DHEAD):
    r"""Proxy of C++ DLIST< TRACK > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def Get(self):
        r"""Get(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Get(self)

    def __deref__(self):
        r"""__deref__(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List___deref__(self)

    def GetFirst(self):
        r"""GetFirst(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_GetFirst(self)

    def GetLast(self):
        r"""GetLast(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_GetLast(self)

    def Append(self, *args):
        r"""
        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):
        r"""Insert(TRACK_List self, TRACK aNewElement, TRACK aElementAfterMe)"""
        return _pcbnew.TRACK_List_Insert(self, aNewElement, aElementAfterMe)

    def Remove(self, aElement):
        r"""Remove(TRACK_List self, TRACK aElement) -> TRACK"""
        return _pcbnew.TRACK_List_Remove(self, aElement)

    def begin(self):
        r"""begin(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_begin(self)

    def end(self):
        r"""end(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_end(self)

    def PopFront(self):
        r"""PopFront(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_PopFront(self)

    def PopBack(self):
        r"""PopBack(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_PopBack(self)

    def PushFront(self, aNewElement):
        r"""PushFront(TRACK_List self, TRACK aNewElement)"""
        return _pcbnew.TRACK_List_PushFront(self, aNewElement)

    def PushBack(self, aNewElement):
        r"""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):
        r"""__init__(TRACK_List self) -> TRACK_List"""
        _pcbnew.TRACK_List_swiginit(self, _pcbnew.new_TRACK_List())
    __swig_destroy__ = _pcbnew.delete_TRACK_List

    def ClassOf(self, aItem):
        r"""ClassOf(TRACK_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_List_ClassOf(self, aItem)
    start = property(_pcbnew.TRACK_List_start_get, _pcbnew.TRACK_List_start_set, doc=r"""start : p.BOARD_CONNECTED_ITEM""")
    end = property(_pcbnew.TRACK_List_end_get, _pcbnew.TRACK_List_end_set, doc=r"""end : p.BOARD_CONNECTED_ITEM""")
    m_Param = property(_pcbnew.TRACK_List_m_Param_get, _pcbnew.TRACK_List_m_Param_set, doc=r"""m_Param : double""")

    def Next(self):
        r"""Next(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Next(self)

    def Back(self):
        r"""Back(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Back(self)

    def Move(self, aMoveVector):
        r"""Move(TRACK_List self, wxPoint aMoveVector)"""
        return _pcbnew.TRACK_List_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(TRACK_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TRACK_List_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(TRACK_List self, wxPoint aCentre)"""
        return _pcbnew.TRACK_List_Flip(self, aCentre)

    def SetPosition(self, aPos):
        r"""SetPosition(TRACK_List self, wxPoint aPos)"""
        return _pcbnew.TRACK_List_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetPosition(self)

    def SetWidth(self, aWidth):
        r"""SetWidth(TRACK_List self, int aWidth)"""
        return _pcbnew.TRACK_List_SetWidth(self, aWidth)

    def GetWidth(self):
        r"""GetWidth(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetWidth(self)

    def SetEnd(self, aEnd):
        r"""SetEnd(TRACK_List self, wxPoint aEnd)"""
        return _pcbnew.TRACK_List_SetEnd(self, aEnd)

    def GetEnd(self):
        r"""GetEnd(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetEnd(self)

    def SetStart(self, aStart):
        r"""SetStart(TRACK_List self, wxPoint aStart)"""
        return _pcbnew.TRACK_List_SetStart(self, aStart)

    def GetStart(self):
        r"""GetStart(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetStart(self)

    def GetEndPoint(self, aEndPoint):
        r"""GetEndPoint(TRACK_List self, ENDPOINT_T aEndPoint) -> wxPoint"""
        return _pcbnew.TRACK_List_GetEndPoint(self, aEndPoint)

    def GetBoundingBox(self):
        r"""GetBoundingBox(TRACK_List self) -> EDA_RECT"""
        return _pcbnew.TRACK_List_GetBoundingBox(self)

    def IsLocked(self):
        r"""IsLocked(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsLocked(self)

    def SetLocked(self, aLocked):
        r"""SetLocked(TRACK_List self, bool aLocked)"""
        return _pcbnew.TRACK_List_SetLocked(self, aLocked)

    def GetBestInsertPoint(self, aPcb):
        r"""GetBestInsertPoint(TRACK_List self, BOARD aPcb) -> TRACK"""
        return _pcbnew.TRACK_List_GetBestInsertPoint(self, aPcb)

    def GetStartNetCode(self, NetCode):
        r"""GetStartNetCode(TRACK_List self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_List_GetStartNetCode(self, NetCode)

    def GetEndNetCode(self, NetCode):
        r"""GetEndNetCode(TRACK_List self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_List_GetEndNetCode(self, NetCode)

    def GetLength(self):
        r"""GetLength(TRACK_List self) -> double"""
        return _pcbnew.TRACK_List_GetLength(self)

    def Draw(self, *args):
        r"""Draw(TRACK_List self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.TRACK_List_Draw(self, *args)

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

    def IsPointOnEnds(self, point, min_dist=0):
        r"""IsPointOnEnds(TRACK_List self, wxPoint point, int min_dist=0) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_IsPointOnEnds(self, point, min_dist)

    def IsNull(self):
        r"""IsNull(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsNull(self)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""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):
        r"""
        HitTest(TRACK_List self, wxPoint aPosition) -> bool
        HitTest(TRACK_List self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.TRACK_List_HitTest(self, *args)

    def GetVia(self, *args):
        r"""
        GetVia(TRACK_List self, wxPoint aPosition, PCB_LAYER_ID aLayer=UNDEFINED_LAYER) -> 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):
        r"""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):
        r"""GetEndSegments(TRACK_List self, int NbSegm, TRACK ** StartTrack, TRACK ** EndTrack) -> int"""
        return _pcbnew.TRACK_List_GetEndSegments(self, NbSegm, StartTrack, EndTrack)

    def GetClass(self):
        r"""GetClass(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetClass(self)

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

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(TRACK_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TRACK_List_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(TRACK_List self) -> BITMAP_DEF"""
        return _pcbnew.TRACK_List_GetMenuImage(self)

    def Clone(self):
        r"""Clone(TRACK_List self) -> EDA_ITEM"""
        return _pcbnew.TRACK_List_Clone(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(TRACK_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.TRACK_List_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(TRACK_List self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.TRACK_List_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self):
        r"""ViewBBox(TRACK_List self) -> BOX2I const"""
        return _pcbnew.TRACK_List_ViewBBox(self)

    def SwapData(self, aImage):
        r"""SwapData(TRACK_List self, BOARD_ITEM aImage)"""
        return _pcbnew.TRACK_List_SwapData(self, aImage)

    def IsConnected(self):
        r"""IsConnected(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsConnected(self)

    def GetNet(self):
        r"""GetNet(TRACK_List self) -> NETINFO_ITEM"""
        return _pcbnew.TRACK_List_GetNet(self)

    def SetNet(self, aNetInfo):
        r"""SetNet(TRACK_List self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.TRACK_List_SetNet(self, aNetInfo)

    def GetNetCode(self):
        r"""GetNetCode(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetNetCode(self)

    def SetNetCode(self, aNetCode, aNoAssert=False):
        r"""SetNetCode(TRACK_List self, int aNetCode, bool aNoAssert=False) -> bool"""
        return _pcbnew.TRACK_List_SetNetCode(self, aNetCode, aNoAssert)

    def GetNetname(self):
        r"""GetNetname(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetname(self)

    def GetNetnameMsg(self):
        r"""GetNetnameMsg(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetnameMsg(self)

    def GetShortNetname(self):
        r"""GetShortNetname(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetShortNetname(self)

    def GetNetClass(self):
        r"""GetNetClass(TRACK_List self) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.TRACK_List_GetNetClass(self)

    def GetNetClassName(self):
        r"""GetNetClassName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetClassName(self)

    def SetLocalRatsnestVisible(self, aVisible):
        r"""SetLocalRatsnestVisible(TRACK_List self, bool aVisible)"""
        return _pcbnew.TRACK_List_SetLocalRatsnestVisible(self, aVisible)

    def GetLocalRatsnestVisible(self):
        r"""GetLocalRatsnestVisible(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_GetLocalRatsnestVisible(self)

    def GetCenter(self):
        r"""GetCenter(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetCenter(self)

    def GetParent(self):
        r"""GetParent(TRACK_List self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.TRACK_List_GetParent(self)

    def GetLayer(self):
        r"""GetLayer(TRACK_List self) -> PCB_LAYER_ID"""
        return _pcbnew.TRACK_List_GetLayer(self)

    def GetLayerSet(self):
        r"""GetLayerSet(TRACK_List self) -> LSET"""
        return _pcbnew.TRACK_List_GetLayerSet(self)

    def SetLayer(self, aLayer):
        r"""SetLayer(TRACK_List self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.TRACK_List_SetLayer(self, aLayer)

    def IsOnLayer(self, aLayer):
        r"""IsOnLayer(TRACK_List self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.TRACK_List_IsOnLayer(self, aLayer)

    def IsTrack(self):
        r"""IsTrack(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsTrack(self)

    def UnLink(self):
        r"""UnLink(TRACK_List self)"""
        return _pcbnew.TRACK_List_UnLink(self)

    def DeleteStructure(self):
        r"""DeleteStructure(TRACK_List self)"""
        return _pcbnew.TRACK_List_DeleteStructure(self)

    def ShowShape(self, aShape):
        r"""ShowShape(TRACK_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.TRACK_List_ShowShape(self, aShape)

    def GetBoard(self):
        r"""GetBoard(TRACK_List self) -> BOARD"""
        return _pcbnew.TRACK_List_GetBoard(self)

    def GetLayerName(self):
        r"""GetLayerName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetLayerName(self)

    def Type(self):
        r"""Type(TRACK_List self) -> KICAD_T"""
        return _pcbnew.TRACK_List_Type(self)

    def SetTimeStamp(self, aNewTimeStamp):
        r"""SetTimeStamp(TRACK_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.TRACK_List_SetTimeStamp(self, aNewTimeStamp)

    def GetTimeStamp(self):
        r"""GetTimeStamp(TRACK_List self) -> timestamp_t"""
        return _pcbnew.TRACK_List_GetTimeStamp(self)

    def GetList(self):
        r"""GetList(TRACK_List self) -> DHEAD"""
        return _pcbnew.TRACK_List_GetList(self)

    def SetParent(self, aParent):
        r"""SetParent(TRACK_List self, EDA_ITEM aParent)"""
        return _pcbnew.TRACK_List_SetParent(self, aParent)

    def SetList(self, aList):
        r"""SetList(TRACK_List self, DHEAD aList)"""
        return _pcbnew.TRACK_List_SetList(self, aList)

    def IsNew(self):
        r"""IsNew(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsNew(self)

    def IsModified(self):
        r"""IsModified(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsModified(self)

    def IsMoving(self):
        r"""IsMoving(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsMoving(self)

    def IsDragging(self):
        r"""IsDragging(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsDragging(self)

    def IsWireImage(self):
        r"""IsWireImage(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsWireImage(self)

    def IsSelected(self):
        r"""IsSelected(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsSelected(self)

    def IsResized(self):
        r"""IsResized(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsResized(self)

    def IsHighlighted(self):
        r"""IsHighlighted(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsHighlighted(self)

    def IsBrightened(self):
        r"""IsBrightened(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsBrightened(self)

    def SetWireImage(self):
        r"""SetWireImage(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetWireImage(self)

    def SetSelected(self):
        r"""SetSelected(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetSelected(self)

    def SetHighlighted(self):
        r"""SetHighlighted(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetHighlighted(self)

    def SetBrightened(self):
        r"""SetBrightened(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetBrightened(self)

    def ClearSelected(self):
        r"""ClearSelected(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearSelected(self)

    def ClearHighlighted(self):
        r"""ClearHighlighted(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearHighlighted(self)

    def ClearBrightened(self):
        r"""ClearBrightened(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearBrightened(self)

    def SetModified(self):
        r"""SetModified(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetModified(self)

    def GetState(self, type):
        r"""GetState(TRACK_List self, int type) -> int"""
        return _pcbnew.TRACK_List_GetState(self, type)

    def SetState(self, type, state):
        r"""SetState(TRACK_List self, int type, int state)"""
        return _pcbnew.TRACK_List_SetState(self, type, state)

    def GetStatus(self):
        r"""GetStatus(TRACK_List self) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_GetStatus(self)

    def SetStatus(self, aStatus):
        r"""SetStatus(TRACK_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.TRACK_List_SetStatus(self, aStatus)

    def SetFlags(self, aMask):
        r"""SetFlags(TRACK_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.TRACK_List_SetFlags(self, aMask)

    def ClearFlags(self, aMask=-1):
        r"""ClearFlags(TRACK_List self, STATUS_FLAGS aMask=-1)"""
        return _pcbnew.TRACK_List_ClearFlags(self, aMask)

    def GetFlags(self):
        r"""GetFlags(TRACK_List self) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_GetFlags(self)

    def IsType(self, aScanTypes):
        r"""IsType(TRACK_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.TRACK_List_IsType(self, aScanTypes)

    def SetForceVisible(self, aEnable):
        r"""SetForceVisible(TRACK_List self, bool aEnable)"""
        return _pcbnew.TRACK_List_SetForceVisible(self, aEnable)

    def IterateForward(self, listStart, inspector, testData, scanTypes):
        r"""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):
        r"""Matches(TRACK_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.TRACK_List_Matches(self, aSearchData, aAuxData, aFindLocation)

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

    def IsReplaceable(self):
        r"""IsReplaceable(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsReplaceable(self)

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

    def Sort(self, aLeft, aRight):
        r"""Sort(TRACK_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.TRACK_List_Sort(self, aLeft, aRight)

# Register TRACK_List in _pcbnew:
_pcbnew.TRACK_List_swigregister(TRACK_List)

class ZONE_CONTAINER(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ ZONE_CONTAINER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        r"""
        __init__(ZONE_CONTAINER self, BOARD parent) -> ZONE_CONTAINER
        __init__(ZONE_CONTAINER self, ZONE_CONTAINER aZone) -> ZONE_CONTAINER
        """
        _pcbnew.ZONE_CONTAINER_swiginit(self, _pcbnew.new_ZONE_CONTAINER(*args))
    __swig_destroy__ = _pcbnew.delete_ZONE_CONTAINER

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.ZONE_CONTAINER_ClassOf(aItem)

    def GetPosition(self):
        r"""GetPosition(ZONE_CONTAINER self) -> wxPoint"""
        return _pcbnew.ZONE_CONTAINER_GetPosition(self)

    def SetPosition(self, aPos):
        r"""SetPosition(ZONE_CONTAINER self, wxPoint aPos)"""
        return _pcbnew.ZONE_CONTAINER_SetPosition(self, aPos)

    def SetPriority(self, aPriority):
        r"""SetPriority(ZONE_CONTAINER self, unsigned int aPriority)"""
        return _pcbnew.ZONE_CONTAINER_SetPriority(self, aPriority)

    def GetPriority(self):
        r"""GetPriority(ZONE_CONTAINER self) -> unsigned int"""
        return _pcbnew.ZONE_CONTAINER_GetPriority(self)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""SetLayerSet(ZONE_CONTAINER self, LSET aLayerSet)"""
        return _pcbnew.ZONE_CONTAINER_SetLayerSet(self, aLayerSet)

    def GetLayerSet(self):
        r"""GetLayerSet(ZONE_CONTAINER self) -> LSET"""
        return _pcbnew.ZONE_CONTAINER_GetLayerSet(self)

    def Draw(self, *args):
        r"""Draw(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset=)"""
        return _pcbnew.ZONE_CONTAINER_Draw(self, *args)

    def DrawFilledArea(self, *args):
        r"""DrawFilledArea(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset=)"""
        return _pcbnew.ZONE_CONTAINER_DrawFilledArea(self, *args)

    def DrawWhileCreateOutline(self, *args):
        r"""DrawWhileCreateOutline(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE draw_mode=GR_OR)"""
        return _pcbnew.ZONE_CONTAINER_DrawWhileCreateOutline(self, *args)

    def GetBoundingBox(self):
        r"""GetBoundingBox(ZONE_CONTAINER self) -> EDA_RECT"""
        return _pcbnew.ZONE_CONTAINER_GetBoundingBox(self)

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

    def IsOnCopperLayer(self):
        r"""IsOnCopperLayer(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsOnCopperLayer(self)

    def CommonLayerExists(self, aLayerSet):
        r"""CommonLayerExists(ZONE_CONTAINER self, LSET aLayerSet) -> bool"""
        return _pcbnew.ZONE_CONTAINER_CommonLayerExists(self, aLayerSet)

    def SetLayer(self, aLayer):
        r"""SetLayer(ZONE_CONTAINER self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.ZONE_CONTAINER_SetLayer(self, aLayer)

    def GetLayer(self):
        r"""GetLayer(ZONE_CONTAINER self) -> PCB_LAYER_ID"""
        return _pcbnew.ZONE_CONTAINER_GetLayer(self)

    def IsOnLayer(self, arg2):
        r"""IsOnLayer(ZONE_CONTAINER self, PCB_LAYER_ID arg2) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsOnLayer(self, arg2)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(ZONE_CONTAINER self, int [] aLayers, int & aCount)"""
        return _pcbnew.ZONE_CONTAINER_ViewGetLayers(self, aLayers, aCount)

    def SetFillMode(self, aFillMode):
        r"""SetFillMode(ZONE_CONTAINER self, ZONE_FILL_MODE aFillMode)"""
        return _pcbnew.ZONE_CONTAINER_SetFillMode(self, aFillMode)

    def GetFillMode(self):
        r"""GetFillMode(ZONE_CONTAINER self) -> ZONE_FILL_MODE"""
        return _pcbnew.ZONE_CONTAINER_GetFillMode(self)

    def SetThermalReliefGap(self, aThermalReliefGap):
        r"""SetThermalReliefGap(ZONE_CONTAINER self, int aThermalReliefGap)"""
        return _pcbnew.ZONE_CONTAINER_SetThermalReliefGap(self, aThermalReliefGap)

    def GetThermalReliefGap(self, aPad=None):
        r"""GetThermalReliefGap(ZONE_CONTAINER self, D_PAD aPad=None) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetThermalReliefGap(self, aPad)

    def SetThermalReliefCopperBridge(self, aThermalReliefCopperBridge):
        r"""SetThermalReliefCopperBridge(ZONE_CONTAINER self, int aThermalReliefCopperBridge)"""
        return _pcbnew.ZONE_CONTAINER_SetThermalReliefCopperBridge(self, aThermalReliefCopperBridge)

    def GetThermalReliefCopperBridge(self, aPad=None):
        r"""GetThermalReliefCopperBridge(ZONE_CONTAINER self, D_PAD aPad=None) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetThermalReliefCopperBridge(self, aPad)

    def SetArcSegmentCount(self, aArcSegCount):
        r"""SetArcSegmentCount(ZONE_CONTAINER self, int aArcSegCount)"""
        return _pcbnew.ZONE_CONTAINER_SetArcSegmentCount(self, aArcSegCount)

    def GetArcSegmentCount(self):
        r"""GetArcSegmentCount(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetArcSegmentCount(self)

    def IsFilled(self):
        r"""IsFilled(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsFilled(self)

    def SetIsFilled(self, isFilled):
        r"""SetIsFilled(ZONE_CONTAINER self, bool isFilled)"""
        return _pcbnew.ZONE_CONTAINER_SetIsFilled(self, isFilled)

    def GetZoneClearance(self):
        r"""GetZoneClearance(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetZoneClearance(self)

    def SetZoneClearance(self, aZoneClearance):
        r"""SetZoneClearance(ZONE_CONTAINER self, int aZoneClearance)"""
        return _pcbnew.ZONE_CONTAINER_SetZoneClearance(self, aZoneClearance)

    def GetPadConnection(self, aPad=None):
        r"""GetPadConnection(ZONE_CONTAINER self, D_PAD aPad=None) -> ZoneConnection"""
        return _pcbnew.ZONE_CONTAINER_GetPadConnection(self, aPad)

    def SetPadConnection(self, aPadConnection):
        r"""SetPadConnection(ZONE_CONTAINER self, ZoneConnection aPadConnection)"""
        return _pcbnew.ZONE_CONTAINER_SetPadConnection(self, aPadConnection)

    def GetMinThickness(self):
        r"""GetMinThickness(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetMinThickness(self)

    def SetMinThickness(self, aMinThickness):
        r"""SetMinThickness(ZONE_CONTAINER self, int aMinThickness)"""
        return _pcbnew.ZONE_CONTAINER_SetMinThickness(self, aMinThickness)

    def GetSelectedCorner(self):
        r"""GetSelectedCorner(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetSelectedCorner(self)

    def SetSelectedCorner(self, *args):
        r"""
        SetSelectedCorner(ZONE_CONTAINER self, int aCorner)
        SetSelectedCorner(ZONE_CONTAINER self, wxPoint aPosition, int aAccuracy)
        """
        return _pcbnew.ZONE_CONTAINER_SetSelectedCorner(self, *args)

    def GetLocalFlags(self):
        r"""GetLocalFlags(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetLocalFlags(self)

    def SetLocalFlags(self, aFlags):
        r"""SetLocalFlags(ZONE_CONTAINER self, int aFlags)"""
        return _pcbnew.ZONE_CONTAINER_SetLocalFlags(self, aFlags)

    def FillSegments(self, *args):
        r"""
        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):
        r"""
        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):
        r"""SetOutline(ZONE_CONTAINER self, SHAPE_POLY_SET aOutline)"""
        return _pcbnew.ZONE_CONTAINER_SetOutline(self, aOutline)

    def HitTestInsideZone(self, aPosition):
        r"""HitTestInsideZone(ZONE_CONTAINER self, wxPoint aPosition) -> bool"""
        return _pcbnew.ZONE_CONTAINER_HitTestInsideZone(self, aPosition)

    def HitTestFilledArea(self, aRefPos):
        r"""HitTestFilledArea(ZONE_CONTAINER self, wxPoint aRefPos) -> bool"""
        return _pcbnew.ZONE_CONTAINER_HitTestFilledArea(self, aRefPos)

    def TransformSolidAreasShapesToPolygonSet(self, aCornerBuffer, aCircleToSegmentsCount, aCorrectionFactor):
        r"""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):
        r"""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):
        r"""TransformShapeWithClearanceToPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=False)"""
        return _pcbnew.ZONE_CONTAINER_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor, ignoreLineWidth)

    def HitTestForCorner(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        HitTest(ZONE_CONTAINER self, wxPoint aPosition) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_HitTest(self, *args)

    def UnFill(self):
        r"""UnFill(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_UnFill(self)

    def Move(self, offset):
        r"""Move(ZONE_CONTAINER self, wxPoint offset)"""
        return _pcbnew.ZONE_CONTAINER_Move(self, offset)

    def MoveEdge(self, offset, aEdge):
        r"""MoveEdge(ZONE_CONTAINER self, wxPoint offset, int aEdge)"""
        return _pcbnew.ZONE_CONTAINER_MoveEdge(self, offset, aEdge)

    def Rotate(self, centre, angle):
        r"""Rotate(ZONE_CONTAINER self, wxPoint centre, double angle)"""
        return _pcbnew.ZONE_CONTAINER_Rotate(self, centre, angle)

    def Flip(self, aCentre):
        r"""Flip(ZONE_CONTAINER self, wxPoint aCentre)"""
        return _pcbnew.ZONE_CONTAINER_Flip(self, aCentre)

    def Mirror(self, mirror_ref):
        r"""Mirror(ZONE_CONTAINER self, wxPoint mirror_ref)"""
        return _pcbnew.ZONE_CONTAINER_Mirror(self, mirror_ref)

    def GetClass(self):
        r"""GetClass(ZONE_CONTAINER self) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetClass(self)

    def GetNumCorners(self):
        r"""GetNumCorners(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetNumCorners(self)

    def Iterate(self):
        r"""Iterate(ZONE_CONTAINER self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_CONTAINER_Iterate(self)

    def IterateWithHoles(self):
        r"""IterateWithHoles(ZONE_CONTAINER self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_CONTAINER_IterateWithHoles(self)

    def CIterateWithHoles(self):
        r"""CIterateWithHoles(ZONE_CONTAINER self) -> SHAPE_POLY_SET::CONST_ITERATOR"""
        return _pcbnew.ZONE_CONTAINER_CIterateWithHoles(self)

    def RemoveAllContours(self):
        r"""RemoveAllContours(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_RemoveAllContours(self)

    def GetCornerPosition(self, aCornerIndex):
        r"""GetCornerPosition(ZONE_CONTAINER self, int aCornerIndex) -> VECTOR2I"""
        return _pcbnew.ZONE_CONTAINER_GetCornerPosition(self, aCornerIndex)

    def SetCornerPosition(self, aCornerIndex, new_pos):
        r"""SetCornerPosition(ZONE_CONTAINER self, int aCornerIndex, wxPoint new_pos)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerPosition(self, aCornerIndex, new_pos)

    def NewHole(self):
        r"""NewHole(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_NewHole(self)

    def AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication=False):
        r"""AppendCorner(ZONE_CONTAINER self, wxPoint aPosition, int aHoleIdx, bool aAllowDuplication=False) -> bool"""
        return _pcbnew.ZONE_CONTAINER_AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication)

    def GetHatchStyle(self):
        r"""GetHatchStyle(ZONE_CONTAINER self) -> ZONE_CONTAINER::HATCH_STYLE"""
        return _pcbnew.ZONE_CONTAINER_GetHatchStyle(self)

    def SetHatchStyle(self, aStyle):
        r"""SetHatchStyle(ZONE_CONTAINER self, ZONE_CONTAINER::HATCH_STYLE aStyle)"""
        return _pcbnew.ZONE_CONTAINER_SetHatchStyle(self, aStyle)

    def IsSame(self, aZoneToCompare):
        r"""IsSame(ZONE_CONTAINER self, ZONE_CONTAINER aZoneToCompare) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsSame(self, aZoneToCompare)

    def ClearFilledPolysList(self):
        r"""ClearFilledPolysList(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_ClearFilledPolysList(self)

    def GetFilledPolysList(self):
        r"""GetFilledPolysList(ZONE_CONTAINER self) -> SHAPE_POLY_SET"""
        return _pcbnew.ZONE_CONTAINER_GetFilledPolysList(self)

    def CacheTriangulation(self):
        r"""CacheTriangulation(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_CacheTriangulation(self)

    def SetFilledPolysList(self, aPolysList):
        r"""SetFilledPolysList(ZONE_CONTAINER self, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_CONTAINER_SetFilledPolysList(self, aPolysList)

    def SetRawPolysList(self, aPolysList):
        r"""SetRawPolysList(ZONE_CONTAINER self, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_CONTAINER_SetRawPolysList(self, aPolysList)

    def BuildSmoothedPoly(self, aSmoothedPoly):
        r"""BuildSmoothedPoly(ZONE_CONTAINER self, SHAPE_POLY_SET aSmoothedPoly) -> bool"""
        return _pcbnew.ZONE_CONTAINER_BuildSmoothedPoly(self, aSmoothedPoly)

    def SetCornerSmoothingType(self, aType):
        r"""SetCornerSmoothingType(ZONE_CONTAINER self, int aType)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerSmoothingType(self, aType)

    def GetCornerSmoothingType(self):
        r"""GetCornerSmoothingType(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetCornerSmoothingType(self)

    def SetCornerRadius(self, aRadius):
        r"""SetCornerRadius(ZONE_CONTAINER self, unsigned int aRadius)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerRadius(self, aRadius)

    def GetCornerRadius(self):
        r"""GetCornerRadius(ZONE_CONTAINER self) -> unsigned int"""
        return _pcbnew.ZONE_CONTAINER_GetCornerRadius(self)

    def AddPolygon(self, *args):
        r"""
        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):
        r"""SetFillSegments(ZONE_CONTAINER self, ZONE_SEGMENT_FILL const & aSegments)"""
        return _pcbnew.ZONE_CONTAINER_SetFillSegments(self, aSegments)

    def RawPolysList(self):
        r"""RawPolysList(ZONE_CONTAINER self) -> SHAPE_POLY_SET"""
        return _pcbnew.ZONE_CONTAINER_RawPolysList(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(ZONE_CONTAINER self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(ZONE_CONTAINER self) -> BITMAP_DEF"""
        return _pcbnew.ZONE_CONTAINER_GetMenuImage(self)

    def Clone(self):
        r"""Clone(ZONE_CONTAINER self) -> EDA_ITEM"""
        return _pcbnew.ZONE_CONTAINER_Clone(self)

    def GetIsKeepout(self):
        r"""GetIsKeepout(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetIsKeepout(self)

    def GetDoNotAllowCopperPour(self):
        r"""GetDoNotAllowCopperPour(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowCopperPour(self)

    def GetDoNotAllowVias(self):
        r"""GetDoNotAllowVias(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowVias(self)

    def GetDoNotAllowTracks(self):
        r"""GetDoNotAllowTracks(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowTracks(self)

    def SetIsKeepout(self, aEnable):
        r"""SetIsKeepout(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetIsKeepout(self, aEnable)

    def SetDoNotAllowCopperPour(self, aEnable):
        r"""SetDoNotAllowCopperPour(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowCopperPour(self, aEnable)

    def SetDoNotAllowVias(self, aEnable):
        r"""SetDoNotAllowVias(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowVias(self, aEnable)

    def SetDoNotAllowTracks(self, aEnable):
        r"""SetDoNotAllowTracks(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowTracks(self, aEnable)

    def GetHatchPitch(self):
        r"""GetHatchPitch(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetHatchPitch(self)

    @staticmethod
    def GetDefaultHatchPitch():
        r"""GetDefaultHatchPitch() -> int"""
        return _pcbnew.ZONE_CONTAINER_GetDefaultHatchPitch()

    def SetHatch(self, aHatchStyle, aHatchPitch, aRebuildHatch):
        r"""SetHatch(ZONE_CONTAINER self, int aHatchStyle, int aHatchPitch, bool aRebuildHatch)"""
        return _pcbnew.ZONE_CONTAINER_SetHatch(self, aHatchStyle, aHatchPitch, aRebuildHatch)

    def SetHatchPitch(self, aPitch):
        r"""SetHatchPitch(ZONE_CONTAINER self, int aPitch)"""
        return _pcbnew.ZONE_CONTAINER_SetHatchPitch(self, aPitch)

    def UnHatch(self):
        r"""UnHatch(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_UnHatch(self)

    def Hatch(self):
        r"""Hatch(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_Hatch(self)

    def GetHatchLines(self):
        r"""GetHatchLines(ZONE_CONTAINER self) -> std::vector< SEG,std::allocator< SEG > > const &"""
        return _pcbnew.ZONE_CONTAINER_GetHatchLines(self)

    def GetHV45(self):
        r"""GetHV45(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetHV45(self)

    def SetHV45(self, aConstrain):
        r"""SetHV45(ZONE_CONTAINER self, bool aConstrain)"""
        return _pcbnew.ZONE_CONTAINER_SetHV45(self, aConstrain)

    def GetHashValue(self):
        r"""GetHashValue(ZONE_CONTAINER self) -> MD5_HASH"""
        return _pcbnew.ZONE_CONTAINER_GetHashValue(self)

    def BuildHashValue(self):
        r"""BuildHashValue(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_BuildHashValue(self)

    def SwapData(self, aImage):
        r"""SwapData(ZONE_CONTAINER self, BOARD_ITEM aImage)"""
        return _pcbnew.ZONE_CONTAINER_SwapData(self, aImage)

# Register ZONE_CONTAINER in _pcbnew:
_pcbnew.ZONE_CONTAINER_swigregister(ZONE_CONTAINER)

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

def ZONE_CONTAINER_GetDefaultHatchPitch():
    r"""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):
    r"""InvokeNonCopperZonesEditor(PCB_BASE_FRAME * aParent, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeNonCopperZonesEditor(aParent, aSettings)

def InvokeCopperZonesEditor(aCaller, aSettings):
    r"""InvokeCopperZonesEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeCopperZonesEditor(aCaller, aSettings)

def InvokeKeepoutAreaEditor(aCaller, aSettings):
    r"""InvokeKeepoutAreaEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeKeepoutAreaEditor(aCaller, aSettings)
class ZONE_FILLER(object):
    r"""Proxy of C++ ZONE_FILLER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aBoard, aCommit=None):
        r"""__init__(ZONE_FILLER self, BOARD aBoard, COMMIT * aCommit=None) -> ZONE_FILLER"""
        _pcbnew.ZONE_FILLER_swiginit(self, _pcbnew.new_ZONE_FILLER(aBoard, aCommit))
    __swig_destroy__ = _pcbnew.delete_ZONE_FILLER

    def SetProgressReporter(self, *args):
        r"""
        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):
        r"""Fill(ZONE_FILLER self, ZONE_CONTAINERS aZones, bool aCheck=False) -> bool"""
        return _pcbnew.ZONE_FILLER_Fill(self, aZones, aCheck)

# Register ZONE_FILLER in _pcbnew:
_pcbnew.ZONE_FILLER_swigregister(ZONE_FILLER)

ZFM_POLYGONS = _pcbnew.ZFM_POLYGONS

ZFM_SEGMENTS = _pcbnew.ZFM_SEGMENTS

class ZONE_SETTINGS(object):
    r"""Proxy of C++ ZONE_SETTINGS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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
    
    m_FillMode = property(_pcbnew.ZONE_SETTINGS_m_FillMode_get, _pcbnew.ZONE_SETTINGS_m_FillMode_set, doc=r"""m_FillMode : ZONE_FILL_MODE""")
    m_ZonePriority = property(_pcbnew.ZONE_SETTINGS_m_ZonePriority_get, _pcbnew.ZONE_SETTINGS_m_ZonePriority_set, doc=r"""m_ZonePriority : int""")
    m_ZoneClearance = property(_pcbnew.ZONE_SETTINGS_m_ZoneClearance_get, _pcbnew.ZONE_SETTINGS_m_ZoneClearance_set, doc=r"""m_ZoneClearance : int""")
    m_ZoneMinThickness = property(_pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_get, _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_set, doc=r"""m_ZoneMinThickness : int""")
    m_NetcodeSelection = property(_pcbnew.ZONE_SETTINGS_m_NetcodeSelection_get, _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_set, doc=r"""m_NetcodeSelection : int""")
    m_Layers = property(_pcbnew.ZONE_SETTINGS_m_Layers_get, _pcbnew.ZONE_SETTINGS_m_Layers_set, doc=r"""m_Layers : LSET""")
    m_CurrentZone_Layer = property(_pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_get, _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_set, doc=r"""m_CurrentZone_Layer : PCB_LAYER_ID""")
    m_Zone_HatchingStyle = property(_pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_get, _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_set, doc=r"""m_Zone_HatchingStyle : int""")
    m_ArcToSegmentsCount = property(_pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_get, _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_set, doc=r"""m_ArcToSegmentsCount : int""")
    m_ThermalReliefGap = property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set, doc=r"""m_ThermalReliefGap : long""")
    m_ThermalReliefCopperBridge = property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_set, doc=r"""m_ThermalReliefCopperBridge : long""")
    m_Zone_45_Only = property(_pcbnew.ZONE_SETTINGS_m_Zone_45_Only_get, _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_set, doc=r"""m_Zone_45_Only : bool""")

    def __init__(self):
        r"""__init__(ZONE_SETTINGS self) -> ZONE_SETTINGS"""
        _pcbnew.ZONE_SETTINGS_swiginit(self, _pcbnew.new_ZONE_SETTINGS())

    def __lshift__(self, aSource):
        r"""__lshift__(ZONE_SETTINGS self, ZONE_CONTAINER aSource) -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS___lshift__(self, aSource)

    def SetupLayersList(self, aList, aFrame, aShowCopper):
        r"""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):
        r"""ExportSetting(ZONE_SETTINGS self, ZONE_CONTAINER aTarget, bool aFullExport=True)"""
        return _pcbnew.ZONE_SETTINGS_ExportSetting(self, aTarget, aFullExport)

    def SetCornerSmoothingType(self, aType):
        r"""SetCornerSmoothingType(ZONE_SETTINGS self, int aType)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerSmoothingType(self, aType)

    def GetCornerSmoothingType(self):
        r"""GetCornerSmoothingType(ZONE_SETTINGS self) -> int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerSmoothingType(self)

    def SetCornerRadius(self, aRadius):
        r"""SetCornerRadius(ZONE_SETTINGS self, int aRadius)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerRadius(self, aRadius)

    def GetCornerRadius(self):
        r"""GetCornerRadius(ZONE_SETTINGS self) -> unsigned int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerRadius(self)

    def GetPadConnection(self):
        r"""GetPadConnection(ZONE_SETTINGS self) -> ZoneConnection"""
        return _pcbnew.ZONE_SETTINGS_GetPadConnection(self)

    def SetPadConnection(self, aPadConnection):
        r"""SetPadConnection(ZONE_SETTINGS self, ZoneConnection aPadConnection)"""
        return _pcbnew.ZONE_SETTINGS_SetPadConnection(self, aPadConnection)

    def GetIsKeepout(self):
        r"""GetIsKeepout(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetIsKeepout(self)

    def GetDoNotAllowCopperPour(self):
        r"""GetDoNotAllowCopperPour(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowCopperPour(self)

    def GetDoNotAllowVias(self):
        r"""GetDoNotAllowVias(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowVias(self)

    def GetDoNotAllowTracks(self):
        r"""GetDoNotAllowTracks(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowTracks(self)

    def SetIsKeepout(self, aEnable):
        r"""SetIsKeepout(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetIsKeepout(self, aEnable)

    def SetDoNotAllowCopperPour(self, aEnable):
        r"""SetDoNotAllowCopperPour(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowCopperPour(self, aEnable)

    def SetDoNotAllowVias(self, aEnable):
        r"""SetDoNotAllowVias(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowVias(self, aEnable)

    def SetDoNotAllowTracks(self, aEnable):
        r"""SetDoNotAllowTracks(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowTracks(self, aEnable)
    __swig_destroy__ = _pcbnew.delete_ZONE_SETTINGS

# Register ZONE_SETTINGS in _pcbnew:
_pcbnew.ZONE_SETTINGS_swigregister(ZONE_SETTINGS)

class TEXTE_PCB(BOARD_ITEM, EDA_TEXT):
    r"""Proxy of C++ TEXTE_PCB class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, parent):
        r"""__init__(TEXTE_PCB self, BOARD_ITEM parent) -> TEXTE_PCB"""
        _pcbnew.TEXTE_PCB_swiginit(self, _pcbnew.new_TEXTE_PCB(parent))
    __swig_destroy__ = _pcbnew.delete_TEXTE_PCB

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TEXTE_PCB_ClassOf(aItem)

    def GetPosition(self):
        r"""GetPosition(TEXTE_PCB self) -> wxPoint"""
        return _pcbnew.TEXTE_PCB_GetPosition(self)

    def SetPosition(self, aPos):
        r"""SetPosition(TEXTE_PCB self, wxPoint aPos)"""
        return _pcbnew.TEXTE_PCB_SetPosition(self, aPos)

    def Move(self, aMoveVector):
        r"""Move(TEXTE_PCB self, wxPoint aMoveVector)"""
        return _pcbnew.TEXTE_PCB_Move(self, aMoveVector)

    def SetTextAngle(self, aAngle):
        r"""SetTextAngle(TEXTE_PCB self, double aAngle)"""
        return _pcbnew.TEXTE_PCB_SetTextAngle(self, aAngle)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(TEXTE_PCB self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TEXTE_PCB_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(TEXTE_PCB self, wxPoint aCentre)"""
        return _pcbnew.TEXTE_PCB_Flip(self, aCentre)

    def Draw(self, *args):
        r"""Draw(TEXTE_PCB self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset=)"""
        return _pcbnew.TEXTE_PCB_Draw(self, *args)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""
        HitTest(TEXTE_PCB self, wxPoint aPosition) -> bool
        HitTest(TEXTE_PCB self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.TEXTE_PCB_HitTest(self, *args)

    def GetClass(self):
        r"""GetClass(TEXTE_PCB self) -> wxString"""
        return _pcbnew.TEXTE_PCB_GetClass(self)

    def TransformShapeWithClearanceToPolygonSet(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        r"""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):
        r"""GetSelectMenuText(TEXTE_PCB self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TEXTE_PCB_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(TEXTE_PCB self) -> BITMAP_DEF"""
        return _pcbnew.TEXTE_PCB_GetMenuImage(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(TEXTE_PCB self) -> EDA_RECT"""
        return _pcbnew.TEXTE_PCB_GetBoundingBox(self)

    def Clone(self):
        r"""Clone(TEXTE_PCB self) -> EDA_ITEM"""
        return _pcbnew.TEXTE_PCB_Clone(self)

    def SwapData(self, aImage):
        r"""SwapData(TEXTE_PCB self, BOARD_ITEM aImage)"""
        return _pcbnew.TEXTE_PCB_SwapData(self, aImage)

# Register TEXTE_PCB in _pcbnew:
_pcbnew.TEXTE_PCB_swigregister(TEXTE_PCB)

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

class DIMENSION(BOARD_ITEM):
    r"""Proxy of C++ DIMENSION class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_crossBarO = property(_pcbnew.DIMENSION_m_crossBarO_get, _pcbnew.DIMENSION_m_crossBarO_set, doc=r"""m_crossBarO : wxPoint""")
    m_crossBarF = property(_pcbnew.DIMENSION_m_crossBarF_get, _pcbnew.DIMENSION_m_crossBarF_set, doc=r"""m_crossBarF : wxPoint""")
    m_featureLineGO = property(_pcbnew.DIMENSION_m_featureLineGO_get, _pcbnew.DIMENSION_m_featureLineGO_set, doc=r"""m_featureLineGO : wxPoint""")
    m_featureLineGF = property(_pcbnew.DIMENSION_m_featureLineGF_get, _pcbnew.DIMENSION_m_featureLineGF_set, doc=r"""m_featureLineGF : wxPoint""")
    m_featureLineDO = property(_pcbnew.DIMENSION_m_featureLineDO_get, _pcbnew.DIMENSION_m_featureLineDO_set, doc=r"""m_featureLineDO : wxPoint""")
    m_featureLineDF = property(_pcbnew.DIMENSION_m_featureLineDF_get, _pcbnew.DIMENSION_m_featureLineDF_set, doc=r"""m_featureLineDF : wxPoint""")
    m_arrowD1F = property(_pcbnew.DIMENSION_m_arrowD1F_get, _pcbnew.DIMENSION_m_arrowD1F_set, doc=r"""m_arrowD1F : wxPoint""")
    m_arrowD2F = property(_pcbnew.DIMENSION_m_arrowD2F_get, _pcbnew.DIMENSION_m_arrowD2F_set, doc=r"""m_arrowD2F : wxPoint""")
    m_arrowG1F = property(_pcbnew.DIMENSION_m_arrowG1F_get, _pcbnew.DIMENSION_m_arrowG1F_set, doc=r"""m_arrowG1F : wxPoint""")
    m_arrowG2F = property(_pcbnew.DIMENSION_m_arrowG2F_get, _pcbnew.DIMENSION_m_arrowG2F_set, doc=r"""m_arrowG2F : wxPoint""")

    def __init__(self, aParent):
        r"""__init__(DIMENSION self, BOARD_ITEM aParent) -> DIMENSION"""
        _pcbnew.DIMENSION_swiginit(self, _pcbnew.new_DIMENSION(aParent))
    __swig_destroy__ = _pcbnew.delete_DIMENSION

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.DIMENSION_ClassOf(aItem)

    def SetValue(self, aValue):
        r"""SetValue(DIMENSION self, int aValue)"""
        return _pcbnew.DIMENSION_SetValue(self, aValue)

    def GetValue(self):
        r"""GetValue(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetValue(self)

    def GetPosition(self):
        r"""GetPosition(DIMENSION self) -> wxPoint"""
        return _pcbnew.DIMENSION_GetPosition(self)

    def SetPosition(self, aPos):
        r"""SetPosition(DIMENSION self, wxPoint aPos)"""
        return _pcbnew.DIMENSION_SetPosition(self, aPos)

    def SetTextSize(self, aTextSize):
        r"""SetTextSize(DIMENSION self, wxSize aTextSize)"""
        return _pcbnew.DIMENSION_SetTextSize(self, aTextSize)

    def SetLayer(self, aLayer):
        r"""SetLayer(DIMENSION self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.DIMENSION_SetLayer(self, aLayer)

    def SetShape(self, aShape):
        r"""SetShape(DIMENSION self, int aShape)"""
        return _pcbnew.DIMENSION_SetShape(self, aShape)

    def GetShape(self):
        r"""GetShape(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetShape(self)

    def GetWidth(self):
        r"""GetWidth(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetWidth(self)

    def SetWidth(self, aWidth):
        r"""SetWidth(DIMENSION self, int aWidth)"""
        return _pcbnew.DIMENSION_SetWidth(self, aWidth)

    def SetOrigin(self, aOrigin):
        r"""SetOrigin(DIMENSION self, wxPoint aOrigin)"""
        return _pcbnew.DIMENSION_SetOrigin(self, aOrigin)

    def GetOrigin(self):
        r"""GetOrigin(DIMENSION self) -> wxPoint"""
        return _pcbnew.DIMENSION_GetOrigin(self)

    def SetEnd(self, aEnd):
        r"""SetEnd(DIMENSION self, wxPoint aEnd)"""
        return _pcbnew.DIMENSION_SetEnd(self, aEnd)

    def GetEnd(self):
        r"""GetEnd(DIMENSION self) -> wxPoint"""
        return _pcbnew.DIMENSION_GetEnd(self)

    def SetHeight(self, aHeight):
        r"""SetHeight(DIMENSION self, int aHeight)"""
        return _pcbnew.DIMENSION_SetHeight(self, aHeight)

    def GetHeight(self):
        r"""GetHeight(DIMENSION self) -> int"""
        return _pcbnew.DIMENSION_GetHeight(self)

    def UpdateHeight(self):
        r"""UpdateHeight(DIMENSION self)"""
        return _pcbnew.DIMENSION_UpdateHeight(self)

    def GetAngle(self):
        r"""GetAngle(DIMENSION self) -> double"""
        return _pcbnew.DIMENSION_GetAngle(self)

    def AdjustDimensionDetails(self):
        r"""AdjustDimensionDetails(DIMENSION self)"""
        return _pcbnew.DIMENSION_AdjustDimensionDetails(self)

    def GetUnits(self, aUnits, aUseMils):
        r"""GetUnits(DIMENSION self, EDA_UNITS_T & aUnits, bool & aUseMils)"""
        return _pcbnew.DIMENSION_GetUnits(self, aUnits, aUseMils)

    def SetUnits(self, aUnits, aUseMils):
        r"""SetUnits(DIMENSION self, EDA_UNITS_T aUnits, bool aUseMils)"""
        return _pcbnew.DIMENSION_SetUnits(self, aUnits, aUseMils)

    def SetText(self, NewText):
        r"""SetText(DIMENSION self, wxString NewText)"""
        return _pcbnew.DIMENSION_SetText(self, NewText)

    def GetText(self):
        r"""GetText(DIMENSION self) -> wxString"""
        return _pcbnew.DIMENSION_GetText(self)

    def Text(self, *args):
        r"""
        Text(DIMENSION self) -> TEXTE_PCB
        Text(DIMENSION self) -> TEXTE_PCB
        """
        return _pcbnew.DIMENSION_Text(self, *args)

    def Draw(self, *args):
        r"""Draw(DIMENSION self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aColorMode, wxPoint offset=)"""
        return _pcbnew.DIMENSION_Draw(self, *args)

    def Move(self, offset):
        r"""Move(DIMENSION self, wxPoint offset)"""
        return _pcbnew.DIMENSION_Move(self, offset)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(DIMENSION self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.DIMENSION_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(DIMENSION self, wxPoint aCentre)"""
        return _pcbnew.DIMENSION_Flip(self, aCentre)

    def Mirror(self, axis_pos):
        r"""Mirror(DIMENSION self, wxPoint axis_pos)"""
        return _pcbnew.DIMENSION_Mirror(self, axis_pos)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""
        HitTest(DIMENSION self, wxPoint aPosition) -> bool
        HitTest(DIMENSION self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.DIMENSION_HitTest(self, *args)

    def GetClass(self):
        r"""GetClass(DIMENSION self) -> wxString"""
        return _pcbnew.DIMENSION_GetClass(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(DIMENSION self) -> EDA_RECT"""
        return _pcbnew.DIMENSION_GetBoundingBox(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(DIMENSION self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.DIMENSION_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(DIMENSION self) -> BITMAP_DEF"""
        return _pcbnew.DIMENSION_GetMenuImage(self)

    def Clone(self):
        r"""Clone(DIMENSION self) -> EDA_ITEM"""
        return _pcbnew.DIMENSION_Clone(self)

    def ViewBBox(self):
        r"""ViewBBox(DIMENSION self) -> BOX2I const"""
        return _pcbnew.DIMENSION_ViewBBox(self)

    def SwapData(self, aImage):
        r"""SwapData(DIMENSION self, BOARD_ITEM aImage)"""
        return _pcbnew.DIMENSION_SwapData(self, aImage)

# Register DIMENSION in _pcbnew:
_pcbnew.DIMENSION_swigregister(DIMENSION)

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

class DRAWSEGMENT(BOARD_ITEM):
    r"""Proxy of C++ DRAWSEGMENT class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aParent=None, idtype=PCB_LINE_T):
        r"""__init__(DRAWSEGMENT self, BOARD_ITEM aParent=None, KICAD_T idtype=PCB_LINE_T) -> DRAWSEGMENT"""
        _pcbnew.DRAWSEGMENT_swiginit(self, _pcbnew.new_DRAWSEGMENT(aParent, idtype))
    __swig_destroy__ = _pcbnew.delete_DRAWSEGMENT

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.DRAWSEGMENT_ClassOf(aItem)

    def IsPolygonFilled(self):
        r"""IsPolygonFilled(DRAWSEGMENT self) -> bool"""
        return _pcbnew.DRAWSEGMENT_IsPolygonFilled(self)

    def SetWidth(self, aWidth):
        r"""SetWidth(DRAWSEGMENT self, int aWidth)"""
        return _pcbnew.DRAWSEGMENT_SetWidth(self, aWidth)

    def GetWidth(self):
        r"""GetWidth(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetWidth(self)

    def SetAngle(self, aAngle):
        r"""SetAngle(DRAWSEGMENT self, double aAngle)"""
        return _pcbnew.DRAWSEGMENT_SetAngle(self, aAngle)

    def GetAngle(self):
        r"""GetAngle(DRAWSEGMENT self) -> double"""
        return _pcbnew.DRAWSEGMENT_GetAngle(self)

    def SetType(self, aType):
        r"""SetType(DRAWSEGMENT self, int aType)"""
        return _pcbnew.DRAWSEGMENT_SetType(self, aType)

    def GetType(self):
        r"""GetType(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetType(self)

    def SetShape(self, aShape):
        r"""SetShape(DRAWSEGMENT self, STROKE_T aShape)"""
        return _pcbnew.DRAWSEGMENT_SetShape(self, aShape)

    def GetShape(self):
        r"""GetShape(DRAWSEGMENT self) -> STROKE_T"""
        return _pcbnew.DRAWSEGMENT_GetShape(self)

    def SetBezControl1(self, aPoint):
        r"""SetBezControl1(DRAWSEGMENT self, wxPoint aPoint)"""
        return _pcbnew.DRAWSEGMENT_SetBezControl1(self, aPoint)

    def GetBezControl1(self):
        r"""GetBezControl1(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetBezControl1(self)

    def SetBezControl2(self, aPoint):
        r"""SetBezControl2(DRAWSEGMENT self, wxPoint aPoint)"""
        return _pcbnew.DRAWSEGMENT_SetBezControl2(self, aPoint)

    def GetBezControl2(self):
        r"""GetBezControl2(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetBezControl2(self)

    def SetPosition(self, aPos):
        r"""SetPosition(DRAWSEGMENT self, wxPoint aPos)"""
        return _pcbnew.DRAWSEGMENT_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetPosition(self)

    def GetStart(self):
        r"""GetStart(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetStart(self)

    def SetStart(self, aStart):
        r"""SetStart(DRAWSEGMENT self, wxPoint aStart)"""
        return _pcbnew.DRAWSEGMENT_SetStart(self, aStart)

    def SetStartY(self, y):
        r"""SetStartY(DRAWSEGMENT self, int y)"""
        return _pcbnew.DRAWSEGMENT_SetStartY(self, y)

    def SetStartX(self, x):
        r"""SetStartX(DRAWSEGMENT self, int x)"""
        return _pcbnew.DRAWSEGMENT_SetStartX(self, x)

    def GetEnd(self):
        r"""GetEnd(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetEnd(self)

    def SetEnd(self, aEnd):
        r"""SetEnd(DRAWSEGMENT self, wxPoint aEnd)"""
        return _pcbnew.DRAWSEGMENT_SetEnd(self, aEnd)

    def SetEndY(self, y):
        r"""SetEndY(DRAWSEGMENT self, int y)"""
        return _pcbnew.DRAWSEGMENT_SetEndY(self, y)

    def SetEndX(self, x):
        r"""SetEndX(DRAWSEGMENT self, int x)"""
        return _pcbnew.DRAWSEGMENT_SetEndX(self, x)

    def GetCenter(self):
        r"""GetCenter(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetCenter(self)

    def GetArcStart(self):
        r"""GetArcStart(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetArcStart(self)

    def GetArcEnd(self):
        r"""GetArcEnd(DRAWSEGMENT self) -> wxPoint"""
        return _pcbnew.DRAWSEGMENT_GetArcEnd(self)

    def GetArcAngleStart(self):
        r"""GetArcAngleStart(DRAWSEGMENT self) -> double"""
        return _pcbnew.DRAWSEGMENT_GetArcAngleStart(self)

    def GetRadius(self):
        r"""GetRadius(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetRadius(self)

    def SetArcStart(self, aArcStartPoint):
        r"""SetArcStart(DRAWSEGMENT self, wxPoint aArcStartPoint)"""
        return _pcbnew.DRAWSEGMENT_SetArcStart(self, aArcStartPoint)

    def SetCenter(self, aCenterPoint):
        r"""SetCenter(DRAWSEGMENT self, wxPoint aCenterPoint)"""
        return _pcbnew.DRAWSEGMENT_SetCenter(self, aCenterPoint)

    def GetParentModule(self):
        r"""GetParentModule(DRAWSEGMENT self) -> MODULE"""
        return _pcbnew.DRAWSEGMENT_GetParentModule(self)

    def GetBezierPoints(self):
        r"""GetBezierPoints(DRAWSEGMENT self) -> wxPoint_Vector"""
        return _pcbnew.DRAWSEGMENT_GetBezierPoints(self)

    def BuildPolyPointsList(self):
        r"""BuildPolyPointsList(DRAWSEGMENT self) -> wxPoint_Vector"""
        return _pcbnew.DRAWSEGMENT_BuildPolyPointsList(self)

    def GetPointCount(self):
        r"""GetPointCount(DRAWSEGMENT self) -> int"""
        return _pcbnew.DRAWSEGMENT_GetPointCount(self)

    def GetPolyShape(self, *args):
        r"""
        GetPolyShape(DRAWSEGMENT self) -> SHAPE_POLY_SET
        GetPolyShape(DRAWSEGMENT self) -> SHAPE_POLY_SET
        """
        return _pcbnew.DRAWSEGMENT_GetPolyShape(self, *args)

    def IsPolyShapeValid(self):
        r"""IsPolyShapeValid(DRAWSEGMENT self) -> bool"""
        return _pcbnew.DRAWSEGMENT_IsPolyShapeValid(self)

    def SetPolyShape(self, aShape):
        r"""SetPolyShape(DRAWSEGMENT self, SHAPE_POLY_SET aShape)"""
        return _pcbnew.DRAWSEGMENT_SetPolyShape(self, aShape)

    def SetBezierPoints(self, aPoints):
        r"""SetBezierPoints(DRAWSEGMENT self, wxPoint_Vector aPoints)"""
        return _pcbnew.DRAWSEGMENT_SetBezierPoints(self, aPoints)

    def RebuildBezierToSegmentsPointsList(self, aMinSegLen):
        r"""RebuildBezierToSegmentsPointsList(DRAWSEGMENT self, int aMinSegLen)"""
        return _pcbnew.DRAWSEGMENT_RebuildBezierToSegmentsPointsList(self, aMinSegLen)

    def SetPolyPoints(self, aPoints):
        r"""SetPolyPoints(DRAWSEGMENT self, wxPoint_Vector aPoints)"""
        return _pcbnew.DRAWSEGMENT_SetPolyPoints(self, aPoints)

    def Draw(self, *args):
        r"""Draw(DRAWSEGMENT self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.DRAWSEGMENT_Draw(self, *args)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""GetBoundingBox(DRAWSEGMENT self) -> EDA_RECT"""
        return _pcbnew.DRAWSEGMENT_GetBoundingBox(self)

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

    def GetClass(self):
        r"""GetClass(DRAWSEGMENT self) -> wxString"""
        return _pcbnew.DRAWSEGMENT_GetClass(self)

    def GetLength(self):
        r"""GetLength(DRAWSEGMENT self) -> double"""
        return _pcbnew.DRAWSEGMENT_GetLength(self)

    def Move(self, aMoveVector):
        r"""Move(DRAWSEGMENT self, wxPoint aMoveVector)"""
        return _pcbnew.DRAWSEGMENT_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(DRAWSEGMENT self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.DRAWSEGMENT_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(DRAWSEGMENT self, wxPoint aCentre)"""
        return _pcbnew.DRAWSEGMENT_Flip(self, aCentre)

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

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(DRAWSEGMENT self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.DRAWSEGMENT_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(DRAWSEGMENT self) -> BITMAP_DEF"""
        return _pcbnew.DRAWSEGMENT_GetMenuImage(self)

    def Clone(self):
        r"""Clone(DRAWSEGMENT self) -> EDA_ITEM"""
        return _pcbnew.DRAWSEGMENT_Clone(self)

    def ViewBBox(self):
        r"""ViewBBox(DRAWSEGMENT self) -> BOX2I const"""
        return _pcbnew.DRAWSEGMENT_ViewBBox(self)

    def SwapData(self, aImage):
        r"""SwapData(DRAWSEGMENT self, BOARD_ITEM aImage)"""
        return _pcbnew.DRAWSEGMENT_SwapData(self, aImage)

    def GetShapeStr(self):
        return self.ShowShape(self.GetShape())


# Register DRAWSEGMENT in _pcbnew:
_pcbnew.DRAWSEGMENT_swigregister(DRAWSEGMENT)

def DRAWSEGMENT_ClassOf(aItem):
    r"""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):
    r"""Proxy of C++ MARKER_PCB class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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=wxPoint()) -> MARKER_PCB
        __init__(MARKER_PCB self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText=wxEmptyString, wxPoint bPos=wxPoint()) -> MARKER_PCB
        """
        _pcbnew.MARKER_PCB_swiginit(self, _pcbnew.new_MARKER_PCB(*args))
    __swig_destroy__ = _pcbnew.delete_MARKER_PCB

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.MARKER_PCB_ClassOf(aItem)

    def Move(self, aMoveVector):
        r"""Move(MARKER_PCB self, wxPoint aMoveVector)"""
        return _pcbnew.MARKER_PCB_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(MARKER_PCB self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MARKER_PCB_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(MARKER_PCB self, wxPoint aCentre)"""
        return _pcbnew.MARKER_PCB_Flip(self, aCentre)

    def Draw(self, *args):
        r"""Draw(MARKER_PCB self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.MARKER_PCB_Draw(self, *args)

    def GetPosition(self):
        r"""GetPosition(MARKER_PCB self) -> wxPoint"""
        return _pcbnew.MARKER_PCB_GetPosition(self)

    def SetPosition(self, aPos):
        r"""SetPosition(MARKER_PCB self, wxPoint aPos)"""
        return _pcbnew.MARKER_PCB_SetPosition(self, aPos)

    def HitTest(self, aPosition):
        r"""HitTest(MARKER_PCB self, wxPoint aPosition) -> bool"""
        return _pcbnew.MARKER_PCB_HitTest(self, aPosition)

    def IsOnLayer(self, aLayer):
        r"""IsOnLayer(MARKER_PCB self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.MARKER_PCB_IsOnLayer(self, aLayer)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""GetSelectMenuText(MARKER_PCB self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.MARKER_PCB_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(MARKER_PCB self) -> BITMAP_DEF"""
        return _pcbnew.MARKER_PCB_GetMenuImage(self)

    def ViewBBox(self):
        r"""ViewBBox(MARKER_PCB self) -> BOX2I const"""
        return _pcbnew.MARKER_PCB_ViewBBox(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(MARKER_PCB self) -> EDA_RECT"""
        return _pcbnew.MARKER_PCB_GetBoundingBox(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(MARKER_PCB self, int [] aLayers, int & aCount)"""
        return _pcbnew.MARKER_PCB_ViewGetLayers(self, aLayers, aCount)

    def GetClass(self):
        r"""GetClass(MARKER_PCB self) -> wxString"""
        return _pcbnew.MARKER_PCB_GetClass(self)

# Register MARKER_PCB in _pcbnew:
_pcbnew.MARKER_PCB_swigregister(MARKER_PCB)

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

class PCB_TARGET(BOARD_ITEM):
    r"""Proxy of C++ PCB_TARGET class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _pcbnew.PCB_TARGET_swiginit(self, _pcbnew.new_PCB_TARGET(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_TARGET

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TARGET_ClassOf(aItem)

    def SetPosition(self, aPos):
        r"""SetPosition(PCB_TARGET self, wxPoint aPos)"""
        return _pcbnew.PCB_TARGET_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(PCB_TARGET self) -> wxPoint"""
        return _pcbnew.PCB_TARGET_GetPosition(self)

    def SetShape(self, aShape):
        r"""SetShape(PCB_TARGET self, int aShape)"""
        return _pcbnew.PCB_TARGET_SetShape(self, aShape)

    def GetShape(self):
        r"""GetShape(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetShape(self)

    def SetSize(self, aSize):
        r"""SetSize(PCB_TARGET self, int aSize)"""
        return _pcbnew.PCB_TARGET_SetSize(self, aSize)

    def GetSize(self):
        r"""GetSize(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetSize(self)

    def SetWidth(self, aWidth):
        r"""SetWidth(PCB_TARGET self, int aWidth)"""
        return _pcbnew.PCB_TARGET_SetWidth(self, aWidth)

    def GetWidth(self):
        r"""GetWidth(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetWidth(self)

    def Move(self, aMoveVector):
        r"""Move(PCB_TARGET self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_TARGET_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(PCB_TARGET self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_TARGET_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(PCB_TARGET self, wxPoint aCentre)"""
        return _pcbnew.PCB_TARGET_Flip(self, aCentre)

    def Draw(self, *args):
        r"""Draw(PCB_TARGET self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset=)"""
        return _pcbnew.PCB_TARGET_Draw(self, *args)

    def GetClass(self):
        r"""GetClass(PCB_TARGET self) -> wxString"""
        return _pcbnew.PCB_TARGET_GetClass(self)

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

    def GetBoundingBox(self):
        r"""GetBoundingBox(PCB_TARGET self) -> EDA_RECT"""
        return _pcbnew.PCB_TARGET_GetBoundingBox(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(PCB_TARGET self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.PCB_TARGET_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(PCB_TARGET self) -> BITMAP_DEF"""
        return _pcbnew.PCB_TARGET_GetMenuImage(self)

    def Clone(self):
        r"""Clone(PCB_TARGET self) -> EDA_ITEM"""
        return _pcbnew.PCB_TARGET_Clone(self)

    def SwapData(self, aImage):
        r"""SwapData(PCB_TARGET self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_TARGET_SwapData(self, aImage)

# Register PCB_TARGET in _pcbnew:
_pcbnew.PCB_TARGET_swigregister(PCB_TARGET)

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

class TEXTE_MODULE(BOARD_ITEM, EDA_TEXT):
    r"""Proxy of C++ TEXTE_MODULE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        r"""__init__(TEXTE_MODULE self, MODULE parent, TEXTE_MODULE::TEXT_TYPE text_type=TEXT_is_DIVERS) -> TEXTE_MODULE"""
        _pcbnew.TEXTE_MODULE_swiginit(self, _pcbnew.new_TEXTE_MODULE(*args))
    __swig_destroy__ = _pcbnew.delete_TEXTE_MODULE

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TEXTE_MODULE_ClassOf(aItem)

    def GetPosition(self):
        r"""GetPosition(TEXTE_MODULE self) -> wxPoint"""
        return _pcbnew.TEXTE_MODULE_GetPosition(self)

    def SetPosition(self, aPos):
        r"""SetPosition(TEXTE_MODULE self, wxPoint aPos)"""
        return _pcbnew.TEXTE_MODULE_SetPosition(self, aPos)

    def SetTextAngle(self, aAngle):
        r"""SetTextAngle(TEXTE_MODULE self, double aAngle)"""
        return _pcbnew.TEXTE_MODULE_SetTextAngle(self, aAngle)

    def KeepUpright(self, aOldOrientation, aNewOrientation):
        r"""KeepUpright(TEXTE_MODULE self, double aOldOrientation, double aNewOrientation)"""
        return _pcbnew.TEXTE_MODULE_KeepUpright(self, aOldOrientation, aNewOrientation)

    def IsKeepUpright(self):
        r"""IsKeepUpright(TEXTE_MODULE self) -> bool"""
        return _pcbnew.TEXTE_MODULE_IsKeepUpright(self)

    def SetKeepUpright(self, aKeepUpright):
        r"""SetKeepUpright(TEXTE_MODULE self, bool aKeepUpright)"""
        return _pcbnew.TEXTE_MODULE_SetKeepUpright(self, aKeepUpright)

    def Rotate(self, aOffset, aAngle):
        r"""Rotate(TEXTE_MODULE self, wxPoint aOffset, double aAngle)"""
        return _pcbnew.TEXTE_MODULE_Rotate(self, aOffset, aAngle)

    def Flip(self, aCentre):
        r"""Flip(TEXTE_MODULE self, wxPoint aCentre)"""
        return _pcbnew.TEXTE_MODULE_Flip(self, aCentre)

    def IsParentFlipped(self):
        r"""IsParentFlipped(TEXTE_MODULE self) -> bool"""
        return _pcbnew.TEXTE_MODULE_IsParentFlipped(self)

    def Mirror(self, aCentre, aMirrorAroundXAxis):
        r"""Mirror(TEXTE_MODULE self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.TEXTE_MODULE_Mirror(self, aCentre, aMirrorAroundXAxis)

    def Move(self, aMoveVector):
        r"""Move(TEXTE_MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.TEXTE_MODULE_Move(self, aMoveVector)

    def SetType(self, aType):
        r"""SetType(TEXTE_MODULE self, TEXTE_MODULE::TEXT_TYPE aType)"""
        return _pcbnew.TEXTE_MODULE_SetType(self, aType)

    def GetType(self):
        r"""GetType(TEXTE_MODULE self) -> TEXTE_MODULE::TEXT_TYPE"""
        return _pcbnew.TEXTE_MODULE_GetType(self)

    def SetEffects(self, aSrc):
        r"""SetEffects(TEXTE_MODULE self, TEXTE_MODULE aSrc)"""
        return _pcbnew.TEXTE_MODULE_SetEffects(self, aSrc)

    def SwapEffects(self, aTradingPartner):
        r"""SwapEffects(TEXTE_MODULE self, TEXTE_MODULE aTradingPartner)"""
        return _pcbnew.TEXTE_MODULE_SwapEffects(self, aTradingPartner)

    def SetPos0(self, aPos):
        r"""SetPos0(TEXTE_MODULE self, wxPoint aPos)"""
        return _pcbnew.TEXTE_MODULE_SetPos0(self, aPos)

    def GetPos0(self):
        r"""GetPos0(TEXTE_MODULE self) -> wxPoint"""
        return _pcbnew.TEXTE_MODULE_GetPos0(self)

    def GetLength(self):
        r"""GetLength(TEXTE_MODULE self) -> int"""
        return _pcbnew.TEXTE_MODULE_GetLength(self)

    def GetDrawRotation(self):
        r"""GetDrawRotation(TEXTE_MODULE self) -> double"""
        return _pcbnew.TEXTE_MODULE_GetDrawRotation(self)

    def GetDrawRotationRadians(self):
        r"""GetDrawRotationRadians(TEXTE_MODULE self) -> double"""
        return _pcbnew.TEXTE_MODULE_GetDrawRotationRadians(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(TEXTE_MODULE self) -> EDA_RECT"""
        return _pcbnew.TEXTE_MODULE_GetBoundingBox(self)

    def SetDrawCoord(self):
        r"""SetDrawCoord(TEXTE_MODULE self)"""
        return _pcbnew.TEXTE_MODULE_SetDrawCoord(self)

    def SetLocalCoord(self):
        r"""SetLocalCoord(TEXTE_MODULE self)"""
        return _pcbnew.TEXTE_MODULE_SetLocalCoord(self)

    def Draw(self, *args):
        r"""Draw(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.TEXTE_MODULE_Draw(self, *args)

    def DrawUmbilical(self, *args):
        r"""DrawUmbilical(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.TEXTE_MODULE_DrawUmbilical(self, *args)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""
        TextHitTest(TEXTE_MODULE self, wxPoint aPoint, int aAccuracy=0) -> bool
        TextHitTest(TEXTE_MODULE self, EDA_RECT aRect, bool aContains=False, int aAccuracy=0) -> bool
        """
        return _pcbnew.TEXTE_MODULE_TextHitTest(self, *args)

    def HitTest(self, *args):
        r"""
        HitTest(TEXTE_MODULE self, wxPoint aPosition) -> bool
        HitTest(TEXTE_MODULE self, EDA_RECT aRect, bool aContained=False, int aAccuracy=0) -> bool
        """
        return _pcbnew.TEXTE_MODULE_HitTest(self, *args)

    def GetClass(self):
        r"""GetClass(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(TEXTE_MODULE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(TEXTE_MODULE self) -> BITMAP_DEF"""
        return _pcbnew.TEXTE_MODULE_GetMenuImage(self)

    def Clone(self):
        r"""Clone(TEXTE_MODULE self) -> EDA_ITEM"""
        return _pcbnew.TEXTE_MODULE_Clone(self)

    def GetShownText(self):
        r"""GetShownText(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetShownText(self)

    def ViewBBox(self):
        r"""ViewBBox(TEXTE_MODULE self) -> BOX2I const"""
        return _pcbnew.TEXTE_MODULE_ViewBBox(self)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(TEXTE_MODULE self, int [] aLayers, int & aCount)"""
        return _pcbnew.TEXTE_MODULE_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(TEXTE_MODULE self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.TEXTE_MODULE_ViewGetLOD(self, aLayer, aView)

# Register TEXTE_MODULE in _pcbnew:
_pcbnew.TEXTE_MODULE_swigregister(TEXTE_MODULE)

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

class EDGE_MODULE(DRAWSEGMENT):
    r"""Proxy of C++ EDGE_MODULE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, parent, aShape=S_SEGMENT):
        r"""__init__(EDGE_MODULE self, MODULE parent, STROKE_T aShape=S_SEGMENT) -> EDGE_MODULE"""
        _pcbnew.EDGE_MODULE_swiginit(self, _pcbnew.new_EDGE_MODULE(parent, aShape))
    __swig_destroy__ = _pcbnew.delete_EDGE_MODULE

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.EDGE_MODULE_ClassOf(aItem)

    def Move(self, aMoveVector):
        r"""Move(EDGE_MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.EDGE_MODULE_Move(self, aMoveVector)

    def Mirror(self, aCentre, aMirrorAroundXAxis):
        r"""Mirror(EDGE_MODULE self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.EDGE_MODULE_Mirror(self, aCentre, aMirrorAroundXAxis)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(EDGE_MODULE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.EDGE_MODULE_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(EDGE_MODULE self, wxPoint aCentre)"""
        return _pcbnew.EDGE_MODULE_Flip(self, aCentre)

    def IsParentFlipped(self):
        r"""IsParentFlipped(EDGE_MODULE self) -> bool"""
        return _pcbnew.EDGE_MODULE_IsParentFlipped(self)

    def SetStart0(self, aPoint):
        r"""SetStart0(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetStart0(self, aPoint)

    def GetStart0(self):
        r"""GetStart0(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetStart0(self)

    def SetEnd0(self, aPoint):
        r"""SetEnd0(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetEnd0(self, aPoint)

    def GetEnd0(self):
        r"""GetEnd0(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetEnd0(self)

    def SetBezier0_C1(self, aPoint):
        r"""SetBezier0_C1(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetBezier0_C1(self, aPoint)

    def GetBezier0_C1(self):
        r"""GetBezier0_C1(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetBezier0_C1(self)

    def SetBezier0_C2(self, aPoint):
        r"""SetBezier0_C2(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetBezier0_C2(self, aPoint)

    def GetBezier0_C2(self):
        r"""GetBezier0_C2(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetBezier0_C2(self)

    def SetLocalCoord(self):
        r"""SetLocalCoord(EDGE_MODULE self)"""
        return _pcbnew.EDGE_MODULE_SetLocalCoord(self)

    def SetDrawCoord(self):
        r"""SetDrawCoord(EDGE_MODULE self)"""
        return _pcbnew.EDGE_MODULE_SetDrawCoord(self)

    def Draw(self, *args):
        r"""Draw(EDGE_MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset=)"""
        return _pcbnew.EDGE_MODULE_Draw(self, *args)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""GetClass(EDGE_MODULE self) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(EDGE_MODULE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(EDGE_MODULE self) -> BITMAP_DEF"""
        return _pcbnew.EDGE_MODULE_GetMenuImage(self)

    def Clone(self):
        r"""Clone(EDGE_MODULE self) -> EDA_ITEM"""
        return _pcbnew.EDGE_MODULE_Clone(self)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(EDGE_MODULE self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.EDGE_MODULE_ViewGetLOD(self, aLayer, aView)
    m_Start0 = property(_pcbnew.EDGE_MODULE_m_Start0_get, _pcbnew.EDGE_MODULE_m_Start0_set, doc=r"""m_Start0 : wxPoint""")
    m_End0 = property(_pcbnew.EDGE_MODULE_m_End0_get, _pcbnew.EDGE_MODULE_m_End0_set, doc=r"""m_End0 : wxPoint""")
    m_Bezier0_C1 = property(_pcbnew.EDGE_MODULE_m_Bezier0_C1_get, _pcbnew.EDGE_MODULE_m_Bezier0_C1_set, doc=r"""m_Bezier0_C1 : wxPoint""")
    m_Bezier0_C2 = property(_pcbnew.EDGE_MODULE_m_Bezier0_C2_get, _pcbnew.EDGE_MODULE_m_Bezier0_C2_set, doc=r"""m_Bezier0_C2 : wxPoint""")

# Register EDGE_MODULE in _pcbnew:
_pcbnew.EDGE_MODULE_swigregister(EDGE_MODULE)

def EDGE_MODULE_ClassOf(aItem):
    r"""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):
    r"""Proxy of C++ std::vector< D_PAD * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(D_PADS self) -> SwigPyIterator"""
        return _pcbnew.D_PADS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(D_PADS self) -> bool"""
        return _pcbnew.D_PADS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(D_PADS self) -> bool"""
        return _pcbnew.D_PADS___bool__(self)

    def __len__(self):
        r"""__len__(D_PADS self) -> std::vector< D_PAD * >::size_type"""
        return _pcbnew.D_PADS___len__(self)

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(D_PADS self) -> D_PAD"""
        return _pcbnew.D_PADS_pop(self)

    def append(self, x):
        r"""append(D_PADS self, D_PAD x)"""
        return _pcbnew.D_PADS_append(self, x)

    def empty(self):
        r"""empty(D_PADS self) -> bool"""
        return _pcbnew.D_PADS_empty(self)

    def size(self):
        r"""size(D_PADS self) -> std::vector< D_PAD * >::size_type"""
        return _pcbnew.D_PADS_size(self)

    def swap(self, v):
        r"""swap(D_PADS self, D_PADS v)"""
        return _pcbnew.D_PADS_swap(self, v)

    def begin(self):
        r"""begin(D_PADS self) -> std::vector< D_PAD * >::iterator"""
        return _pcbnew.D_PADS_begin(self)

    def end(self):
        r"""end(D_PADS self) -> std::vector< D_PAD * >::iterator"""
        return _pcbnew.D_PADS_end(self)

    def rbegin(self):
        r"""rbegin(D_PADS self) -> std::vector< D_PAD * >::reverse_iterator"""
        return _pcbnew.D_PADS_rbegin(self)

    def rend(self):
        r"""rend(D_PADS self) -> std::vector< D_PAD * >::reverse_iterator"""
        return _pcbnew.D_PADS_rend(self)

    def clear(self):
        r"""clear(D_PADS self)"""
        return _pcbnew.D_PADS_clear(self)

    def get_allocator(self):
        r"""get_allocator(D_PADS self) -> std::vector< D_PAD * >::allocator_type"""
        return _pcbnew.D_PADS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(D_PADS self)"""
        return _pcbnew.D_PADS_pop_back(self)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(D_PADS self) -> D_PADS
        __init__(D_PADS self, D_PADS other) -> D_PADS
        __init__(D_PADS self, std::vector< D_PAD * >::size_type size) -> D_PADS
        __init__(D_PADS self, std::vector< D_PAD * >::size_type size, D_PAD value) -> D_PADS
        """
        _pcbnew.D_PADS_swiginit(self, _pcbnew.new_D_PADS(*args))

    def push_back(self, x):
        r"""push_back(D_PADS self, D_PAD x)"""
        return _pcbnew.D_PADS_push_back(self, x)

    def front(self):
        r"""front(D_PADS self) -> D_PAD"""
        return _pcbnew.D_PADS_front(self)

    def back(self):
        r"""back(D_PADS self) -> D_PAD"""
        return _pcbnew.D_PADS_back(self)

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(D_PADS self, std::vector< D_PAD * >::size_type n)"""
        return _pcbnew.D_PADS_reserve(self, n)

    def capacity(self):
        r"""capacity(D_PADS self) -> std::vector< D_PAD * >::size_type"""
        return _pcbnew.D_PADS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_D_PADS

# Register D_PADS in _pcbnew:
_pcbnew.D_PADS_swigregister(D_PADS)

class NETINFO_ITEM(BOARD_ITEM):
    r"""Proxy of C++ NETINFO_ITEM class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NETINFO_ITEM self, BOARD aParent, wxString aNetName=wxEmptyString, int aNetCode=-1) -> NETINFO_ITEM"""
        _pcbnew.NETINFO_ITEM_swiginit(self, _pcbnew.new_NETINFO_ITEM(*args))
    __swig_destroy__ = _pcbnew.delete_NETINFO_ITEM

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.NETINFO_ITEM_ClassOf(aItem)

    def GetClass(self):
        r"""GetClass(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetClass(self)

    def GetPosition(self):
        r"""GetPosition(NETINFO_ITEM self) -> wxPoint"""
        return _pcbnew.NETINFO_ITEM_GetPosition(self)

    def SetPosition(self, aPos):
        r"""SetPosition(NETINFO_ITEM self, wxPoint aPos)"""
        return _pcbnew.NETINFO_ITEM_SetPosition(self, aPos)

    def SetClass(self, aNetClass):
        r"""SetClass(NETINFO_ITEM self, NETCLASSPTR const & aNetClass)"""
        return _pcbnew.NETINFO_ITEM_SetClass(self, aNetClass)

    def GetNetClass(self):
        r"""GetNetClass(NETINFO_ITEM self) -> NETCLASSPTR"""
        return _pcbnew.NETINFO_ITEM_GetNetClass(self)

    def GetClassName(self):
        r"""GetClassName(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetClassName(self)

    def GetTrackWidth(self):
        r"""GetTrackWidth(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetTrackWidth(self)

    def GetViaSize(self):
        r"""GetViaSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetViaSize(self)

    def GetMicroViaSize(self):
        r"""GetMicroViaSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetMicroViaSize(self)

    def GetViaDrillSize(self):
        r"""GetViaDrillSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetViaDrillSize(self)

    def GetMicroViaDrillSize(self):
        r"""GetMicroViaDrillSize(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetMicroViaDrillSize(self)

    def GetClearance(self, aBoardItem):
        r"""GetClearance(NETINFO_ITEM self, BOARD_ITEM aBoardItem) -> int"""
        return _pcbnew.NETINFO_ITEM_GetClearance(self, aBoardItem)

    def Draw(self, panel, DC, aDrawMode, offset):
        r"""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):
        r"""GetNet(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetNet(self)

    def SetNetCode(self, aNetCode):
        r"""SetNetCode(NETINFO_ITEM self, int aNetCode)"""
        return _pcbnew.NETINFO_ITEM_SetNetCode(self, aNetCode)

    def GetNetname(self):
        r"""GetNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetNetname(self)

    def GetShortNetname(self):
        r"""GetShortNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetShortNetname(self)

    def IsCurrent(self):
        r"""IsCurrent(NETINFO_ITEM self) -> bool"""
        return _pcbnew.NETINFO_ITEM_IsCurrent(self)

    def SetIsCurrent(self, isCurrent):
        r"""SetIsCurrent(NETINFO_ITEM self, bool isCurrent)"""
        return _pcbnew.NETINFO_ITEM_SetIsCurrent(self, isCurrent)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""Clear(NETINFO_ITEM self)"""
        return _pcbnew.NETINFO_ITEM_Clear(self)

    def GetParent(self):
        r"""GetParent(NETINFO_ITEM self) -> BOARD"""
        return _pcbnew.NETINFO_ITEM_GetParent(self)

# Register NETINFO_ITEM in _pcbnew:
_pcbnew.NETINFO_ITEM_swigregister(NETINFO_ITEM)

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

class NETNAMES_MAP(object):
    r"""Proxy of C++ std::map< wxString,NETINFO_ITEM * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP___nonzero__(self)

    def __bool__(self):
        r"""__bool__(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP___bool__(self)

    def __len__(self):
        r"""__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):
        r"""__getitem__(NETNAMES_MAP self, wxString key) -> NETINFO_ITEM"""
        return _pcbnew.NETNAMES_MAP___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(NETNAMES_MAP self, wxString key)"""
        return _pcbnew.NETNAMES_MAP___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(NETNAMES_MAP self, wxString key) -> bool"""
        return _pcbnew.NETNAMES_MAP_has_key(self, key)

    def keys(self):
        r"""keys(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_keys(self)

    def values(self):
        r"""values(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_values(self)

    def items(self):
        r"""items(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_items(self)

    def __contains__(self, key):
        r"""__contains__(NETNAMES_MAP self, wxString key) -> bool"""
        return _pcbnew.NETNAMES_MAP___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""asdict(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(NETNAMES_MAP self, std::less< wxString > const & other) -> NETNAMES_MAP
        __init__(NETNAMES_MAP self) -> NETNAMES_MAP
        __init__(NETNAMES_MAP self, NETNAMES_MAP other) -> NETNAMES_MAP
        """
        _pcbnew.NETNAMES_MAP_swiginit(self, _pcbnew.new_NETNAMES_MAP(*args))

    def empty(self):
        r"""empty(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP_empty(self)

    def size(self):
        r"""size(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP_size(self)

    def swap(self, v):
        r"""swap(NETNAMES_MAP self, NETNAMES_MAP v)"""
        return _pcbnew.NETNAMES_MAP_swap(self, v)

    def begin(self):
        r"""begin(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_begin(self)

    def end(self):
        r"""end(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_end(self)

    def rbegin(self):
        r"""rbegin(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETNAMES_MAP_rbegin(self)

    def rend(self):
        r"""rend(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETNAMES_MAP_rend(self)

    def clear(self):
        r"""clear(NETNAMES_MAP self)"""
        return _pcbnew.NETNAMES_MAP_clear(self)

    def get_allocator(self):
        r"""get_allocator(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::allocator_type"""
        return _pcbnew.NETNAMES_MAP_get_allocator(self)

    def count(self, x):
        r"""count(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP_count(self, x)

    def erase(self, *args):
        r"""
        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):
        r"""find(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_find(self, x)

    def lower_bound(self, x):
        r"""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):
        r"""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

# Register NETNAMES_MAP in _pcbnew:
_pcbnew.NETNAMES_MAP_swigregister(NETNAMES_MAP)

class NETCODES_MAP(object):
    r"""Proxy of C++ std::map< int,NETINFO_ITEM * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP___nonzero__(self)

    def __bool__(self):
        r"""__bool__(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP___bool__(self)

    def __len__(self):
        r"""__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):
        r"""__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):
        r"""__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):
        r"""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):
        r"""keys(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_keys(self)

    def values(self):
        r"""values(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_values(self)

    def items(self):
        r"""items(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_items(self)

    def __contains__(self, key):
        r"""__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):
        r"""key_iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""asdict(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(NETCODES_MAP self, std::less< int > const & other) -> NETCODES_MAP
        __init__(NETCODES_MAP self) -> NETCODES_MAP
        __init__(NETCODES_MAP self, NETCODES_MAP other) -> NETCODES_MAP
        """
        _pcbnew.NETCODES_MAP_swiginit(self, _pcbnew.new_NETCODES_MAP(*args))

    def empty(self):
        r"""empty(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP_empty(self)

    def size(self):
        r"""size(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_MAP_size(self)

    def swap(self, v):
        r"""swap(NETCODES_MAP self, NETCODES_MAP v)"""
        return _pcbnew.NETCODES_MAP_swap(self, v)

    def begin(self):
        r"""begin(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_begin(self)

    def end(self):
        r"""end(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_end(self)

    def rbegin(self):
        r"""rbegin(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETCODES_MAP_rbegin(self)

    def rend(self):
        r"""rend(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETCODES_MAP_rend(self)

    def clear(self):
        r"""clear(NETCODES_MAP self)"""
        return _pcbnew.NETCODES_MAP_clear(self)

    def get_allocator(self):
        r"""get_allocator(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::allocator_type"""
        return _pcbnew.NETCODES_MAP_get_allocator(self)

    def count(self, x):
        r"""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):
        r"""
        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):
        r"""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):
        r"""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):
        r"""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

# Register NETCODES_MAP in _pcbnew:
_pcbnew.NETCODES_MAP_swigregister(NETCODES_MAP)

class NETINFO_LIST(object):
    r"""Proxy of C++ NETINFO_LIST class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aParent):
        r"""__init__(NETINFO_LIST self, BOARD aParent) -> NETINFO_LIST"""
        _pcbnew.NETINFO_LIST_swiginit(self, _pcbnew.new_NETINFO_LIST(aParent))
    __swig_destroy__ = _pcbnew.delete_NETINFO_LIST

    def GetNetItem(self, *args):
        r"""
        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):
        r"""GetNetCount(NETINFO_LIST self) -> unsigned int"""
        return _pcbnew.NETINFO_LIST_GetNetCount(self)

    def AppendNet(self, aNewElement):
        r"""AppendNet(NETINFO_LIST self, NETINFO_ITEM aNewElement)"""
        return _pcbnew.NETINFO_LIST_AppendNet(self, aNewElement)

    def RemoveNet(self, aNet):
        r"""RemoveNet(NETINFO_LIST self, NETINFO_ITEM aNet)"""
        return _pcbnew.NETINFO_LIST_RemoveNet(self, aNet)

    def NetsByName(self):
        r"""NetsByName(NETINFO_LIST self) -> NETNAMES_MAP"""
        return _pcbnew.NETINFO_LIST_NetsByName(self)

    def NetsByNetcode(self):
        r"""NetsByNetcode(NETINFO_LIST self) -> NETCODES_MAP"""
        return _pcbnew.NETINFO_LIST_NetsByNetcode(self)
    ORPHANED_ITEM = property(_pcbnew.NETINFO_LIST_ORPHANED_ITEM_get, _pcbnew.NETINFO_LIST_ORPHANED_ITEM_set, doc=r"""ORPHANED_ITEM : NETINFO_ITEM""")

    def GetParent(self):
        r"""GetParent(NETINFO_LIST self) -> BOARD"""
        return _pcbnew.NETINFO_LIST_GetParent(self)

# Register NETINFO_LIST in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ std::set< wxString > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(STRINGSET self) -> SwigPyIterator"""
        return _pcbnew.STRINGSET_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET___nonzero__(self)

    def __bool__(self):
        r"""__bool__(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET___bool__(self)

    def __len__(self):
        r"""__len__(STRINGSET self) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET___len__(self)

    def append(self, x):
        r"""append(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_append(self, x)

    def __contains__(self, x):
        r"""__contains__(STRINGSET self, wxString x) -> bool"""
        return _pcbnew.STRINGSET___contains__(self, x)

    def __getitem__(self, i):
        r"""__getitem__(STRINGSET self, std::set< wxString >::difference_type i) -> wxString"""
        return _pcbnew.STRINGSET___getitem__(self, i)

    def add(self, x):
        r"""add(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_add(self, x)

    def discard(self, x):
        r"""discard(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(STRINGSET self, std::less< wxString > const & other) -> STRINGSET
        __init__(STRINGSET self) -> STRINGSET
        __init__(STRINGSET self, STRINGSET other) -> STRINGSET
        """
        _pcbnew.STRINGSET_swiginit(self, _pcbnew.new_STRINGSET(*args))

    def empty(self):
        r"""empty(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET_empty(self)

    def size(self):
        r"""size(STRINGSET self) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET_size(self)

    def clear(self):
        r"""clear(STRINGSET self)"""
        return _pcbnew.STRINGSET_clear(self)

    def swap(self, v):
        r"""swap(STRINGSET self, STRINGSET v)"""
        return _pcbnew.STRINGSET_swap(self, v)

    def count(self, x):
        r"""count(STRINGSET self, wxString x) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET_count(self, x)

    def begin(self):
        r"""begin(STRINGSET self) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_begin(self)

    def end(self):
        r"""end(STRINGSET self) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_end(self)

    def rbegin(self):
        r"""rbegin(STRINGSET self) -> std::set< wxString >::reverse_iterator"""
        return _pcbnew.STRINGSET_rbegin(self)

    def rend(self):
        r"""rend(STRINGSET self) -> std::set< wxString >::reverse_iterator"""
        return _pcbnew.STRINGSET_rend(self)

    def erase(self, *args):
        r"""
        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):
        r"""find(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_upper_bound(self, x)

    def equal_range(self, x):
        r"""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):
        r"""insert(STRINGSET self, wxString __x) -> std::pair< std::set< wxString >::iterator,bool >"""
        return _pcbnew.STRINGSET_insert(self, __x)
    __swig_destroy__ = _pcbnew.delete_STRINGSET

# Register STRINGSET in _pcbnew:
_pcbnew.STRINGSET_swigregister(STRINGSET)

class NETCLASSPTR(object):
    r"""Proxy of C++ std::shared_ptr< NETCLASS > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name):
        r"""__init__(NETCLASSPTR self, string name) -> NETCLASSPTR"""
        _pcbnew.NETCLASSPTR_swiginit(self, _pcbnew.new_NETCLASSPTR(name))

    def NetNames(self):
        r"""NetNames(NETCLASSPTR self) -> STRINGSET"""
        return _pcbnew.NETCLASSPTR_NetNames(self)

    def GetName(self):
        r"""GetName(NETCLASSPTR self) -> wxString"""
        return _pcbnew.NETCLASSPTR_GetName(self)

    def GetCount(self):
        r"""GetCount(NETCLASSPTR self) -> unsigned int"""
        return _pcbnew.NETCLASSPTR_GetCount(self)

    def GetDescription(self):
        r"""GetDescription(NETCLASSPTR self) -> wxString"""
        return _pcbnew.NETCLASSPTR_GetDescription(self)

    def SetDescription(self, aDesc):
        r"""SetDescription(NETCLASSPTR self, wxString aDesc)"""
        return _pcbnew.NETCLASSPTR_SetDescription(self, aDesc)

    def GetClearance(self):
        r"""GetClearance(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetClearance(self)

    def SetClearance(self, aClearance):
        r"""SetClearance(NETCLASSPTR self, int aClearance)"""
        return _pcbnew.NETCLASSPTR_SetClearance(self, aClearance)

    def GetTrackWidth(self):
        r"""GetTrackWidth(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetTrackWidth(self)

    def SetTrackWidth(self, aWidth):
        r"""SetTrackWidth(NETCLASSPTR self, int aWidth)"""
        return _pcbnew.NETCLASSPTR_SetTrackWidth(self, aWidth)

    def GetViaDiameter(self):
        r"""GetViaDiameter(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetViaDiameter(self)

    def SetViaDiameter(self, aDia):
        r"""SetViaDiameter(NETCLASSPTR self, int aDia)"""
        return _pcbnew.NETCLASSPTR_SetViaDiameter(self, aDia)

    def GetViaDrill(self):
        r"""GetViaDrill(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetViaDrill(self)

    def SetViaDrill(self, aSize):
        r"""SetViaDrill(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetViaDrill(self, aSize)

    def GetuViaDiameter(self):
        r"""GetuViaDiameter(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetuViaDiameter(self)

    def SetuViaDiameter(self, aSize):
        r"""SetuViaDiameter(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetuViaDiameter(self, aSize)

    def GetuViaDrill(self):
        r"""GetuViaDrill(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetuViaDrill(self)

    def SetuViaDrill(self, aSize):
        r"""SetuViaDrill(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetuViaDrill(self, aSize)

    def GetDiffPairWidth(self):
        r"""GetDiffPairWidth(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetDiffPairWidth(self)

    def SetDiffPairWidth(self, aSize):
        r"""SetDiffPairWidth(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetDiffPairWidth(self, aSize)

    def GetDiffPairGap(self):
        r"""GetDiffPairGap(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetDiffPairGap(self)

    def SetDiffPairGap(self, aSize):
        r"""SetDiffPairGap(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetDiffPairGap(self, aSize)
    __swig_destroy__ = _pcbnew.delete_NETCLASSPTR

# Register NETCLASSPTR in _pcbnew:
_pcbnew.NETCLASSPTR_swigregister(NETCLASSPTR)

class NETCLASS_MAP(object):
    r"""Proxy of C++ std::map< wxString,NETCLASSPTR > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP___nonzero__(self)

    def __bool__(self):
        r"""__bool__(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP___bool__(self)

    def __len__(self):
        r"""__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):
        r"""__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):
        r"""__delitem__(NETCLASS_MAP self, wxString key)"""
        return _pcbnew.NETCLASS_MAP___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(NETCLASS_MAP self, wxString key) -> bool"""
        return _pcbnew.NETCLASS_MAP_has_key(self, key)

    def keys(self):
        r"""keys(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_keys(self)

    def values(self):
        r"""values(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_values(self)

    def items(self):
        r"""items(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_items(self)

    def __contains__(self, key):
        r"""__contains__(NETCLASS_MAP self, wxString key) -> bool"""
        return _pcbnew.NETCLASS_MAP___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""asdict(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(NETCLASS_MAP self, std::less< wxString > const & other) -> NETCLASS_MAP
        __init__(NETCLASS_MAP self) -> NETCLASS_MAP
        __init__(NETCLASS_MAP self, NETCLASS_MAP other) -> NETCLASS_MAP
        """
        _pcbnew.NETCLASS_MAP_swiginit(self, _pcbnew.new_NETCLASS_MAP(*args))

    def empty(self):
        r"""empty(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP_empty(self)

    def size(self):
        r"""size(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_MAP_size(self)

    def swap(self, v):
        r"""swap(NETCLASS_MAP self, NETCLASS_MAP v)"""
        return _pcbnew.NETCLASS_MAP_swap(self, v)

    def begin(self):
        r"""begin(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_begin(self)

    def end(self):
        r"""end(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_end(self)

    def rbegin(self):
        r"""rbegin(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.NETCLASS_MAP_rbegin(self)

    def rend(self):
        r"""rend(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.NETCLASS_MAP_rend(self)

    def clear(self):
        r"""clear(NETCLASS_MAP self)"""
        return _pcbnew.NETCLASS_MAP_clear(self)

    def get_allocator(self):
        r"""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):
        r"""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):
        r"""
        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):
        r"""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):
        r"""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):
        r"""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

# Register NETCLASS_MAP in _pcbnew:
_pcbnew.NETCLASS_MAP_swigregister(NETCLASS_MAP)

class NETCLASSES(object):
    r"""Proxy of C++ NETCLASSES class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(NETCLASSES self) -> NETCLASSES"""
        _pcbnew.NETCLASSES_swiginit(self, _pcbnew.new_NETCLASSES())
    __swig_destroy__ = _pcbnew.delete_NETCLASSES

    def Clear(self):
        r"""Clear(NETCLASSES self)"""
        return _pcbnew.NETCLASSES_Clear(self)

    def begin(self, *args):
        r"""
        begin(NETCLASSES self) -> NETCLASSES::iterator
        begin(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_begin(self, *args)

    def end(self, *args):
        r"""
        end(NETCLASSES self) -> NETCLASSES::iterator
        end(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_end(self, *args)

    def GetCount(self):
        r"""GetCount(NETCLASSES self) -> unsigned int"""
        return _pcbnew.NETCLASSES_GetCount(self)

    def GetDefault(self):
        r"""GetDefault(NETCLASSES self) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_GetDefault(self)

    def Add(self, aNetclass):
        r"""Add(NETCLASSES self, NETCLASSPTR const & aNetclass) -> bool"""
        return _pcbnew.NETCLASSES_Add(self, aNetclass)

    def Remove(self, aNetName):
        r"""Remove(NETCLASSES self, wxString aNetName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Remove(self, aNetName)

    def Find(self, aName):
        r"""Find(NETCLASSES self, wxString aName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Find(self, aName)

    def NetClasses(self):
        r"""NetClasses(NETCLASSES self) -> NETCLASS_MAP"""
        return _pcbnew.NETCLASSES_NetClasses(self)

# Register NETCLASSES in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ LSEQ class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(LSEQ self) -> LSEQ"""
        _pcbnew.LSEQ_swiginit(self, _pcbnew.new_LSEQ())

    def Rewind(self):
        r"""Rewind(LSEQ self)"""
        return _pcbnew.LSEQ_Rewind(self)

    def __nonzero__(self):
        return _pcbnew.LSEQ___nonzero__(self)
    __bool__ = __nonzero__



    def __ref__(self):
        r"""__ref__(LSEQ self) -> PCB_LAYER_ID"""
        return _pcbnew.LSEQ___ref__(self)
    __swig_destroy__ = _pcbnew.delete_LSEQ

# Register LSEQ in _pcbnew:
_pcbnew.LSEQ_swigregister(LSEQ)

class LSET(BASE_SET):
    r"""Proxy of C++ LSET class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _pcbnew.LSET_swiginit(self, _pcbnew.new_LSET(*args))

    @staticmethod
    def Name(aLayerId):
        r"""Name(PCB_LAYER_ID aLayerId) -> wxChar const *"""
        return _pcbnew.LSET_Name(aLayerId)

    @staticmethod
    def InternalCuMask():
        r"""InternalCuMask() -> LSET"""
        return _pcbnew.LSET_InternalCuMask()

    @staticmethod
    def AllCuMask(*args):
        r"""AllCuMask(int aCuLayerCount=(B_Cu-F_Cu+1)) -> LSET"""
        return _pcbnew.LSET_AllCuMask(*args)

    @staticmethod
    def ExternalCuMask():
        r"""ExternalCuMask() -> LSET"""
        return _pcbnew.LSET_ExternalCuMask()

    @staticmethod
    def AllNonCuMask():
        r"""AllNonCuMask() -> LSET"""
        return _pcbnew.LSET_AllNonCuMask()

    @staticmethod
    def AllLayersMask():
        r"""AllLayersMask() -> LSET"""
        return _pcbnew.LSET_AllLayersMask()

    @staticmethod
    def FrontTechMask():
        r"""FrontTechMask() -> LSET"""
        return _pcbnew.LSET_FrontTechMask()

    @staticmethod
    def FrontBoardTechMask():
        r"""FrontBoardTechMask() -> LSET"""
        return _pcbnew.LSET_FrontBoardTechMask()

    @staticmethod
    def BackTechMask():
        r"""BackTechMask() -> LSET"""
        return _pcbnew.LSET_BackTechMask()

    @staticmethod
    def BackBoardTechMask():
        r"""BackBoardTechMask() -> LSET"""
        return _pcbnew.LSET_BackBoardTechMask()

    @staticmethod
    def AllTechMask():
        r"""AllTechMask() -> LSET"""
        return _pcbnew.LSET_AllTechMask()

    @staticmethod
    def AllBoardTechMask():
        r"""AllBoardTechMask() -> LSET"""
        return _pcbnew.LSET_AllBoardTechMask()

    @staticmethod
    def FrontMask():
        r"""FrontMask() -> LSET"""
        return _pcbnew.LSET_FrontMask()

    @staticmethod
    def BackMask():
        r"""BackMask() -> LSET"""
        return _pcbnew.LSET_BackMask()

    @staticmethod
    def UserMask():
        r"""UserMask() -> LSET"""
        return _pcbnew.LSET_UserMask()

    @staticmethod
    def ForbiddenFootprintLayers():
        r"""ForbiddenFootprintLayers() -> LSET"""
        return _pcbnew.LSET_ForbiddenFootprintLayers()

    @staticmethod
    def ForbiddenTextLayers():
        r"""ForbiddenTextLayers() -> LSET"""
        return _pcbnew.LSET_ForbiddenTextLayers()

    def CuStack(self):
        r"""CuStack(LSET self) -> LSEQ"""
        return _pcbnew.LSET_CuStack(self)

    def Technicals(self, *args):
        r"""Technicals(LSET self, LSET aSubToOmit=LSET()) -> LSEQ"""
        return _pcbnew.LSET_Technicals(self, *args)

    def Users(self):
        r"""Users(LSET self) -> LSEQ"""
        return _pcbnew.LSET_Users(self)

    def TechAndUserUIOrder(self):
        r"""TechAndUserUIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_TechAndUserUIOrder(self)

    def UIOrder(self):
        r"""UIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_UIOrder(self)

    def Seq(self, *args):
        r"""
        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):
        r"""SeqStackupBottom2Top(LSET self) -> LSEQ"""
        return _pcbnew.LSET_SeqStackupBottom2Top(self)

    def FmtHex(self):
        r"""FmtHex(LSET self) -> string"""
        return _pcbnew.LSET_FmtHex(self)

    def ParseHex(self, aStart, aCount):
        r"""ParseHex(LSET self, char const * aStart, int aCount) -> int"""
        return _pcbnew.LSET_ParseHex(self, aStart, aCount)

    def FmtBin(self):
        r"""FmtBin(LSET self) -> string"""
        return _pcbnew.LSET_FmtBin(self)

    def ExtractLayer(self):
        r"""ExtractLayer(LSET self) -> PCB_LAYER_ID"""
        return _pcbnew.LSET_ExtractLayer(self)

    def addLayer(self, aLayer):
        r"""addLayer(LSET self, PCB_LAYER_ID aLayer) -> LSET"""
        return _pcbnew.LSET_addLayer(self, aLayer)

    def removeLayer(self, aLayer):
        r"""removeLayer(LSET self, PCB_LAYER_ID aLayer) -> LSET"""
        return _pcbnew.LSET_removeLayer(self, aLayer)

    def addLayerSet(self, aLayerSet):
        r"""addLayerSet(LSET self, LSET aLayerSet) -> LSET"""
        return _pcbnew.LSET_addLayerSet(self, aLayerSet)

    def removeLayerSet(self, aLayerSet):
        r"""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

# Register LSET in _pcbnew:
_pcbnew.LSET_swigregister(LSET)

def LSET_Name(aLayerId):
    r"""LSET_Name(PCB_LAYER_ID aLayerId) -> wxChar const *"""
    return _pcbnew.LSET_Name(aLayerId)

def LSET_InternalCuMask():
    r"""LSET_InternalCuMask() -> LSET"""
    return _pcbnew.LSET_InternalCuMask()

def LSET_AllCuMask(*args):
    r"""LSET_AllCuMask(int aCuLayerCount=(B_Cu-F_Cu+1)) -> LSET"""
    return _pcbnew.LSET_AllCuMask(*args)

def LSET_ExternalCuMask():
    r"""LSET_ExternalCuMask() -> LSET"""
    return _pcbnew.LSET_ExternalCuMask()

def LSET_AllNonCuMask():
    r"""LSET_AllNonCuMask() -> LSET"""
    return _pcbnew.LSET_AllNonCuMask()

def LSET_AllLayersMask():
    r"""LSET_AllLayersMask() -> LSET"""
    return _pcbnew.LSET_AllLayersMask()

def LSET_FrontTechMask():
    r"""LSET_FrontTechMask() -> LSET"""
    return _pcbnew.LSET_FrontTechMask()

def LSET_FrontBoardTechMask():
    r"""LSET_FrontBoardTechMask() -> LSET"""
    return _pcbnew.LSET_FrontBoardTechMask()

def LSET_BackTechMask():
    r"""LSET_BackTechMask() -> LSET"""
    return _pcbnew.LSET_BackTechMask()

def LSET_BackBoardTechMask():
    r"""LSET_BackBoardTechMask() -> LSET"""
    return _pcbnew.LSET_BackBoardTechMask()

def LSET_AllTechMask():
    r"""LSET_AllTechMask() -> LSET"""
    return _pcbnew.LSET_AllTechMask()

def LSET_AllBoardTechMask():
    r"""LSET_AllBoardTechMask() -> LSET"""
    return _pcbnew.LSET_AllBoardTechMask()

def LSET_FrontMask():
    r"""LSET_FrontMask() -> LSET"""
    return _pcbnew.LSET_FrontMask()

def LSET_BackMask():
    r"""LSET_BackMask() -> LSET"""
    return _pcbnew.LSET_BackMask()

def LSET_UserMask():
    r"""LSET_UserMask() -> LSET"""
    return _pcbnew.LSET_UserMask()

def LSET_ForbiddenFootprintLayers():
    r"""LSET_ForbiddenFootprintLayers() -> LSET"""
    return _pcbnew.LSET_ForbiddenFootprintLayers()

def LSET_ForbiddenTextLayers():
    r"""LSET_ForbiddenTextLayers() -> LSET"""
    return _pcbnew.LSET_ForbiddenTextLayers()


def IsValidLayer(aLayerId):
    r"""IsValidLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsValidLayer(aLayerId)

def IsPcbLayer(aLayer):
    r"""IsPcbLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsPcbLayer(aLayer)

def IsCopperLayer(aLayerId):
    r"""IsCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsCopperLayer(aLayerId)

def IsNonCopperLayer(aLayerId):
    r"""IsNonCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsNonCopperLayer(aLayerId)

def IsUserLayer(aLayerId):
    r"""IsUserLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsUserLayer(aLayerId)

def IsFrontLayer(aLayerId):
    r"""IsFrontLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsFrontLayer(aLayerId)

def IsBackLayer(aLayerId):
    r"""IsBackLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsBackLayer(aLayerId)

def FlipLayer(aLayerId, aCopperLayersCount=0):
    r"""FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount=0) -> PCB_LAYER_ID"""
    return _pcbnew.FlipLayer(aLayerId, aCopperLayersCount)

def FlipLayerMask(aMask, aCopperLayersCount=0):
    r"""FlipLayerMask(LSET aMask, int aCopperLayersCount=0) -> LSET"""
    return _pcbnew.FlipLayerMask(aMask, aCopperLayersCount)

def GetNetnameLayer(aLayer):
    r"""GetNetnameLayer(int aLayer) -> int"""
    return _pcbnew.GetNetnameLayer(aLayer)

def IsNetnameLayer(aLayer):
    r"""IsNetnameLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsNetnameLayer(aLayer)

def IsDCodeLayer(aLayer):
    r"""IsDCodeLayer(int aLayer) -> bool"""
    return _pcbnew.IsDCodeLayer(aLayer)

def ToLAYER_ID(aLayer):
    r"""ToLAYER_ID(int aLayer) -> PCB_LAYER_ID"""
    return _pcbnew.ToLAYER_ID(aLayer)
class VIA_DIMENSION_Vector(object):
    r"""Proxy of C++ std::vector< VIA_DIMENSION > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(VIA_DIMENSION_Vector self) -> SwigPyIterator"""
        return _pcbnew.VIA_DIMENSION_Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector___bool__(self)

    def __len__(self):
        r"""__len__(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector___len__(self)

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_pop(self)

    def append(self, x):
        r"""append(VIA_DIMENSION_Vector self, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_append(self, x)

    def empty(self):
        r"""empty(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector_empty(self)

    def size(self):
        r"""size(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector_size(self)

    def swap(self, v):
        r"""swap(VIA_DIMENSION_Vector self, VIA_DIMENSION_Vector v)"""
        return _pcbnew.VIA_DIMENSION_Vector_swap(self, v)

    def begin(self):
        r"""begin(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_begin(self)

    def end(self):
        r"""end(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_end(self)

    def rbegin(self):
        r"""rbegin(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::reverse_iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_rbegin(self)

    def rend(self):
        r"""rend(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::reverse_iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_rend(self)

    def clear(self):
        r"""clear(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_clear(self)

    def get_allocator(self):
        r"""get_allocator(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::allocator_type"""
        return _pcbnew.VIA_DIMENSION_Vector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_pop_back(self)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(VIA_DIMENSION_Vector self) -> VIA_DIMENSION_Vector
        __init__(VIA_DIMENSION_Vector self, VIA_DIMENSION_Vector other) -> VIA_DIMENSION_Vector
        __init__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type size) -> VIA_DIMENSION_Vector
        __init__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type size, VIA_DIMENSION value) -> VIA_DIMENSION_Vector
        """
        _pcbnew.VIA_DIMENSION_Vector_swiginit(self, _pcbnew.new_VIA_DIMENSION_Vector(*args))

    def push_back(self, x):
        r"""push_back(VIA_DIMENSION_Vector self, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_push_back(self, x)

    def front(self):
        r"""front(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_front(self)

    def back(self):
        r"""back(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_back(self)

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type n)"""
        return _pcbnew.VIA_DIMENSION_Vector_reserve(self, n)

    def capacity(self):
        r"""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

# Register VIA_DIMENSION_Vector in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ LAYER class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(LAYER self) -> LAYER"""
        _pcbnew.LAYER_swiginit(self, _pcbnew.new_LAYER())

    def clear(self):
        r"""clear(LAYER self)"""
        return _pcbnew.LAYER_clear(self)
    m_name = property(_pcbnew.LAYER_m_name_get, _pcbnew.LAYER_m_name_set, doc=r"""m_name : wxString""")
    m_type = property(_pcbnew.LAYER_m_type_get, _pcbnew.LAYER_m_type_set, doc=r"""m_type : LAYER_T""")
    m_visible = property(_pcbnew.LAYER_m_visible_get, _pcbnew.LAYER_m_visible_set, doc=r"""m_visible : bool""")
    m_number = property(_pcbnew.LAYER_m_number_get, _pcbnew.LAYER_m_number_set, doc=r"""m_number : int""")

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

    @staticmethod
    def ParseType(aType):
        r"""ParseType(char const * aType) -> LAYER_T"""
        return _pcbnew.LAYER_ParseType(aType)
    __swig_destroy__ = _pcbnew.delete_LAYER

# Register LAYER in _pcbnew:
_pcbnew.LAYER_swigregister(LAYER)

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

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

class HIGH_LIGHT_INFO(object):
    r"""Proxy of C++ HIGH_LIGHT_INFO class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register HIGH_LIGHT_INFO in _pcbnew:
_pcbnew.HIGH_LIGHT_INFO_swigregister(HIGH_LIGHT_INFO)

class MARKERS(object):
    r"""Proxy of C++ std::vector< MARKER_PCB * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(MARKERS self) -> SwigPyIterator"""
        return _pcbnew.MARKERS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(MARKERS self) -> bool"""
        return _pcbnew.MARKERS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(MARKERS self) -> bool"""
        return _pcbnew.MARKERS___bool__(self)

    def __len__(self):
        r"""__len__(MARKERS self) -> std::vector< MARKER_PCB * >::size_type"""
        return _pcbnew.MARKERS___len__(self)

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(MARKERS self) -> MARKER_PCB"""
        return _pcbnew.MARKERS_pop(self)

    def append(self, x):
        r"""append(MARKERS self, MARKER_PCB x)"""
        return _pcbnew.MARKERS_append(self, x)

    def empty(self):
        r"""empty(MARKERS self) -> bool"""
        return _pcbnew.MARKERS_empty(self)

    def size(self):
        r"""size(MARKERS self) -> std::vector< MARKER_PCB * >::size_type"""
        return _pcbnew.MARKERS_size(self)

    def swap(self, v):
        r"""swap(MARKERS self, MARKERS v)"""
        return _pcbnew.MARKERS_swap(self, v)

    def begin(self):
        r"""begin(MARKERS self) -> std::vector< MARKER_PCB * >::iterator"""
        return _pcbnew.MARKERS_begin(self)

    def end(self):
        r"""end(MARKERS self) -> std::vector< MARKER_PCB * >::iterator"""
        return _pcbnew.MARKERS_end(self)

    def rbegin(self):
        r"""rbegin(MARKERS self) -> std::vector< MARKER_PCB * >::reverse_iterator"""
        return _pcbnew.MARKERS_rbegin(self)

    def rend(self):
        r"""rend(MARKERS self) -> std::vector< MARKER_PCB * >::reverse_iterator"""
        return _pcbnew.MARKERS_rend(self)

    def clear(self):
        r"""clear(MARKERS self)"""
        return _pcbnew.MARKERS_clear(self)

    def get_allocator(self):
        r"""get_allocator(MARKERS self) -> std::vector< MARKER_PCB * >::allocator_type"""
        return _pcbnew.MARKERS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(MARKERS self)"""
        return _pcbnew.MARKERS_pop_back(self)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(MARKERS self) -> MARKERS
        __init__(MARKERS self, MARKERS other) -> MARKERS
        __init__(MARKERS self, std::vector< MARKER_PCB * >::size_type size) -> MARKERS
        __init__(MARKERS self, std::vector< MARKER_PCB * >::size_type size, MARKER_PCB value) -> MARKERS
        """
        _pcbnew.MARKERS_swiginit(self, _pcbnew.new_MARKERS(*args))

    def push_back(self, x):
        r"""push_back(MARKERS self, MARKER_PCB x)"""
        return _pcbnew.MARKERS_push_back(self, x)

    def front(self):
        r"""front(MARKERS self) -> MARKER_PCB"""
        return _pcbnew.MARKERS_front(self)

    def back(self):
        r"""back(MARKERS self) -> MARKER_PCB"""
        return _pcbnew.MARKERS_back(self)

    def assign(self, n, x):
        r"""assign(MARKERS self, std::vector< MARKER_PCB * >::size_type n, MARKER_PCB x)"""
        return _pcbnew.MARKERS_assign(self, n, x)

    def resize(self, *args):
        r"""
        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):
        r"""
        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):
        r"""reserve(MARKERS self, std::vector< MARKER_PCB * >::size_type n)"""
        return _pcbnew.MARKERS_reserve(self, n)

    def capacity(self):
        r"""capacity(MARKERS self) -> std::vector< MARKER_PCB * >::size_type"""
        return _pcbnew.MARKERS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_MARKERS

# Register MARKERS in _pcbnew:
_pcbnew.MARKERS_swigregister(MARKERS)

class ZONE_CONTAINERS(object):
    r"""Proxy of C++ std::vector< ZONE_CONTAINER * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(ZONE_CONTAINERS self) -> SwigPyIterator"""
        return _pcbnew.ZONE_CONTAINERS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ZONE_CONTAINERS self) -> bool"""
        return _pcbnew.ZONE_CONTAINERS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ZONE_CONTAINERS self) -> bool"""
        return _pcbnew.ZONE_CONTAINERS___bool__(self)

    def __len__(self):
        r"""__len__(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::size_type"""
        return _pcbnew.ZONE_CONTAINERS___len__(self)

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(ZONE_CONTAINERS self) -> ZONE_CONTAINER"""
        return _pcbnew.ZONE_CONTAINERS_pop(self)

    def append(self, x):
        r"""append(ZONE_CONTAINERS self, ZONE_CONTAINER x)"""
        return _pcbnew.ZONE_CONTAINERS_append(self, x)

    def empty(self):
        r"""empty(ZONE_CONTAINERS self) -> bool"""
        return _pcbnew.ZONE_CONTAINERS_empty(self)

    def size(self):
        r"""size(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::size_type"""
        return _pcbnew.ZONE_CONTAINERS_size(self)

    def swap(self, v):
        r"""swap(ZONE_CONTAINERS self, ZONE_CONTAINERS v)"""
        return _pcbnew.ZONE_CONTAINERS_swap(self, v)

    def begin(self):
        r"""begin(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::iterator"""
        return _pcbnew.ZONE_CONTAINERS_begin(self)

    def end(self):
        r"""end(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::iterator"""
        return _pcbnew.ZONE_CONTAINERS_end(self)

    def rbegin(self):
        r"""rbegin(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::reverse_iterator"""
        return _pcbnew.ZONE_CONTAINERS_rbegin(self)

    def rend(self):
        r"""rend(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::reverse_iterator"""
        return _pcbnew.ZONE_CONTAINERS_rend(self)

    def clear(self):
        r"""clear(ZONE_CONTAINERS self)"""
        return _pcbnew.ZONE_CONTAINERS_clear(self)

    def get_allocator(self):
        r"""get_allocator(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::allocator_type"""
        return _pcbnew.ZONE_CONTAINERS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ZONE_CONTAINERS self)"""
        return _pcbnew.ZONE_CONTAINERS_pop_back(self)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(ZONE_CONTAINERS self) -> ZONE_CONTAINERS
        __init__(ZONE_CONTAINERS self, ZONE_CONTAINERS other) -> ZONE_CONTAINERS
        __init__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type size) -> ZONE_CONTAINERS
        __init__(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type size, ZONE_CONTAINER value) -> ZONE_CONTAINERS
        """
        _pcbnew.ZONE_CONTAINERS_swiginit(self, _pcbnew.new_ZONE_CONTAINERS(*args))

    def push_back(self, x):
        r"""push_back(ZONE_CONTAINERS self, ZONE_CONTAINER x)"""
        return _pcbnew.ZONE_CONTAINERS_push_back(self, x)

    def front(self):
        r"""front(ZONE_CONTAINERS self) -> ZONE_CONTAINER"""
        return _pcbnew.ZONE_CONTAINERS_front(self)

    def back(self):
        r"""back(ZONE_CONTAINERS self) -> ZONE_CONTAINER"""
        return _pcbnew.ZONE_CONTAINERS_back(self)

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(ZONE_CONTAINERS self, std::vector< ZONE_CONTAINER * >::size_type n)"""
        return _pcbnew.ZONE_CONTAINERS_reserve(self, n)

    def capacity(self):
        r"""capacity(ZONE_CONTAINERS self) -> std::vector< ZONE_CONTAINER * >::size_type"""
        return _pcbnew.ZONE_CONTAINERS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_ZONE_CONTAINERS

# Register ZONE_CONTAINERS in _pcbnew:
_pcbnew.ZONE_CONTAINERS_swigregister(ZONE_CONTAINERS)

class TRACKS(object):
    r"""Proxy of C++ std::vector< TRACK * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(TRACKS self) -> SwigPyIterator"""
        return _pcbnew.TRACKS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(TRACKS self) -> bool"""
        return _pcbnew.TRACKS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(TRACKS self) -> bool"""
        return _pcbnew.TRACKS___bool__(self)

    def __len__(self):
        r"""__len__(TRACKS self) -> std::vector< TRACK * >::size_type"""
        return _pcbnew.TRACKS___len__(self)

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __delitem__(TRACKS self, std::vector< TRACK * >::difference_type i)
        __delitem__(TRACKS self, PySliceObject * slice)
        """
        return _pcbnew.TRACKS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""pop(TRACKS self) -> TRACK"""
        return _pcbnew.TRACKS_pop(self)

    def append(self, x):
        r"""append(TRACKS self, TRACK x)"""
        return _pcbnew.TRACKS_append(self, x)

    def empty(self):
        r"""empty(TRACKS self) -> bool"""
        return _pcbnew.TRACKS_empty(self)

    def size(self):
        r"""size(TRACKS self) -> std::vector< TRACK * >::size_type"""
        return _pcbnew.TRACKS_size(self)

    def swap(self, v):
        r"""swap(TRACKS self, TRACKS v)"""
        return _pcbnew.TRACKS_swap(self, v)

    def begin(self):
        r"""begin(TRACKS self) -> std::vector< TRACK * >::iterator"""
        return _pcbnew.TRACKS_begin(self)

    def end(self):
        r"""end(TRACKS self) -> std::vector< TRACK * >::iterator"""
        return _pcbnew.TRACKS_end(self)

    def rbegin(self):
        r"""rbegin(TRACKS self) -> std::vector< TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rbegin(self)

    def rend(self):
        r"""rend(TRACKS self) -> std::vector< TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rend(self)

    def clear(self):
        r"""clear(TRACKS self)"""
        return _pcbnew.TRACKS_clear(self)

    def get_allocator(self):
        r"""get_allocator(TRACKS self) -> std::vector< TRACK * >::allocator_type"""
        return _pcbnew.TRACKS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(TRACKS self)"""
        return _pcbnew.TRACKS_pop_back(self)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(TRACKS self) -> TRACKS
        __init__(TRACKS self, TRACKS other) -> TRACKS
        __init__(TRACKS self, std::vector< TRACK * >::size_type size) -> TRACKS
        __init__(TRACKS self, std::vector< TRACK * >::size_type size, TRACK value) -> TRACKS
        """
        _pcbnew.TRACKS_swiginit(self, _pcbnew.new_TRACKS(*args))

    def push_back(self, x):
        r"""push_back(TRACKS self, TRACK x)"""
        return _pcbnew.TRACKS_push_back(self, x)

    def front(self):
        r"""front(TRACKS self) -> TRACK"""
        return _pcbnew.TRACKS_front(self)

    def back(self):
        r"""back(TRACKS self) -> TRACK"""
        return _pcbnew.TRACKS_back(self)

    def assign(self, n, x):
        r"""assign(TRACKS self, std::vector< TRACK * >::size_type n, TRACK x)"""
        return _pcbnew.TRACKS_assign(self, n, x)

    def resize(self, *args):
        r"""
        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):
        r"""
        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):
        r"""reserve(TRACKS self, std::vector< TRACK * >::size_type n)"""
        return _pcbnew.TRACKS_reserve(self, n)

    def capacity(self):
        r"""capacity(TRACKS self) -> std::vector< TRACK * >::size_type"""
        return _pcbnew.TRACKS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_TRACKS

# Register TRACKS in _pcbnew:
_pcbnew.TRACKS_swigregister(TRACKS)

class BOARD(BOARD_ITEM_CONTAINER):
    r"""Proxy of C++ BOARD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

    def GetFileName(self):
        r"""GetFileName(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetFileName(self)
    m_Status_Pcb = property(_pcbnew.BOARD_m_Status_Pcb_get, _pcbnew.BOARD_m_Status_Pcb_set, doc=r"""m_Status_Pcb : int""")
    m_Modules = property(_pcbnew.BOARD_m_Modules_get, _pcbnew.BOARD_m_Modules_set, doc=r"""m_Modules : DLIST<(MODULE)>""")
    m_Track = property(_pcbnew.BOARD_m_Track_get, _pcbnew.BOARD_m_Track_set, doc=r"""m_Track : DLIST<(TRACK)>""")
    m_SegZoneDeprecated = property(_pcbnew.BOARD_m_SegZoneDeprecated_get, _pcbnew.BOARD_m_SegZoneDeprecated_set, doc=r"""m_SegZoneDeprecated : DLIST<(SEGZONE)>""")

    def Tracks(self):
        r"""Tracks(BOARD self) -> DLIST_ITERATOR_WRAPPER< TRACK >"""
        return _pcbnew.BOARD_Tracks(self)

    def Modules(self):
        r"""Modules(BOARD self) -> DLIST_ITERATOR_WRAPPER< MODULE >"""
        return _pcbnew.BOARD_Modules(self)

    def Drawings(self):
        r"""Drawings(BOARD self) -> DLIST_ITERATOR_WRAPPER< BOARD_ITEM >"""
        return _pcbnew.BOARD_Drawings(self)

    def Zones(self):
        r"""Zones(BOARD self) -> ZONE_CONTAINERS"""
        return _pcbnew.BOARD_Zones(self)

    def AllConnectedItems(self):
        r"""AllConnectedItems(BOARD self) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.BOARD_AllConnectedItems(self)

    def DrawingsList(self):
        r"""DrawingsList(BOARD self) -> BOARD_ITEM_List"""
        return _pcbnew.BOARD_DrawingsList(self)
    m_CurrentZoneContour = property(_pcbnew.BOARD_m_CurrentZoneContour_get, _pcbnew.BOARD_m_CurrentZoneContour_set, doc=r"""m_CurrentZoneContour : p.ZONE_CONTAINER""")

    def __init__(self):
        r"""__init__(BOARD self) -> BOARD"""
        _pcbnew.BOARD_swiginit(self, _pcbnew.new_BOARD())
    __swig_destroy__ = _pcbnew.delete_BOARD

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

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

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

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

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

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

    def AddNative(self, aItem, aMode=ADD_INSERT):
        r"""AddNative(BOARD self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)"""
        return _pcbnew.BOARD_AddNative(self, aItem, aMode)

    def RemoveNative(self, aBoardItem):
        r"""RemoveNative(BOARD self, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_RemoveNative(self, aBoardItem)

    def GetItem(self, aWeakReference):
        r"""GetItem(BOARD self, void * aWeakReference) -> BOARD_ITEM"""
        return _pcbnew.BOARD_GetItem(self, aWeakReference)

    def Duplicate(self, aItem, aAddToBoard=False):
        r"""Duplicate(BOARD self, BOARD_ITEM aItem, bool aAddToBoard=False) -> BOARD_ITEM"""
        return _pcbnew.BOARD_Duplicate(self, aItem, aAddToBoard)

    def GetConnectivity(self):
        r"""GetConnectivity(BOARD self) -> std::shared_ptr< CONNECTIVITY_DATA >"""
        return _pcbnew.BOARD_GetConnectivity(self)

    def BuildConnectivity(self):
        r"""BuildConnectivity(BOARD self)"""
        return _pcbnew.BOARD_BuildConnectivity(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def IsElementVisible(self, aLayer):
        r"""IsElementVisible(BOARD self, GAL_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsElementVisible(self, aLayer)

    def SetElementVisibility(self, aLayer, aNewState):
        r"""SetElementVisibility(BOARD self, GAL_LAYER_ID aLayer, bool aNewState)"""
        return _pcbnew.BOARD_SetElementVisibility(self, aLayer, aNewState)

    def IsModuleLayerVisible(self, aLayer):
        r"""IsModuleLayerVisible(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsModuleLayerVisible(self, aLayer)

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

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

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

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

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

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

    def GetTitleBlock(self):
        r"""GetTitleBlock(BOARD self) -> TITLE_BLOCK"""
        return _pcbnew.BOARD_GetTitleBlock(self)

    def SetTitleBlock(self, aTitleBlock):
        r"""SetTitleBlock(BOARD self, TITLE_BLOCK aTitleBlock)"""
        return _pcbnew.BOARD_SetTitleBlock(self, aTitleBlock)

    def GetZoneSettings(self):
        r"""GetZoneSettings(BOARD self) -> ZONE_SETTINGS"""
        return _pcbnew.BOARD_GetZoneSettings(self)

    def SetZoneSettings(self, aSettings):
        r"""SetZoneSettings(BOARD self, ZONE_SETTINGS aSettings)"""
        return _pcbnew.BOARD_SetZoneSettings(self, aSettings)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(BOARD self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.BOARD_GetSelectMenuText(self, aUnits)

    def Colors(self):
        r"""Colors(BOARD self) -> COLORS_DESIGN_SETTINGS"""
        return _pcbnew.BOARD_Colors(self)

    def SetColorsSettings(self, aColorsSettings):
        r"""SetColorsSettings(BOARD self, COLORS_DESIGN_SETTINGS aColorsSettings)"""
        return _pcbnew.BOARD_SetColorsSettings(self, aColorsSettings)

    def GetBoardPolygonOutlines(self, aOutlines, aErrorText=None, aErrorLocation=None):
        r"""GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET aOutlines, wxString aErrorText=None, wxPoint aErrorLocation=None) -> bool"""
        return _pcbnew.BOARD_GetBoardPolygonOutlines(self, aOutlines, aErrorText, aErrorLocation)

    def ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines):
        r"""ConvertBrdLayerToPolygonalContours(BOARD self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aOutlines)"""
        return _pcbnew.BOARD_ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines)

    def GetLayerID(self, aLayerName):
        r"""GetLayerID(BOARD self, wxString aLayerName) -> PCB_LAYER_ID const"""
        return _pcbnew.BOARD_GetLayerID(self, aLayerName)

    def GetLayerName(self, aLayer):
        r"""GetLayerName(BOARD self, PCB_LAYER_ID aLayer) -> wxString"""
        return _pcbnew.BOARD_GetLayerName(self, aLayer)

    def SetLayerName(self, aLayer, aLayerName):
        r"""SetLayerName(BOARD self, PCB_LAYER_ID aLayer, wxString aLayerName) -> bool"""
        return _pcbnew.BOARD_SetLayerName(self, aLayer, aLayerName)

    @staticmethod
    def GetStandardLayerName(aLayerId):
        r"""GetStandardLayerName(PCB_LAYER_ID aLayerId) -> wxString"""
        return _pcbnew.BOARD_GetStandardLayerName(aLayerId)

    def SetLayerDescr(self, aIndex, aLayer):
        r"""SetLayerDescr(BOARD self, PCB_LAYER_ID aIndex, LAYER aLayer) -> bool"""
        return _pcbnew.BOARD_SetLayerDescr(self, aIndex, aLayer)

    def GetLayerType(self, aLayer):
        r"""GetLayerType(BOARD self, PCB_LAYER_ID aLayer) -> LAYER_T"""
        return _pcbnew.BOARD_GetLayerType(self, aLayer)

    def SetLayerType(self, aLayer, aLayerType):
        r"""SetLayerType(BOARD self, PCB_LAYER_ID aLayer, LAYER_T aLayerType) -> bool"""
        return _pcbnew.BOARD_SetLayerType(self, aLayer, aLayerType)

    def GetNumSegmTrack(self):
        r"""GetNumSegmTrack(BOARD self) -> int"""
        return _pcbnew.BOARD_GetNumSegmTrack(self)

    def GetNumSegmZone(self):
        r"""GetNumSegmZone(BOARD self) -> int"""
        return _pcbnew.BOARD_GetNumSegmZone(self)

    def GetNodesCount(self, aNet=-1):
        r"""GetNodesCount(BOARD self, int aNet=-1) -> unsigned int"""
        return _pcbnew.BOARD_GetNodesCount(self, aNet)

    def GetUnconnectedNetCount(self):
        r"""GetUnconnectedNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetUnconnectedNetCount(self)

    def GetPadCount(self):
        r"""GetPadCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetPadCount(self)

    def GetPads(self):
        r"""GetPads(BOARD self) -> D_PADS"""
        return _pcbnew.BOARD_GetPads(self)

    def BuildListOfNets(self):
        r"""BuildListOfNets(BOARD self)"""
        return _pcbnew.BOARD_BuildListOfNets(self)

    def FindNet(self, *args):
        r"""
        FindNet(BOARD self, int aNetcode) -> NETINFO_ITEM
        FindNet(BOARD self, wxString aNetname) -> NETINFO_ITEM
        """
        return _pcbnew.BOARD_FindNet(self, *args)

    def GetNetInfo(self):
        r"""GetNetInfo(BOARD self) -> NETINFO_LIST"""
        return _pcbnew.BOARD_GetNetInfo(self)

    def GetNetCount(self):
        r"""GetNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetNetCount(self)

    def ComputeBoundingBox(self, aBoardEdgesOnly=False):
        r"""ComputeBoundingBox(BOARD self, bool aBoardEdgesOnly=False) -> EDA_RECT"""
        return _pcbnew.BOARD_ComputeBoundingBox(self, aBoardEdgesOnly)

    def GetBoundingBox(self):
        r"""GetBoundingBox(BOARD self) -> EDA_RECT"""
        return _pcbnew.BOARD_GetBoundingBox(self)

    def GetBoardEdgesBoundingBox(self):
        r"""GetBoardEdgesBoundingBox(BOARD self) -> EDA_RECT"""
        return _pcbnew.BOARD_GetBoardEdgesBoundingBox(self)

    def GetMsgPanelInfo(self, aUnits, aList):
        r"""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):
        r"""Draw(BOARD self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.BOARD_Draw(self, *args)

    def DrawHighLight(self, aDrawPanel, aDC, aNetCode):
        r"""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):
        r"""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):
        r"""FindModuleByReference(BOARD self, wxString aReference) -> MODULE"""
        return _pcbnew.BOARD_FindModuleByReference(self, aReference)

    def FindModule(self, aRefOrTimeStamp, aSearchByTimeStamp=False):
        r"""FindModule(BOARD self, wxString aRefOrTimeStamp, bool aSearchByTimeStamp=False) -> MODULE"""
        return _pcbnew.BOARD_FindModule(self, aRefOrTimeStamp, aSearchByTimeStamp)

    def ReplaceNetlist(self, aNetlist, aDeleteSinglePadNets, aNewFootprints, aReporter):
        r"""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):
        r"""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):
        r"""SortedNetnamesList(BOARD self, wxArrayString & aNames, bool aSortbyPadsCount) -> int"""
        return _pcbnew.BOARD_SortedNetnamesList(self, aNames, aSortbyPadsCount)

    def SynchronizeNetsAndNetClasses(self):
        r"""SynchronizeNetsAndNetClasses(BOARD self)"""
        return _pcbnew.BOARD_SynchronizeNetsAndNetClasses(self)

    def GetClass(self):
        r"""GetClass(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetClass(self)

    def HitTestForAnyFilledArea(self, aRefPos, aStartLayer, aEndLayer, aNetCode):
        r"""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):
        r"""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):
        r"""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):
        r"""SetAreasNetCodesFromNetNames(BOARD self) -> int"""
        return _pcbnew.BOARD_SetAreasNetCodesFromNetNames(self)

    def GetArea(self, index):
        r"""GetArea(BOARD self, int index) -> ZONE_CONTAINER"""
        return _pcbnew.BOARD_GetArea(self, index)

    def GetAreaIndex(self, aArea):
        r"""GetAreaIndex(BOARD self, ZONE_CONTAINER aArea) -> int"""
        return _pcbnew.BOARD_GetAreaIndex(self, aArea)

    def GetAreaCount(self):
        r"""GetAreaCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetAreaCount(self)

    def AddArea(self, aNewZonesList, aNetcode, aLayer, aStartPointPosition, aHatch):
        r"""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):
        r"""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):
        r"""NormalizeAreaPolygon(BOARD self, PICKED_ITEMS_LIST * aNewZonesList, ZONE_CONTAINER aCurrArea) -> bool"""
        return _pcbnew.BOARD_NormalizeAreaPolygon(self, aNewZonesList, aCurrArea)

    def OnAreaPolygonModified(self, aModifiedZonesList, modified_area):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""GetViaByPosition(BOARD self, wxPoint aPosition, PCB_LAYER_ID aLayer=PCB_LAYER_ID( -1 )) -> VIA"""
        return _pcbnew.BOARD_GetViaByPosition(self, *args)

    def GetTracksByPosition(self, *args):
        r"""GetTracksByPosition(BOARD self, wxPoint aPosition, PCB_LAYER_ID aLayer=PCB_LAYER_ID( -1 )) -> std::list< TRACK *,std::allocator< TRACK * > >"""
        return _pcbnew.BOARD_GetTracksByPosition(self, *args)

    def GetPadFast(self, aPosition, aLayerMask):
        r"""GetPadFast(BOARD self, wxPoint aPosition, LSET aLayerMask) -> D_PAD"""
        return _pcbnew.BOARD_GetPadFast(self, aPosition, aLayerMask)

    def GetPad(self, *args):
        r"""
        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):
        r"""PadDelete(BOARD self, D_PAD aPad)"""
        return _pcbnew.BOARD_PadDelete(self, aPad)

    def GetSortedPadListByXthenYCoord(self, aVector, aNetCode=-1):
        r"""GetSortedPadListByXthenYCoord(BOARD self, D_PADS aVector, int aNetCode=-1)"""
        return _pcbnew.BOARD_GetSortedPadListByXthenYCoord(self, aVector, aNetCode)

    def GetVisibleTrack(self, aStartingTrace, aPosition, aLayerSet):
        r"""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):
        r"""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):
        r"""TracksInNet(BOARD self, int aNetCode) -> TRACKS"""
        return _pcbnew.BOARD_TracksInNet(self, aNetCode)

    def TracksInNetBetweenPoints(self, aStartPos, aGoalPos, aNetCode):
        r"""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):
        r"""GetFootprint(BOARD self, wxPoint aPosition, PCB_LAYER_ID aActiveLayer, bool aVisibleOnly, bool aIgnoreLocked=False) -> MODULE"""
        return _pcbnew.BOARD_GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked)

    def GetLockPoint(self, aPosition, aLayerMask):
        r"""GetLockPoint(BOARD self, wxPoint aPosition, LSET aLayerMask) -> BOARD_CONNECTED_ITEM"""
        return _pcbnew.BOARD_GetLockPoint(self, aPosition, aLayerMask)

    def CreateLockPoint(self, aPosition, aSegment, aList):
        r"""CreateLockPoint(BOARD self, wxPoint aPosition, TRACK aSegment, PICKED_ITEMS_LIST * aList) -> TRACK"""
        return _pcbnew.BOARD_CreateLockPoint(self, aPosition, aSegment, aList)

    def ClearAllNetCodes(self):
        r"""ClearAllNetCodes(BOARD self)"""
        return _pcbnew.BOARD_ClearAllNetCodes(self)

    def SanitizeNetcodes(self):
        r"""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


# Register BOARD in _pcbnew:
_pcbnew.BOARD_swigregister(BOARD)

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

def BOARD_GetStandardLayerName(aLayerId):
    r"""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):
    r"""Proxy of C++ MODULE_3D_SETTINGS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(MODULE_3D_SETTINGS self) -> MODULE_3D_SETTINGS"""
        _pcbnew.MODULE_3D_SETTINGS_swiginit(self, _pcbnew.new_MODULE_3D_SETTINGS())
    m_Scale = property(_pcbnew.MODULE_3D_SETTINGS_m_Scale_get, _pcbnew.MODULE_3D_SETTINGS_m_Scale_set, doc=r"""m_Scale : MODULE_3D_SETTINGS::VECTOR3D""")
    m_Rotation = property(_pcbnew.MODULE_3D_SETTINGS_m_Rotation_get, _pcbnew.MODULE_3D_SETTINGS_m_Rotation_set, doc=r"""m_Rotation : MODULE_3D_SETTINGS::VECTOR3D""")
    m_Offset = property(_pcbnew.MODULE_3D_SETTINGS_m_Offset_get, _pcbnew.MODULE_3D_SETTINGS_m_Offset_set, doc=r"""m_Offset : MODULE_3D_SETTINGS::VECTOR3D""")
    m_Filename = property(_pcbnew.MODULE_3D_SETTINGS_m_Filename_get, _pcbnew.MODULE_3D_SETTINGS_m_Filename_set, doc=r"""m_Filename : wxString""")
    m_Preview = property(_pcbnew.MODULE_3D_SETTINGS_m_Preview_get, _pcbnew.MODULE_3D_SETTINGS_m_Preview_set, doc=r"""m_Preview : bool""")
    __swig_destroy__ = _pcbnew.delete_MODULE_3D_SETTINGS

# Register MODULE_3D_SETTINGS in _pcbnew:
_pcbnew.MODULE_3D_SETTINGS_swigregister(MODULE_3D_SETTINGS)

class MODULE_3D_SETTINGS_VECTOR3D(object):
    r"""Proxy of C++ MODULE_3D_SETTINGS::VECTOR3D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_x_get, _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_x_set, doc=r"""x : double""")
    y = property(_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_y_get, _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_y_set, doc=r"""y : double""")
    z = property(_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_z_get, _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_z_set, doc=r"""z : double""")

    def __init__(self):
        r"""__init__(MODULE_3D_SETTINGS_VECTOR3D self) -> MODULE_3D_SETTINGS_VECTOR3D"""
        _pcbnew.MODULE_3D_SETTINGS_VECTOR3D_swiginit(self, _pcbnew.new_MODULE_3D_SETTINGS_VECTOR3D())
    __swig_destroy__ = _pcbnew.delete_MODULE_3D_SETTINGS_VECTOR3D

# Register MODULE_3D_SETTINGS_VECTOR3D in _pcbnew:
_pcbnew.MODULE_3D_SETTINGS_VECTOR3D_swigregister(MODULE_3D_SETTINGS_VECTOR3D)

class MODULE(BOARD_ITEM_CONTAINER):
    r"""Proxy of C++ MODULE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MODULE self, BOARD parent) -> MODULE
        __init__(MODULE self, MODULE aModule) -> MODULE
        """
        _pcbnew.MODULE_swiginit(self, _pcbnew.new_MODULE(*args))
    __swig_destroy__ = _pcbnew.delete_MODULE

    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.MODULE_ClassOf(aItem)

    def Next(self):
        r"""Next(MODULE self) -> MODULE"""
        return _pcbnew.MODULE_Next(self)

    def Back(self):
        r"""Back(MODULE self) -> MODULE"""
        return _pcbnew.MODULE_Back(self)

    def AddNative(self, aItem, aMode=ADD_INSERT):
        r"""AddNative(MODULE self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)"""
        return _pcbnew.MODULE_AddNative(self, aItem, aMode)

    def RemoveNative(self, aItem):
        r"""RemoveNative(MODULE self, BOARD_ITEM aItem)"""
        return _pcbnew.MODULE_RemoveNative(self, aItem)

    def ClearAllNets(self):
        r"""ClearAllNets(MODULE self)"""
        return _pcbnew.MODULE_ClearAllNets(self)

    def CalculateBoundingBox(self):
        r"""CalculateBoundingBox(MODULE self)"""
        return _pcbnew.MODULE_CalculateBoundingBox(self)

    def GetFootprintRect(self):
        r"""GetFootprintRect(MODULE self) -> EDA_RECT"""
        return _pcbnew.MODULE_GetFootprintRect(self)

    def GetBoundingPoly(self):
        r"""GetBoundingPoly(MODULE self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_GetBoundingPoly(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(MODULE self) -> EDA_RECT"""
        return _pcbnew.MODULE_GetBoundingBox(self)

    def PadsList(self, *args):
        r"""
        PadsList(MODULE self) -> PAD_List
        PadsList(MODULE self) -> PAD_List
        """
        return _pcbnew.MODULE_PadsList(self, *args)

    def GraphicalItemsList(self, *args):
        r"""
        GraphicalItemsList(MODULE self) -> BOARD_ITEM_List
        GraphicalItemsList(MODULE self) -> BOARD_ITEM_List
        """
        return _pcbnew.MODULE_GraphicalItemsList(self, *args)

    def Pads(self):
        r"""Pads(MODULE self) -> DLIST_ITERATOR_WRAPPER< D_PAD >"""
        return _pcbnew.MODULE_Pads(self)

    def GraphicalItems(self):
        r"""GraphicalItems(MODULE self) -> DLIST_ITERATOR_WRAPPER< BOARD_ITEM >"""
        return _pcbnew.MODULE_GraphicalItems(self)

    def Models(self, *args):
        r"""
        Models(MODULE self) -> MODULE_3D_SETTINGS_List
        Models(MODULE self) -> MODULE_3D_SETTINGS_List
        """
        return _pcbnew.MODULE_Models(self, *args)

    def SetPosition(self, aPos):
        r"""SetPosition(MODULE self, wxPoint aPos)"""
        return _pcbnew.MODULE_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(MODULE self) -> wxPoint"""
        return _pcbnew.MODULE_GetPosition(self)

    def SetOrientation(self, newangle):
        r"""SetOrientation(MODULE self, double newangle)"""
        return _pcbnew.MODULE_SetOrientation(self, newangle)

    def SetOrientationDegrees(self, aOrientation):
        r"""SetOrientationDegrees(MODULE self, double aOrientation)"""
        return _pcbnew.MODULE_SetOrientationDegrees(self, aOrientation)

    def GetOrientation(self):
        r"""GetOrientation(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientation(self)

    def GetOrientationDegrees(self):
        r"""GetOrientationDegrees(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientationDegrees(self)

    def GetOrientationRadians(self):
        r"""GetOrientationRadians(MODULE self) -> double"""
        return _pcbnew.MODULE_GetOrientationRadians(self)

    def GetFPID(self):
        r"""GetFPID(MODULE self) -> LIB_ID"""
        return _pcbnew.MODULE_GetFPID(self)

    def SetFPID(self, aFPID):
        r"""SetFPID(MODULE self, LIB_ID aFPID)"""
        return _pcbnew.MODULE_SetFPID(self, aFPID)

    def GetDescription(self):
        r"""GetDescription(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetDescription(self)

    def SetDescription(self, aDoc):
        r"""SetDescription(MODULE self, wxString aDoc)"""
        return _pcbnew.MODULE_SetDescription(self, aDoc)

    def GetKeywords(self):
        r"""GetKeywords(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetKeywords(self)

    def SetKeywords(self, aKeywords):
        r"""SetKeywords(MODULE self, wxString aKeywords)"""
        return _pcbnew.MODULE_SetKeywords(self, aKeywords)

    def GetPath(self):
        r"""GetPath(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetPath(self)

    def SetPath(self, aPath):
        r"""SetPath(MODULE self, wxString aPath)"""
        return _pcbnew.MODULE_SetPath(self, aPath)

    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(MODULE self) -> int"""
        return _pcbnew.MODULE_GetLocalSolderMaskMargin(self)

    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(MODULE self, int aMargin)"""
        return _pcbnew.MODULE_SetLocalSolderMaskMargin(self, aMargin)

    def GetLocalClearance(self):
        r"""GetLocalClearance(MODULE self) -> int"""
        return _pcbnew.MODULE_GetLocalClearance(self)

    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(MODULE self, int aClearance)"""
        return _pcbnew.MODULE_SetLocalClearance(self, aClearance)

    def GetLocalSolderPasteMargin(self):
        r"""GetLocalSolderPasteMargin(MODULE self) -> int"""
        return _pcbnew.MODULE_GetLocalSolderPasteMargin(self)

    def SetLocalSolderPasteMargin(self, aMargin):
        r"""SetLocalSolderPasteMargin(MODULE self, int aMargin)"""
        return _pcbnew.MODULE_SetLocalSolderPasteMargin(self, aMargin)

    def GetLocalSolderPasteMarginRatio(self):
        r"""GetLocalSolderPasteMarginRatio(MODULE self) -> double"""
        return _pcbnew.MODULE_GetLocalSolderPasteMarginRatio(self)

    def SetLocalSolderPasteMarginRatio(self, aRatio):
        r"""SetLocalSolderPasteMarginRatio(MODULE self, double aRatio)"""
        return _pcbnew.MODULE_SetLocalSolderPasteMarginRatio(self, aRatio)

    def SetZoneConnection(self, aType):
        r"""SetZoneConnection(MODULE self, ZoneConnection aType)"""
        return _pcbnew.MODULE_SetZoneConnection(self, aType)

    def GetZoneConnection(self):
        r"""GetZoneConnection(MODULE self) -> ZoneConnection"""
        return _pcbnew.MODULE_GetZoneConnection(self)

    def SetThermalWidth(self, aWidth):
        r"""SetThermalWidth(MODULE self, int aWidth)"""
        return _pcbnew.MODULE_SetThermalWidth(self, aWidth)

    def GetThermalWidth(self):
        r"""GetThermalWidth(MODULE self) -> int"""
        return _pcbnew.MODULE_GetThermalWidth(self)

    def SetThermalGap(self, aGap):
        r"""SetThermalGap(MODULE self, int aGap)"""
        return _pcbnew.MODULE_SetThermalGap(self, aGap)

    def GetThermalGap(self):
        r"""GetThermalGap(MODULE self) -> int"""
        return _pcbnew.MODULE_GetThermalGap(self)

    def GetAttributes(self):
        r"""GetAttributes(MODULE self) -> int"""
        return _pcbnew.MODULE_GetAttributes(self)

    def SetAttributes(self, aAttributes):
        r"""SetAttributes(MODULE self, int aAttributes)"""
        return _pcbnew.MODULE_SetAttributes(self, aAttributes)

    def SetFlag(self, aFlag):
        r"""SetFlag(MODULE self, int aFlag)"""
        return _pcbnew.MODULE_SetFlag(self, aFlag)

    def IncrementFlag(self):
        r"""IncrementFlag(MODULE self)"""
        return _pcbnew.MODULE_IncrementFlag(self)

    def GetFlag(self):
        r"""GetFlag(MODULE self) -> int"""
        return _pcbnew.MODULE_GetFlag(self)

    def IsNetTie(self):
        r"""IsNetTie(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsNetTie(self)

    def Move(self, aMoveVector):
        r"""Move(MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(MODULE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MODULE_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(MODULE self, wxPoint aCentre)"""
        return _pcbnew.MODULE_Flip(self, aCentre)

    def MoveAnchorPosition(self, aMoveVector):
        r"""MoveAnchorPosition(MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_MoveAnchorPosition(self, aMoveVector)

    def IsFlipped(self):
        r"""IsFlipped(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsFlipped(self)

    def IsLocked(self):
        r"""IsLocked(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsLocked(self)

    def SetLocked(self, isLocked):
        r"""SetLocked(MODULE self, bool isLocked)"""
        return _pcbnew.MODULE_SetLocked(self, isLocked)

    def IsPlaced(self):
        r"""IsPlaced(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsPlaced(self)

    def SetIsPlaced(self, isPlaced):
        r"""SetIsPlaced(MODULE self, bool isPlaced)"""
        return _pcbnew.MODULE_SetIsPlaced(self, isPlaced)

    def NeedsPlaced(self):
        r"""NeedsPlaced(MODULE self) -> bool"""
        return _pcbnew.MODULE_NeedsPlaced(self)

    def SetNeedsPlaced(self, needsPlaced):
        r"""SetNeedsPlaced(MODULE self, bool needsPlaced)"""
        return _pcbnew.MODULE_SetNeedsPlaced(self, needsPlaced)

    def PadsLocked(self):
        r"""PadsLocked(MODULE self) -> bool"""
        return _pcbnew.MODULE_PadsLocked(self)

    def SetPadsLocked(self, aPadsLocked):
        r"""SetPadsLocked(MODULE self, bool aPadsLocked)"""
        return _pcbnew.MODULE_SetPadsLocked(self, aPadsLocked)

    def SetLastEditTime(self, *args):
        r"""
        SetLastEditTime(MODULE self, timestamp_t aTime)
        SetLastEditTime(MODULE self)
        """
        return _pcbnew.MODULE_SetLastEditTime(self, *args)

    def GetLastEditTime(self):
        r"""GetLastEditTime(MODULE self) -> timestamp_t"""
        return _pcbnew.MODULE_GetLastEditTime(self)

    def Draw(self, *args):
        r"""Draw(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.MODULE_Draw(self, *args)

    def DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector):
        r"""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):
        r"""TransformPadsShapesWithClearanceToPolygon(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)"""
        return _pcbnew.MODULE_TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper)

    def TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts=0, aIncludeText=True):
        r"""TransformGraphicShapesWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0, bool aIncludeText=True)"""
        return _pcbnew.MODULE_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts, aIncludeText)

    def TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts=0):
        r"""TransformGraphicTextWithClearanceToPolygonSet(MODULE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0)"""
        return _pcbnew.MODULE_TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts)

    def DrawEdgesOnly(self, panel, DC, offset, draw_mode):
        r"""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):
        r"""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):
        r"""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):
        r"""HitTestAccurate(MODULE self, wxPoint aPosition) -> bool"""
        return _pcbnew.MODULE_HitTestAccurate(self, aPosition)

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

    def GetReference(self):
        r"""GetReference(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetReference(self)

    def SetReference(self, aReference):
        r"""SetReference(MODULE self, wxString aReference)"""
        return _pcbnew.MODULE_SetReference(self, aReference)

    def IncrementReference(self, aDelta):
        r"""IncrementReference(MODULE self, int aDelta)"""
        return _pcbnew.MODULE_IncrementReference(self, aDelta)

    def GetValue(self):
        r"""GetValue(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetValue(self)

    def SetValue(self, aValue):
        r"""SetValue(MODULE self, wxString aValue)"""
        return _pcbnew.MODULE_SetValue(self, aValue)

    def Value(self, *args):
        r"""
        Value(MODULE self) -> TEXTE_MODULE
        Value(MODULE self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_Value(self, *args)

    def Reference(self, *args):
        r"""
        Reference(MODULE self) -> TEXTE_MODULE
        Reference(MODULE self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_Reference(self, *args)

    def FindPadByName(self, aPadName):
        r"""FindPadByName(MODULE self, wxString aPadName) -> D_PAD"""
        return _pcbnew.MODULE_FindPadByName(self, aPadName)

    def GetPad(self, *args):
        r"""GetPad(MODULE self, wxPoint aPosition, LSET aLayerMask=LSET::AllLayersMask()) -> D_PAD"""
        return _pcbnew.MODULE_GetPad(self, *args)

    def GetTopLeftPad(self):
        r"""GetTopLeftPad(MODULE self) -> D_PAD"""
        return _pcbnew.MODULE_GetTopLeftPad(self)

    def GetPadCount(self, *args):
        r"""GetPadCount(MODULE self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.MODULE_GetPadCount(self, *args)

    def GetUniquePadCount(self, *args):
        r"""GetUniquePadCount(MODULE self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.MODULE_GetUniquePadCount(self, *args)

    def GetNextPadName(self, aFillSequenceGaps):
        r"""GetNextPadName(MODULE self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_GetNextPadName(self, aFillSequenceGaps)

    def GetArea(self, aPadding=0):
        r"""GetArea(MODULE self, int aPadding=0) -> double"""
        return _pcbnew.MODULE_GetArea(self, aPadding)

    def GetLink(self):
        r"""GetLink(MODULE self) -> timestamp_t"""
        return _pcbnew.MODULE_GetLink(self)

    def SetLink(self, aLink):
        r"""SetLink(MODULE self, timestamp_t aLink)"""
        return _pcbnew.MODULE_SetLink(self, aLink)

    def GetPlacementCost180(self):
        r"""GetPlacementCost180(MODULE self) -> int"""
        return _pcbnew.MODULE_GetPlacementCost180(self)

    def SetPlacementCost180(self, aCost):
        r"""SetPlacementCost180(MODULE self, int aCost)"""
        return _pcbnew.MODULE_SetPlacementCost180(self, aCost)

    def GetPlacementCost90(self):
        r"""GetPlacementCost90(MODULE self) -> int"""
        return _pcbnew.MODULE_GetPlacementCost90(self)

    def SetPlacementCost90(self, aCost):
        r"""SetPlacementCost90(MODULE self, int aCost)"""
        return _pcbnew.MODULE_SetPlacementCost90(self, aCost)

    def Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule=False):
        r"""Duplicate(MODULE self, BOARD_ITEM aItem, bool aIncrementPadNumbers, bool aAddToModule=False) -> BOARD_ITEM"""
        return _pcbnew.MODULE_Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule)

    def Add3DModel(self, a3DModel):
        r"""Add3DModel(MODULE self, MODULE_3D_SETTINGS a3DModel)"""
        return _pcbnew.MODULE_Add3DModel(self, a3DModel)

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

    def GetClass(self):
        r"""GetClass(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(MODULE self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.MODULE_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(MODULE self) -> BITMAP_DEF"""
        return _pcbnew.MODULE_GetMenuImage(self)

    def Clone(self):
        r"""Clone(MODULE self) -> EDA_ITEM"""
        return _pcbnew.MODULE_Clone(self)

    def RunOnChildren(self, aFunction):
        r"""RunOnChildren(MODULE self, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.MODULE_RunOnChildren(self, aFunction)

    def GetAllDrawingLayers(self, aLayers, aCount, aIncludePads=True):
        r"""GetAllDrawingLayers(MODULE self, int [] aLayers, int & aCount, bool aIncludePads=True)"""
        return _pcbnew.MODULE_GetAllDrawingLayers(self, aLayers, aCount, aIncludePads)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(MODULE self, int [] aLayers, int & aCount)"""
        return _pcbnew.MODULE_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(MODULE self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.MODULE_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self):
        r"""ViewBBox(MODULE self) -> BOX2I const"""
        return _pcbnew.MODULE_ViewBBox(self)

    def CopyNetlistSettings(self, aModule, aCopyLocalSettings):
        r"""CopyNetlistSettings(MODULE self, MODULE aModule, bool aCopyLocalSettings)"""
        return _pcbnew.MODULE_CopyNetlistSettings(self, aModule, aCopyLocalSettings)

    @staticmethod
    def IsLibNameValid(aName):
        r"""IsLibNameValid(wxString aName) -> bool"""
        return _pcbnew.MODULE_IsLibNameValid(aName)

    @staticmethod
    def StringLibNameInvalidChars(aUserReadable):
        r"""StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
        return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)

    def SetInitialComments(self, aInitialComments):
        r"""SetInitialComments(MODULE self, wxArrayString * aInitialComments)"""
        return _pcbnew.MODULE_SetInitialComments(self, aInitialComments)

    def CoverageRatio(self, aCollector):
        r"""CoverageRatio(MODULE self, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.MODULE_CoverageRatio(self, aCollector)

    def GetInitialComments(self):
        r"""GetInitialComments(MODULE self) -> wxArrayString const *"""
        return _pcbnew.MODULE_GetInitialComments(self)

    def GetPolyCourtyardFront(self):
        r"""GetPolyCourtyardFront(MODULE self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_GetPolyCourtyardFront(self)

    def GetPolyCourtyardBack(self):
        r"""GetPolyCourtyardBack(MODULE self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_GetPolyCourtyardBack(self)

    def BuildPolyCourtyard(self):
        r"""BuildPolyCourtyard(MODULE self) -> bool"""
        return _pcbnew.MODULE_BuildPolyCourtyard(self)

    def SwapData(self, aImage):
        r"""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
    #


# Register MODULE in _pcbnew:
_pcbnew.MODULE_swigregister(MODULE)

def MODULE_ClassOf(aItem):
    r"""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):
    r"""MODULE_IsLibNameValid(wxString aName) -> bool"""
    return _pcbnew.MODULE_IsLibNameValid(aName)

def MODULE_StringLibNameInvalidChars(aUserReadable):
    r"""MODULE_StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
    return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)

class MODULE_List(DHEAD):
    r"""Proxy of C++ DLIST< MODULE > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def Get(self):
        r"""Get(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Get(self)

    def __deref__(self):
        r"""__deref__(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List___deref__(self)

    def GetFirst(self):
        r"""GetFirst(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_GetFirst(self)

    def GetLast(self):
        r"""GetLast(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_GetLast(self)

    def Append(self, *args):
        r"""
        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):
        r"""Insert(MODULE_List self, MODULE aNewElement, MODULE aElementAfterMe)"""
        return _pcbnew.MODULE_List_Insert(self, aNewElement, aElementAfterMe)

    def Remove(self, aElement):
        r"""Remove(MODULE_List self, MODULE aElement) -> MODULE"""
        return _pcbnew.MODULE_List_Remove(self, aElement)

    def begin(self):
        r"""begin(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_begin(self)

    def end(self):
        r"""end(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_end(self)

    def PopFront(self):
        r"""PopFront(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_PopFront(self)

    def PopBack(self):
        r"""PopBack(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_PopBack(self)

    def PushFront(self, aNewElement):
        r"""PushFront(MODULE_List self, MODULE aNewElement)"""
        return _pcbnew.MODULE_List_PushFront(self, aNewElement)

    def PushBack(self, aNewElement):
        r"""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):
        r"""__init__(MODULE_List self) -> MODULE_List"""
        _pcbnew.MODULE_List_swiginit(self, _pcbnew.new_MODULE_List())
    __swig_destroy__ = _pcbnew.delete_MODULE_List

    def ClassOf(self, aItem):
        r"""ClassOf(MODULE_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.MODULE_List_ClassOf(self, aItem)

    def Next(self):
        r"""Next(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Next(self)

    def Back(self):
        r"""Back(MODULE_List self) -> MODULE"""
        return _pcbnew.MODULE_List_Back(self)

    def AddNative(self, aItem, aMode=ADD_INSERT):
        r"""AddNative(MODULE_List self, BOARD_ITEM aItem, ADD_MODE aMode=ADD_INSERT)"""
        return _pcbnew.MODULE_List_AddNative(self, aItem, aMode)

    def RemoveNative(self, aItem):
        r"""RemoveNative(MODULE_List self, BOARD_ITEM aItem)"""
        return _pcbnew.MODULE_List_RemoveNative(self, aItem)

    def ClearAllNets(self):
        r"""ClearAllNets(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearAllNets(self)

    def CalculateBoundingBox(self):
        r"""CalculateBoundingBox(MODULE_List self)"""
        return _pcbnew.MODULE_List_CalculateBoundingBox(self)

    def GetFootprintRect(self):
        r"""GetFootprintRect(MODULE_List self) -> EDA_RECT"""
        return _pcbnew.MODULE_List_GetFootprintRect(self)

    def GetBoundingPoly(self):
        r"""GetBoundingPoly(MODULE_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_List_GetBoundingPoly(self)

    def GetBoundingBox(self):
        r"""GetBoundingBox(MODULE_List self) -> EDA_RECT"""
        return _pcbnew.MODULE_List_GetBoundingBox(self)

    def PadsList(self, *args):
        r"""
        PadsList(MODULE_List self) -> PAD_List
        PadsList(MODULE_List self) -> PAD_List
        """
        return _pcbnew.MODULE_List_PadsList(self, *args)

    def GraphicalItemsList(self, *args):
        r"""
        GraphicalItemsList(MODULE_List self) -> BOARD_ITEM_List
        GraphicalItemsList(MODULE_List self) -> BOARD_ITEM_List
        """
        return _pcbnew.MODULE_List_GraphicalItemsList(self, *args)

    def Pads(self):
        r"""Pads(MODULE_List self) -> DLIST_ITERATOR_WRAPPER< D_PAD >"""
        return _pcbnew.MODULE_List_Pads(self)

    def GraphicalItems(self):
        r"""GraphicalItems(MODULE_List self) -> DLIST_ITERATOR_WRAPPER< BOARD_ITEM >"""
        return _pcbnew.MODULE_List_GraphicalItems(self)

    def Models(self, *args):
        r"""
        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):
        r"""SetPosition(MODULE_List self, wxPoint aPos)"""
        return _pcbnew.MODULE_List_SetPosition(self, aPos)

    def GetPosition(self):
        r"""GetPosition(MODULE_List self) -> wxPoint"""
        return _pcbnew.MODULE_List_GetPosition(self)

    def SetOrientation(self, newangle):
        r"""SetOrientation(MODULE_List self, double newangle)"""
        return _pcbnew.MODULE_List_SetOrientation(self, newangle)

    def SetOrientationDegrees(self, aOrientation):
        r"""SetOrientationDegrees(MODULE_List self, double aOrientation)"""
        return _pcbnew.MODULE_List_SetOrientationDegrees(self, aOrientation)

    def GetOrientation(self):
        r"""GetOrientation(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientation(self)

    def GetOrientationDegrees(self):
        r"""GetOrientationDegrees(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientationDegrees(self)

    def GetOrientationRadians(self):
        r"""GetOrientationRadians(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetOrientationRadians(self)

    def GetFPID(self):
        r"""GetFPID(MODULE_List self) -> LIB_ID"""
        return _pcbnew.MODULE_List_GetFPID(self)

    def SetFPID(self, aFPID):
        r"""SetFPID(MODULE_List self, LIB_ID aFPID)"""
        return _pcbnew.MODULE_List_SetFPID(self, aFPID)

    def GetDescription(self):
        r"""GetDescription(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetDescription(self)

    def SetDescription(self, aDoc):
        r"""SetDescription(MODULE_List self, wxString aDoc)"""
        return _pcbnew.MODULE_List_SetDescription(self, aDoc)

    def GetKeywords(self):
        r"""GetKeywords(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetKeywords(self)

    def SetKeywords(self, aKeywords):
        r"""SetKeywords(MODULE_List self, wxString aKeywords)"""
        return _pcbnew.MODULE_List_SetKeywords(self, aKeywords)

    def GetPath(self):
        r"""GetPath(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetPath(self)

    def SetPath(self, aPath):
        r"""SetPath(MODULE_List self, wxString aPath)"""
        return _pcbnew.MODULE_List_SetPath(self, aPath)

    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetLocalSolderMaskMargin(self)

    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(MODULE_List self, int aMargin)"""
        return _pcbnew.MODULE_List_SetLocalSolderMaskMargin(self, aMargin)

    def GetLocalClearance(self):
        r"""GetLocalClearance(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetLocalClearance(self)

    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(MODULE_List self, int aClearance)"""
        return _pcbnew.MODULE_List_SetLocalClearance(self, aClearance)

    def GetLocalSolderPasteMargin(self):
        r"""GetLocalSolderPasteMargin(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetLocalSolderPasteMargin(self)

    def SetLocalSolderPasteMargin(self, aMargin):
        r"""SetLocalSolderPasteMargin(MODULE_List self, int aMargin)"""
        return _pcbnew.MODULE_List_SetLocalSolderPasteMargin(self, aMargin)

    def GetLocalSolderPasteMarginRatio(self):
        r"""GetLocalSolderPasteMarginRatio(MODULE_List self) -> double"""
        return _pcbnew.MODULE_List_GetLocalSolderPasteMarginRatio(self)

    def SetLocalSolderPasteMarginRatio(self, aRatio):
        r"""SetLocalSolderPasteMarginRatio(MODULE_List self, double aRatio)"""
        return _pcbnew.MODULE_List_SetLocalSolderPasteMarginRatio(self, aRatio)

    def SetZoneConnection(self, aType):
        r"""SetZoneConnection(MODULE_List self, ZoneConnection aType)"""
        return _pcbnew.MODULE_List_SetZoneConnection(self, aType)

    def GetZoneConnection(self):
        r"""GetZoneConnection(MODULE_List self) -> ZoneConnection"""
        return _pcbnew.MODULE_List_GetZoneConnection(self)

    def SetThermalWidth(self, aWidth):
        r"""SetThermalWidth(MODULE_List self, int aWidth)"""
        return _pcbnew.MODULE_List_SetThermalWidth(self, aWidth)

    def GetThermalWidth(self):
        r"""GetThermalWidth(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetThermalWidth(self)

    def SetThermalGap(self, aGap):
        r"""SetThermalGap(MODULE_List self, int aGap)"""
        return _pcbnew.MODULE_List_SetThermalGap(self, aGap)

    def GetThermalGap(self):
        r"""GetThermalGap(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetThermalGap(self)

    def GetAttributes(self):
        r"""GetAttributes(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetAttributes(self)

    def SetAttributes(self, aAttributes):
        r"""SetAttributes(MODULE_List self, int aAttributes)"""
        return _pcbnew.MODULE_List_SetAttributes(self, aAttributes)

    def SetFlag(self, aFlag):
        r"""SetFlag(MODULE_List self, int aFlag)"""
        return _pcbnew.MODULE_List_SetFlag(self, aFlag)

    def IncrementFlag(self):
        r"""IncrementFlag(MODULE_List self)"""
        return _pcbnew.MODULE_List_IncrementFlag(self)

    def GetFlag(self):
        r"""GetFlag(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetFlag(self)

    def IsNetTie(self):
        r"""IsNetTie(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsNetTie(self)

    def Move(self, aMoveVector):
        r"""Move(MODULE_List self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_List_Move(self, aMoveVector)

    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(MODULE_List self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MODULE_List_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre):
        r"""Flip(MODULE_List self, wxPoint aCentre)"""
        return _pcbnew.MODULE_List_Flip(self, aCentre)

    def MoveAnchorPosition(self, aMoveVector):
        r"""MoveAnchorPosition(MODULE_List self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_List_MoveAnchorPosition(self, aMoveVector)

    def IsFlipped(self):
        r"""IsFlipped(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsFlipped(self)

    def IsLocked(self):
        r"""IsLocked(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsLocked(self)

    def SetLocked(self, isLocked):
        r"""SetLocked(MODULE_List self, bool isLocked)"""
        return _pcbnew.MODULE_List_SetLocked(self, isLocked)

    def IsPlaced(self):
        r"""IsPlaced(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsPlaced(self)

    def SetIsPlaced(self, isPlaced):
        r"""SetIsPlaced(MODULE_List self, bool isPlaced)"""
        return _pcbnew.MODULE_List_SetIsPlaced(self, isPlaced)

    def NeedsPlaced(self):
        r"""NeedsPlaced(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_NeedsPlaced(self)

    def SetNeedsPlaced(self, needsPlaced):
        r"""SetNeedsPlaced(MODULE_List self, bool needsPlaced)"""
        return _pcbnew.MODULE_List_SetNeedsPlaced(self, needsPlaced)

    def PadsLocked(self):
        r"""PadsLocked(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_PadsLocked(self)

    def SetPadsLocked(self, aPadsLocked):
        r"""SetPadsLocked(MODULE_List self, bool aPadsLocked)"""
        return _pcbnew.MODULE_List_SetPadsLocked(self, aPadsLocked)

    def SetLastEditTime(self, *args):
        r"""
        SetLastEditTime(MODULE_List self, timestamp_t aTime)
        SetLastEditTime(MODULE_List self)
        """
        return _pcbnew.MODULE_List_SetLastEditTime(self, *args)

    def GetLastEditTime(self):
        r"""GetLastEditTime(MODULE_List self) -> timestamp_t"""
        return _pcbnew.MODULE_List_GetLastEditTime(self)

    def Draw(self, *args):
        r"""Draw(MODULE_List self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset=)"""
        return _pcbnew.MODULE_List_Draw(self, *args)

    def DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector):
        r"""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):
        r"""TransformPadsShapesWithClearanceToPolygon(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)"""
        return _pcbnew.MODULE_List_TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper)

    def TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts=0, aIncludeText=True):
        r"""TransformGraphicShapesWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0, bool aIncludeText=True)"""
        return _pcbnew.MODULE_List_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts, aIncludeText)

    def TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts=0):
        r"""TransformGraphicTextWithClearanceToPolygonSet(MODULE_List self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, int aCircleToSegmentsCountForTexts=0)"""
        return _pcbnew.MODULE_List_TransformGraphicTextWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aCircleToSegmentsCountForTexts)

    def DrawEdgesOnly(self, panel, DC, offset, draw_mode):
        r"""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):
        r"""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):
        r"""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):
        r"""
        HitTest(MODULE_List self, wxPoint aPosition) -> bool
        HitTest(MODULE_List self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.MODULE_List_HitTest(self, *args)

    def HitTestAccurate(self, aPosition):
        r"""HitTestAccurate(MODULE_List self, wxPoint aPosition) -> bool"""
        return _pcbnew.MODULE_List_HitTestAccurate(self, aPosition)

    def GetReference(self):
        r"""GetReference(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetReference(self)

    def SetReference(self, aReference):
        r"""SetReference(MODULE_List self, wxString aReference)"""
        return _pcbnew.MODULE_List_SetReference(self, aReference)

    def IncrementReference(self, aDelta):
        r"""IncrementReference(MODULE_List self, int aDelta)"""
        return _pcbnew.MODULE_List_IncrementReference(self, aDelta)

    def GetValue(self):
        r"""GetValue(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetValue(self)

    def SetValue(self, aValue):
        r"""SetValue(MODULE_List self, wxString aValue)"""
        return _pcbnew.MODULE_List_SetValue(self, aValue)

    def Value(self, *args):
        r"""
        Value(MODULE_List self) -> TEXTE_MODULE
        Value(MODULE_List self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_List_Value(self, *args)

    def Reference(self, *args):
        r"""
        Reference(MODULE_List self) -> TEXTE_MODULE
        Reference(MODULE_List self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_List_Reference(self, *args)

    def FindPadByName(self, aPadName):
        r"""FindPadByName(MODULE_List self, wxString aPadName) -> D_PAD"""
        return _pcbnew.MODULE_List_FindPadByName(self, aPadName)

    def GetPad(self, *args):
        r"""GetPad(MODULE_List self, wxPoint aPosition, LSET aLayerMask=LSET::AllLayersMask()) -> D_PAD"""
        return _pcbnew.MODULE_List_GetPad(self, *args)

    def GetTopLeftPad(self):
        r"""GetTopLeftPad(MODULE_List self) -> D_PAD"""
        return _pcbnew.MODULE_List_GetTopLeftPad(self)

    def GetPadCount(self, *args):
        r"""GetPadCount(MODULE_List self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.MODULE_List_GetPadCount(self, *args)

    def GetUniquePadCount(self, *args):
        r"""GetUniquePadCount(MODULE_List self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.MODULE_List_GetUniquePadCount(self, *args)

    def GetNextPadName(self, aFillSequenceGaps):
        r"""GetNextPadName(MODULE_List self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_List_GetNextPadName(self, aFillSequenceGaps)

    def GetArea(self, aPadding=0):
        r"""GetArea(MODULE_List self, int aPadding=0) -> double"""
        return _pcbnew.MODULE_List_GetArea(self, aPadding)

    def GetLink(self):
        r"""GetLink(MODULE_List self) -> timestamp_t"""
        return _pcbnew.MODULE_List_GetLink(self)

    def SetLink(self, aLink):
        r"""SetLink(MODULE_List self, timestamp_t aLink)"""
        return _pcbnew.MODULE_List_SetLink(self, aLink)

    def GetPlacementCost180(self):
        r"""GetPlacementCost180(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetPlacementCost180(self)

    def SetPlacementCost180(self, aCost):
        r"""SetPlacementCost180(MODULE_List self, int aCost)"""
        return _pcbnew.MODULE_List_SetPlacementCost180(self, aCost)

    def GetPlacementCost90(self):
        r"""GetPlacementCost90(MODULE_List self) -> int"""
        return _pcbnew.MODULE_List_GetPlacementCost90(self)

    def SetPlacementCost90(self, aCost):
        r"""SetPlacementCost90(MODULE_List self, int aCost)"""
        return _pcbnew.MODULE_List_SetPlacementCost90(self, aCost)

    def Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule=False):
        r"""Duplicate(MODULE_List self, BOARD_ITEM aItem, bool aIncrementPadNumbers, bool aAddToModule=False) -> BOARD_ITEM"""
        return _pcbnew.MODULE_List_Duplicate(self, aItem, aIncrementPadNumbers, aAddToModule)

    def Add3DModel(self, a3DModel):
        r"""Add3DModel(MODULE_List self, MODULE_3D_SETTINGS a3DModel)"""
        return _pcbnew.MODULE_List_Add3DModel(self, a3DModel)

    def Visit(self, inspector, testData, scanTypes):
        r"""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):
        r"""GetClass(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetClass(self)

    def GetSelectMenuText(self, aUnits):
        r"""GetSelectMenuText(MODULE_List self, EDA_UNITS_T aUnits) -> wxString"""
        return _pcbnew.MODULE_List_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self):
        r"""GetMenuImage(MODULE_List self) -> BITMAP_DEF"""
        return _pcbnew.MODULE_List_GetMenuImage(self)

    def Clone(self):
        r"""Clone(MODULE_List self) -> EDA_ITEM"""
        return _pcbnew.MODULE_List_Clone(self)

    def RunOnChildren(self, aFunction):
        r"""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):
        r"""GetAllDrawingLayers(MODULE_List self, int [] aLayers, int & aCount, bool aIncludePads=True)"""
        return _pcbnew.MODULE_List_GetAllDrawingLayers(self, aLayers, aCount, aIncludePads)

    def ViewGetLayers(self, aLayers, aCount):
        r"""ViewGetLayers(MODULE_List self, int [] aLayers, int & aCount)"""
        return _pcbnew.MODULE_List_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(MODULE_List self, int aLayer, KIGFX::VIEW * aView) -> unsigned int"""
        return _pcbnew.MODULE_List_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self):
        r"""ViewBBox(MODULE_List self) -> BOX2I const"""
        return _pcbnew.MODULE_List_ViewBBox(self)

    def CopyNetlistSettings(self, aModule, aCopyLocalSettings):
        r"""CopyNetlistSettings(MODULE_List self, MODULE aModule, bool aCopyLocalSettings)"""
        return _pcbnew.MODULE_List_CopyNetlistSettings(self, aModule, aCopyLocalSettings)

    def IsLibNameValid(self, aName):
        r"""IsLibNameValid(MODULE_List self, wxString aName) -> bool"""
        return _pcbnew.MODULE_List_IsLibNameValid(self, aName)

    def StringLibNameInvalidChars(self, aUserReadable):
        r"""StringLibNameInvalidChars(MODULE_List self, bool aUserReadable) -> wxChar const *"""
        return _pcbnew.MODULE_List_StringLibNameInvalidChars(self, aUserReadable)

    def SetInitialComments(self, aInitialComments):
        r"""SetInitialComments(MODULE_List self, wxArrayString * aInitialComments)"""
        return _pcbnew.MODULE_List_SetInitialComments(self, aInitialComments)

    def CoverageRatio(self, aCollector):
        r"""CoverageRatio(MODULE_List self, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.MODULE_List_CoverageRatio(self, aCollector)

    def GetInitialComments(self):
        r"""GetInitialComments(MODULE_List self) -> wxArrayString const *"""
        return _pcbnew.MODULE_List_GetInitialComments(self)

    def GetPolyCourtyardFront(self):
        r"""GetPolyCourtyardFront(MODULE_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_List_GetPolyCourtyardFront(self)

    def GetPolyCourtyardBack(self):
        r"""GetPolyCourtyardBack(MODULE_List self) -> SHAPE_POLY_SET"""
        return _pcbnew.MODULE_List_GetPolyCourtyardBack(self)

    def BuildPolyCourtyard(self):
        r"""BuildPolyCourtyard(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_BuildPolyCourtyard(self)

    def SwapData(self, aImage):
        r"""SwapData(MODULE_List self, BOARD_ITEM aImage)"""
        return _pcbnew.MODULE_List_SwapData(self, aImage)

    def DeleteNative(self, aItem):
        r"""DeleteNative(MODULE_List self, BOARD_ITEM aItem)"""
        return _pcbnew.MODULE_List_DeleteNative(self, aItem)

    def GetCenter(self):
        r"""GetCenter(MODULE_List self) -> wxPoint"""
        return _pcbnew.MODULE_List_GetCenter(self)

    def IsConnected(self):
        r"""IsConnected(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsConnected(self)

    def GetParent(self):
        r"""GetParent(MODULE_List self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.MODULE_List_GetParent(self)

    def GetLayer(self):
        r"""GetLayer(MODULE_List self) -> PCB_LAYER_ID"""
        return _pcbnew.MODULE_List_GetLayer(self)

    def GetLayerSet(self):
        r"""GetLayerSet(MODULE_List self) -> LSET"""
        return _pcbnew.MODULE_List_GetLayerSet(self)

    def SetLayer(self, aLayer):
        r"""SetLayer(MODULE_List self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.MODULE_List_SetLayer(self, aLayer)

    def IsOnLayer(self, aLayer):
        r"""IsOnLayer(MODULE_List self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.MODULE_List_IsOnLayer(self, aLayer)

    def IsTrack(self):
        r"""IsTrack(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsTrack(self)

    def UnLink(self):
        r"""UnLink(MODULE_List self)"""
        return _pcbnew.MODULE_List_UnLink(self)

    def DeleteStructure(self):
        r"""DeleteStructure(MODULE_List self)"""
        return _pcbnew.MODULE_List_DeleteStructure(self)

    def ShowShape(self, aShape):
        r"""ShowShape(MODULE_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.MODULE_List_ShowShape(self, aShape)

    def GetBoard(self):
        r"""GetBoard(MODULE_List self) -> BOARD"""
        return _pcbnew.MODULE_List_GetBoard(self)

    def GetLayerName(self):
        r"""GetLayerName(MODULE_List self) -> wxString"""
        return _pcbnew.MODULE_List_GetLayerName(self)

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

    def Type(self):
        r"""Type(MODULE_List self) -> KICAD_T"""
        return _pcbnew.MODULE_List_Type(self)

    def SetTimeStamp(self, aNewTimeStamp):
        r"""SetTimeStamp(MODULE_List self, timestamp_t aNewTimeStamp)"""
        return _pcbnew.MODULE_List_SetTimeStamp(self, aNewTimeStamp)

    def GetTimeStamp(self):
        r"""GetTimeStamp(MODULE_List self) -> timestamp_t"""
        return _pcbnew.MODULE_List_GetTimeStamp(self)

    def GetList(self):
        r"""GetList(MODULE_List self) -> DHEAD"""
        return _pcbnew.MODULE_List_GetList(self)

    def SetParent(self, aParent):
        r"""SetParent(MODULE_List self, EDA_ITEM aParent)"""
        return _pcbnew.MODULE_List_SetParent(self, aParent)

    def SetList(self, aList):
        r"""SetList(MODULE_List self, DHEAD aList)"""
        return _pcbnew.MODULE_List_SetList(self, aList)

    def IsNew(self):
        r"""IsNew(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsNew(self)

    def IsModified(self):
        r"""IsModified(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsModified(self)

    def IsMoving(self):
        r"""IsMoving(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsMoving(self)

    def IsDragging(self):
        r"""IsDragging(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsDragging(self)

    def IsWireImage(self):
        r"""IsWireImage(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsWireImage(self)

    def IsSelected(self):
        r"""IsSelected(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsSelected(self)

    def IsResized(self):
        r"""IsResized(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsResized(self)

    def IsHighlighted(self):
        r"""IsHighlighted(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsHighlighted(self)

    def IsBrightened(self):
        r"""IsBrightened(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsBrightened(self)

    def SetWireImage(self):
        r"""SetWireImage(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetWireImage(self)

    def SetSelected(self):
        r"""SetSelected(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetSelected(self)

    def SetHighlighted(self):
        r"""SetHighlighted(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetHighlighted(self)

    def SetBrightened(self):
        r"""SetBrightened(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetBrightened(self)

    def ClearSelected(self):
        r"""ClearSelected(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearSelected(self)

    def ClearHighlighted(self):
        r"""ClearHighlighted(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearHighlighted(self)

    def ClearBrightened(self):
        r"""ClearBrightened(MODULE_List self)"""
        return _pcbnew.MODULE_List_ClearBrightened(self)

    def SetModified(self):
        r"""SetModified(MODULE_List self)"""
        return _pcbnew.MODULE_List_SetModified(self)

    def GetState(self, type):
        r"""GetState(MODULE_List self, int type) -> int"""
        return _pcbnew.MODULE_List_GetState(self, type)

    def SetState(self, type, state):
        r"""SetState(MODULE_List self, int type, int state)"""
        return _pcbnew.MODULE_List_SetState(self, type, state)

    def GetStatus(self):
        r"""GetStatus(MODULE_List self) -> STATUS_FLAGS"""
        return _pcbnew.MODULE_List_GetStatus(self)

    def SetStatus(self, aStatus):
        r"""SetStatus(MODULE_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.MODULE_List_SetStatus(self, aStatus)

    def SetFlags(self, aMask):
        r"""SetFlags(MODULE_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.MODULE_List_SetFlags(self, aMask)

    def ClearFlags(self, aMask=-1):
        r"""ClearFlags(MODULE_List self, STATUS_FLAGS aMask=-1)"""
        return _pcbnew.MODULE_List_ClearFlags(self, aMask)

    def GetFlags(self):
        r"""GetFlags(MODULE_List self) -> STATUS_FLAGS"""
        return _pcbnew.MODULE_List_GetFlags(self)

    def IsType(self, aScanTypes):
        r"""IsType(MODULE_List self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.MODULE_List_IsType(self, aScanTypes)

    def SetForceVisible(self, aEnable):
        r"""SetForceVisible(MODULE_List self, bool aEnable)"""
        return _pcbnew.MODULE_List_SetForceVisible(self, aEnable)

    def IterateForward(self, listStart, inspector, testData, scanTypes):
        r"""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):
        r"""Matches(MODULE_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.MODULE_List_Matches(self, aSearchData, aAuxData, aFindLocation)

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

    def IsReplaceable(self):
        r"""IsReplaceable(MODULE_List self) -> bool"""
        return _pcbnew.MODULE_List_IsReplaceable(self)

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

    def Sort(self, aLeft, aRight):
        r"""Sort(MODULE_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.MODULE_List_Sort(self, aLeft, aRight)

# Register MODULE_List in _pcbnew:
_pcbnew.MODULE_List_swigregister(MODULE_List)

class MODULE_3D_SETTINGS_List(object):
    r"""Proxy of C++ std::list< MODULE_3D_SETTINGS > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(MODULE_3D_SETTINGS_List self) -> SwigPyIterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(MODULE_3D_SETTINGS_List self) -> bool"""
        return _pcbnew.MODULE_3D_SETTINGS_List___nonzero__(self)

    def __bool__(self):
        r"""__bool__(MODULE_3D_SETTINGS_List self) -> bool"""
        return _pcbnew.MODULE_3D_SETTINGS_List___bool__(self)

    def __len__(self):
        r"""__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):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS"""
        return _pcbnew.MODULE_3D_SETTINGS_List_pop(self)

    def append(self, x):
        r"""append(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_append(self, x)

    def empty(self):
        r"""empty(MODULE_3D_SETTINGS_List self) -> bool"""
        return _pcbnew.MODULE_3D_SETTINGS_List_empty(self)

    def size(self):
        r"""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):
        r"""swap(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS_List v)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_swap(self, v)

    def begin(self):
        r"""begin(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_begin(self)

    def end(self):
        r"""end(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_end(self)

    def rbegin(self):
        r"""rbegin(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::reverse_iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_rbegin(self)

    def rend(self):
        r"""rend(MODULE_3D_SETTINGS_List self) -> std::list< MODULE_3D_SETTINGS >::reverse_iterator"""
        return _pcbnew.MODULE_3D_SETTINGS_List_rend(self)

    def clear(self):
        r"""clear(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_clear(self)

    def get_allocator(self):
        r"""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):
        r"""pop_back(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_pop_back(self)

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS_List
        __init__(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS_List other) -> MODULE_3D_SETTINGS_List
        __init__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::size_type size) -> MODULE_3D_SETTINGS_List
        __init__(MODULE_3D_SETTINGS_List self, std::list< MODULE_3D_SETTINGS >::size_type size, MODULE_3D_SETTINGS value) -> MODULE_3D_SETTINGS_List
        """
        _pcbnew.MODULE_3D_SETTINGS_List_swiginit(self, _pcbnew.new_MODULE_3D_SETTINGS_List(*args))

    def push_back(self, x):
        r"""push_back(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_push_back(self, x)

    def front(self):
        r"""front(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS"""
        return _pcbnew.MODULE_3D_SETTINGS_List_front(self)

    def back(self):
        r"""back(MODULE_3D_SETTINGS_List self) -> MODULE_3D_SETTINGS"""
        return _pcbnew.MODULE_3D_SETTINGS_List_back(self)

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""pop_front(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_pop_front(self)

    def push_front(self, x):
        r"""push_front(MODULE_3D_SETTINGS_List self, MODULE_3D_SETTINGS x)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_push_front(self, x)

    def reverse(self):
        r"""reverse(MODULE_3D_SETTINGS_List self)"""
        return _pcbnew.MODULE_3D_SETTINGS_List_reverse(self)
    __swig_destroy__ = _pcbnew.delete_MODULE_3D_SETTINGS_List

# Register MODULE_3D_SETTINGS_List in _pcbnew:
_pcbnew.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):
    r"""Proxy of C++ PYTHON_FOOTPRINT_WIZARD_LIST class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def register_wizard(wizard):
        r"""register_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard)

    @staticmethod
    def deregister_wizard(wizard):
        r"""deregister_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard)

    def __init__(self):
        r"""__init__(PYTHON_FOOTPRINT_WIZARD_LIST self) -> PYTHON_FOOTPRINT_WIZARD_LIST"""
        _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_swiginit(self, _pcbnew.new_PYTHON_FOOTPRINT_WIZARD_LIST())
    __swig_destroy__ = _pcbnew.delete_PYTHON_FOOTPRINT_WIZARD_LIST

# Register PYTHON_FOOTPRINT_WIZARD_LIST in _pcbnew:
_pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_swigregister(PYTHON_FOOTPRINT_WIZARD_LIST)

def PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard):
    r"""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):
    r"""PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard)

class PYTHON_ACTION_PLUGINS(object):
    r"""Proxy of C++ PYTHON_ACTION_PLUGINS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def register_action(wizard):
        r"""register_action(PyObject * wizard)"""
        return _pcbnew.PYTHON_ACTION_PLUGINS_register_action(wizard)

    @staticmethod
    def deregister_action(wizard):
        r"""deregister_action(PyObject * wizard)"""
        return _pcbnew.PYTHON_ACTION_PLUGINS_deregister_action(wizard)

    def __init__(self):
        r"""__init__(PYTHON_ACTION_PLUGINS self) -> PYTHON_ACTION_PLUGINS"""
        _pcbnew.PYTHON_ACTION_PLUGINS_swiginit(self, _pcbnew.new_PYTHON_ACTION_PLUGINS())
    __swig_destroy__ = _pcbnew.delete_PYTHON_ACTION_PLUGINS

# Register PYTHON_ACTION_PLUGINS in _pcbnew:
_pcbnew.PYTHON_ACTION_PLUGINS_swigregister(PYTHON_ACTION_PLUGINS)

def PYTHON_ACTION_PLUGINS_register_action(wizard):
    r"""PYTHON_ACTION_PLUGINS_register_action(PyObject * wizard)"""
    return _pcbnew.PYTHON_ACTION_PLUGINS_register_action(wizard)

def PYTHON_ACTION_PLUGINS_deregister_action(wizard):
    r"""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)



