pcbnew.py

Go to the documentation of this file.

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.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
# 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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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__)
 
 
 
import warnings
warnings.warn("The SWIG-based Python interface to the PCB editor is deprecated and will be removed "
              "in a future version of KiCad.  Please plan to move to the new IPC API and/or make "
              "use of the kicad-cli tool for your KiCad automation needs.",
               category=DeprecationWarning)
 
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):
        r"""reserve(string self, std::basic_string< char >::size_type __res_arg)"""
        return _pcbnew.string_reserve(self, __res_arg)
 
    def shrink_to_fit(self):
        r"""shrink_to_fit(string self)"""
        return _pcbnew.string_shrink_to_fit(self)
 
    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, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.string___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(string self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, string v)
        __setitem__(string self, SWIGPY_SLICEOBJECT * 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)
 
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.xx==other.x and self.yy==other.y and self.widthwidth==other.width and self.heightheight==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.xx==other.x and self.yy==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.xx = val
        elif index == 1:
            self.yy = 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.wxPoint_Vector___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(wxPoint_Vector self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, wxPoint_Vector v)
        __setitem__(wxPoint_Vector self, SWIGPY_SLICEOBJECT * 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)
SKETCH = _pcbnew.SKETCH
 
FILLED = _pcbnew.FILLED
 
class KIID(object):
    r"""Proxy of C++ KIID 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__(KIID self) -> KIID
        __init__(KIID self, int null) -> KIID
        __init__(KIID self, string aString) -> KIID
        __init__(KIID self, char const * aString) -> KIID
        __init__(KIID self, wxString aString) -> KIID
        __init__(KIID self, timestamp_t aTimestamp) -> KIID
        """
        _pcbnew.KIID_swiginit(self, _pcbnew.new_KIID(*args))
 
    def Clone(self, aUUID):
        r"""Clone(KIID self, KIID aUUID)"""
        return _pcbnew.KIID_Clone(self, aUUID)
 
    def Hash(self):
        r"""Hash(KIID self) -> size_t"""
        return _pcbnew.KIID_Hash(self)
 
    def IsLegacyTimestamp(self):
        r"""IsLegacyTimestamp(KIID self) -> bool"""
        return _pcbnew.KIID_IsLegacyTimestamp(self)
 
    def AsLegacyTimestamp(self):
        r"""AsLegacyTimestamp(KIID self) -> timestamp_t"""
        return _pcbnew.KIID_AsLegacyTimestamp(self)
 
    def AsString(self):
        r"""AsString(KIID self) -> wxString"""
        return _pcbnew.KIID_AsString(self)
 
    def AsLegacyTimestampString(self):
        r"""AsLegacyTimestampString(KIID self) -> wxString"""
        return _pcbnew.KIID_AsLegacyTimestampString(self)
 
    def AsStdString(self):
        r"""AsStdString(KIID self) -> string"""
        return _pcbnew.KIID_AsStdString(self)
 
    @staticmethod
    def SniffTest(aCandidate):
        r"""SniffTest(wxString aCandidate) -> bool"""
        return _pcbnew.KIID_SniffTest(aCandidate)
 
    @staticmethod
    def CreateNilUuids(aNil=True):
        r"""CreateNilUuids(bool aNil=True)"""
        return _pcbnew.KIID_CreateNilUuids(aNil)
 
    @staticmethod
    def SeedGenerator(aSeed):
        r"""SeedGenerator(unsigned int aSeed)"""
        return _pcbnew.KIID_SeedGenerator(aSeed)
 
    def ConvertTimestampToUuid(self):
        r"""ConvertTimestampToUuid(KIID self)"""
        return _pcbnew.KIID_ConvertTimestampToUuid(self)
 
    @staticmethod
    def Combine(aFirst, aSecond):
        r"""Combine(KIID aFirst, KIID aSecond) -> KIID"""
        return _pcbnew.KIID_Combine(aFirst, aSecond)
 
    def Increment(self):
        r"""Increment(KIID self)"""
        return _pcbnew.KIID_Increment(self)
 
    def __eq__(self, rhs):
        r"""__eq__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___eq__(self, rhs)
 
    def __ne__(self, rhs):
        r"""__ne__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___ne__(self, rhs)
 
    def __lt__(self, rhs):
        r"""__lt__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___lt__(self, rhs)
 
    def __gt__(self, rhs):
        r"""__gt__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___gt__(self, rhs)
    __swig_destroy__ = _pcbnew.delete_KIID
 
# Register KIID in _pcbnew:
_pcbnew.KIID_swigregister(KIID)
 
def NilUuid():
    r"""NilUuid() -> KIID"""
    return _pcbnew.NilUuid()
class KIID_VECT_LIST(object):
    r"""Proxy of C++ std::vector< KIID > 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(KIID_VECT_LIST self) -> SwigPyIterator"""
        return _pcbnew.KIID_VECT_LIST_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(KIID_VECT_LIST self) -> bool"""
        return _pcbnew.KIID_VECT_LIST___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(KIID_VECT_LIST self) -> bool"""
        return _pcbnew.KIID_VECT_LIST___bool__(self)
 
    def __len__(self):
        r"""__len__(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
        return _pcbnew.KIID_VECT_LIST___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j) -> KIID_VECT_LIST"""
        return _pcbnew.KIID_VECT_LIST___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j)
        __setslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j, KIID_VECT_LIST v)
        """
        return _pcbnew.KIID_VECT_LIST___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j)"""
        return _pcbnew.KIID_VECT_LIST___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i)
        __delitem__(KIID_VECT_LIST self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.KIID_VECT_LIST___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(KIID_VECT_LIST self, SWIGPY_SLICEOBJECT * slice) -> KIID_VECT_LIST
        __getitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i) -> KIID
        """
        return _pcbnew.KIID_VECT_LIST___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(KIID_VECT_LIST self, SWIGPY_SLICEOBJECT * slice, KIID_VECT_LIST v)
        __setitem__(KIID_VECT_LIST self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, KIID x)
        """
        return _pcbnew.KIID_VECT_LIST___setitem__(self, *args)
 
    def pop(self):
        r"""pop(KIID_VECT_LIST self) -> KIID"""
        return _pcbnew.KIID_VECT_LIST_pop(self)
 
    def append(self, x):
        r"""append(KIID_VECT_LIST self, KIID x)"""
        return _pcbnew.KIID_VECT_LIST_append(self, x)
 
    def empty(self):
        r"""empty(KIID_VECT_LIST self) -> bool"""
        return _pcbnew.KIID_VECT_LIST_empty(self)
 
    def size(self):
        r"""size(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
        return _pcbnew.KIID_VECT_LIST_size(self)
 
    def swap(self, v):
        r"""swap(KIID_VECT_LIST self, KIID_VECT_LIST v)"""
        return _pcbnew.KIID_VECT_LIST_swap(self, v)
 
    def begin(self):
        r"""begin(KIID_VECT_LIST self) -> std::vector< KIID >::iterator"""
        return _pcbnew.KIID_VECT_LIST_begin(self)
 
    def end(self):
        r"""end(KIID_VECT_LIST self) -> std::vector< KIID >::iterator"""
        return _pcbnew.KIID_VECT_LIST_end(self)
 
    def rbegin(self):
        r"""rbegin(KIID_VECT_LIST self) -> std::vector< KIID >::reverse_iterator"""
        return _pcbnew.KIID_VECT_LIST_rbegin(self)
 
    def rend(self):
        r"""rend(KIID_VECT_LIST self) -> std::vector< KIID >::reverse_iterator"""
        return _pcbnew.KIID_VECT_LIST_rend(self)
 
    def clear(self):
        r"""clear(KIID_VECT_LIST self)"""
        return _pcbnew.KIID_VECT_LIST_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(KIID_VECT_LIST self) -> std::vector< KIID >::allocator_type"""
        return _pcbnew.KIID_VECT_LIST_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(KIID_VECT_LIST self)"""
        return _pcbnew.KIID_VECT_LIST_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(KIID_VECT_LIST self, std::vector< KIID >::iterator pos) -> std::vector< KIID >::iterator
        erase(KIID_VECT_LIST self, std::vector< KIID >::iterator first, std::vector< KIID >::iterator last) -> std::vector< KIID >::iterator
        """
        return _pcbnew.KIID_VECT_LIST_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(KIID_VECT_LIST self) -> KIID_VECT_LIST
        __init__(KIID_VECT_LIST self, KIID_VECT_LIST other) -> KIID_VECT_LIST
        __init__(KIID_VECT_LIST self, std::vector< KIID >::size_type size) -> KIID_VECT_LIST
        __init__(KIID_VECT_LIST self, std::vector< KIID >::size_type size, KIID value) -> KIID_VECT_LIST
        """
        _pcbnew.KIID_VECT_LIST_swiginit(self, _pcbnew.new_KIID_VECT_LIST(*args))
 
    def push_back(self, x):
        r"""push_back(KIID_VECT_LIST self, KIID x)"""
        return _pcbnew.KIID_VECT_LIST_push_back(self, x)
 
    def front(self):
        r"""front(KIID_VECT_LIST self) -> KIID"""
        return _pcbnew.KIID_VECT_LIST_front(self)
 
    def back(self):
        r"""back(KIID_VECT_LIST self) -> KIID"""
        return _pcbnew.KIID_VECT_LIST_back(self)
 
    def assign(self, n, x):
        r"""assign(KIID_VECT_LIST self, std::vector< KIID >::size_type n, KIID x)"""
        return _pcbnew.KIID_VECT_LIST_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(KIID_VECT_LIST self, std::vector< KIID >::size_type new_size)
        resize(KIID_VECT_LIST self, std::vector< KIID >::size_type new_size, KIID x)
        """
        return _pcbnew.KIID_VECT_LIST_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(KIID_VECT_LIST self, std::vector< KIID >::iterator pos, KIID x) -> std::vector< KIID >::iterator
        insert(KIID_VECT_LIST self, std::vector< KIID >::iterator pos, std::vector< KIID >::size_type n, KIID x)
        """
        return _pcbnew.KIID_VECT_LIST_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(KIID_VECT_LIST self, std::vector< KIID >::size_type n)"""
        return _pcbnew.KIID_VECT_LIST_reserve(self, n)
 
    def capacity(self):
        r"""capacity(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
        return _pcbnew.KIID_VECT_LIST_capacity(self)
    __swig_destroy__ = _pcbnew.delete_KIID_VECT_LIST
 
# Register KIID_VECT_LIST in _pcbnew:
_pcbnew.KIID_VECT_LIST_swigregister(KIID_VECT_LIST)
class KIID_PATH(KIID_VECT_LIST):
    r"""Proxy of C++ KIID_PATH 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__(KIID_PATH self) -> KIID_PATH
        __init__(KIID_PATH self, wxString aString) -> KIID_PATH
        """
        _pcbnew.KIID_PATH_swiginit(self, _pcbnew.new_KIID_PATH(*args))
 
    def MakeRelativeTo(self, aPath):
        r"""MakeRelativeTo(KIID_PATH self, KIID_PATH aPath) -> bool"""
        return _pcbnew.KIID_PATH_MakeRelativeTo(self, aPath)
 
    def EndsWith(self, aPath):
        r"""EndsWith(KIID_PATH self, KIID_PATH aPath) -> bool"""
        return _pcbnew.KIID_PATH_EndsWith(self, aPath)
 
    def AsString(self):
        r"""AsString(KIID_PATH self) -> wxString"""
        return _pcbnew.KIID_PATH_AsString(self)
 
    def __eq__(self, rhs):
        r"""__eq__(KIID_PATH self, KIID_PATH rhs) -> bool"""
        return _pcbnew.KIID_PATH___eq__(self, rhs)
 
    def __lt__(self, rhs):
        r"""__lt__(KIID_PATH self, KIID_PATH rhs) -> bool"""
        return _pcbnew.KIID_PATH___lt__(self, rhs)
 
    def __gt__(self, rhs):
        r"""__gt__(KIID_PATH self, KIID_PATH rhs) -> bool"""
        return _pcbnew.KIID_PATH___gt__(self, rhs)
 
    def __iadd__(self, aRhs):
        r"""__iadd__(KIID_PATH self, KIID_PATH aRhs) -> KIID_PATH"""
        return _pcbnew.KIID_PATH___iadd__(self, aRhs)
    __swig_destroy__ = _pcbnew.delete_KIID_PATH
 
# Register KIID_PATH in _pcbnew:
_pcbnew.KIID_PATH_swigregister(KIID_PATH)
class KIID_NIL_SET_RESET(object):
    r"""Proxy of C++ KIID_NIL_SET_RESET 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__(KIID_NIL_SET_RESET self) -> KIID_NIL_SET_RESET"""
        _pcbnew.KIID_NIL_SET_RESET_swiginit(self, _pcbnew.new_KIID_NIL_SET_RESET())
    __swig_destroy__ = _pcbnew.delete_KIID_NIL_SET_RESET
 
# Register KIID_NIL_SET_RESET in _pcbnew:
_pcbnew.KIID_NIL_SET_RESET_swigregister(KIID_NIL_SET_RESET)
NOT_USED = _pcbnew.NOT_USED
 
TYPE_NOT_INIT = _pcbnew.TYPE_NOT_INIT
 
PCB_T = _pcbnew.PCB_T
 
SCREEN_T = _pcbnew.SCREEN_T
 
PCB_FOOTPRINT_T = _pcbnew.PCB_FOOTPRINT_T
 
PCB_PAD_T = _pcbnew.PCB_PAD_T
 
PCB_SHAPE_T = _pcbnew.PCB_SHAPE_T
 
PCB_REFERENCE_IMAGE_T = _pcbnew.PCB_REFERENCE_IMAGE_T
 
PCB_FIELD_T = _pcbnew.PCB_FIELD_T
 
PCB_GENERATOR_T = _pcbnew.PCB_GENERATOR_T
 
PCB_TEXT_T = _pcbnew.PCB_TEXT_T
 
PCB_TEXTBOX_T = _pcbnew.PCB_TEXTBOX_T
 
PCB_TABLE_T = _pcbnew.PCB_TABLE_T
 
PCB_TABLECELL_T = _pcbnew.PCB_TABLECELL_T
 
PCB_TRACE_T = _pcbnew.PCB_TRACE_T
 
PCB_VIA_T = _pcbnew.PCB_VIA_T
 
PCB_ARC_T = _pcbnew.PCB_ARC_T
 
PCB_MARKER_T = _pcbnew.PCB_MARKER_T
 
PCB_DIMENSION_T = _pcbnew.PCB_DIMENSION_T
 
PCB_DIM_ALIGNED_T = _pcbnew.PCB_DIM_ALIGNED_T
 
PCB_DIM_LEADER_T = _pcbnew.PCB_DIM_LEADER_T
 
PCB_DIM_CENTER_T = _pcbnew.PCB_DIM_CENTER_T
 
PCB_DIM_RADIAL_T = _pcbnew.PCB_DIM_RADIAL_T
 
PCB_DIM_ORTHOGONAL_T = _pcbnew.PCB_DIM_ORTHOGONAL_T
 
PCB_TARGET_T = _pcbnew.PCB_TARGET_T
 
PCB_ZONE_T = _pcbnew.PCB_ZONE_T
 
PCB_ITEM_LIST_T = _pcbnew.PCB_ITEM_LIST_T
 
PCB_NETINFO_T = _pcbnew.PCB_NETINFO_T
 
PCB_GROUP_T = _pcbnew.PCB_GROUP_T
 
PCB_FIELD_LOCATE_REFERENCE_T = _pcbnew.PCB_FIELD_LOCATE_REFERENCE_T
 
PCB_FIELD_LOCATE_VALUE_T = _pcbnew.PCB_FIELD_LOCATE_VALUE_T
 
PCB_FIELD_LOCATE_FOOTPRINT_T = _pcbnew.PCB_FIELD_LOCATE_FOOTPRINT_T
 
PCB_FIELD_LOCATE_DATASHEET_T = _pcbnew.PCB_FIELD_LOCATE_DATASHEET_T
 
PCB_LOCATE_STDVIA_T = _pcbnew.PCB_LOCATE_STDVIA_T
 
PCB_LOCATE_UVIA_T = _pcbnew.PCB_LOCATE_UVIA_T
 
PCB_LOCATE_BBVIA_T = _pcbnew.PCB_LOCATE_BBVIA_T
 
PCB_LOCATE_TEXT_T = _pcbnew.PCB_LOCATE_TEXT_T
 
PCB_LOCATE_HOLE_T = _pcbnew.PCB_LOCATE_HOLE_T
 
PCB_LOCATE_PTH_T = _pcbnew.PCB_LOCATE_PTH_T
 
PCB_LOCATE_NPTH_T = _pcbnew.PCB_LOCATE_NPTH_T
 
PCB_LOCATE_BOARD_EDGE_T = _pcbnew.PCB_LOCATE_BOARD_EDGE_T
 
PCB_SHAPE_LOCATE_SEGMENT_T = _pcbnew.PCB_SHAPE_LOCATE_SEGMENT_T
 
PCB_SHAPE_LOCATE_RECT_T = _pcbnew.PCB_SHAPE_LOCATE_RECT_T
 
PCB_SHAPE_LOCATE_CIRCLE_T = _pcbnew.PCB_SHAPE_LOCATE_CIRCLE_T
 
PCB_SHAPE_LOCATE_ARC_T = _pcbnew.PCB_SHAPE_LOCATE_ARC_T
 
PCB_SHAPE_LOCATE_POLY_T = _pcbnew.PCB_SHAPE_LOCATE_POLY_T
 
PCB_SHAPE_LOCATE_BEZIER_T = _pcbnew.PCB_SHAPE_LOCATE_BEZIER_T
 
LIB_SYMBOL_T = _pcbnew.LIB_SYMBOL_T
 
SCH_SHAPE_T = _pcbnew.SCH_SHAPE_T
 
SCH_FIELD_T = _pcbnew.SCH_FIELD_T
 
SCH_TEXT_T = _pcbnew.SCH_TEXT_T
 
SCH_TEXTBOX_T = _pcbnew.SCH_TEXTBOX_T
 
SCH_PIN_T = _pcbnew.SCH_PIN_T
 
SCH_MARKER_T = _pcbnew.SCH_MARKER_T
 
SCH_JUNCTION_T = _pcbnew.SCH_JUNCTION_T
 
SCH_NO_CONNECT_T = _pcbnew.SCH_NO_CONNECT_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_BITMAP_T = _pcbnew.SCH_BITMAP_T
 
SCH_TABLE_T = _pcbnew.SCH_TABLE_T
 
SCH_TABLECELL_T = _pcbnew.SCH_TABLECELL_T
 
SCH_LABEL_T = _pcbnew.SCH_LABEL_T
 
SCH_GLOBAL_LABEL_T = _pcbnew.SCH_GLOBAL_LABEL_T
 
SCH_HIER_LABEL_T = _pcbnew.SCH_HIER_LABEL_T
 
SCH_RULE_AREA_T = _pcbnew.SCH_RULE_AREA_T
 
SCH_DIRECTIVE_LABEL_T = _pcbnew.SCH_DIRECTIVE_LABEL_T
 
SCH_SYMBOL_T = _pcbnew.SCH_SYMBOL_T
 
SCH_SHEET_PIN_T = _pcbnew.SCH_SHEET_PIN_T
 
SCH_SHEET_T = _pcbnew.SCH_SHEET_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_ITEM_LOCATE_WIRE_T = _pcbnew.SCH_ITEM_LOCATE_WIRE_T
 
SCH_ITEM_LOCATE_BUS_T = _pcbnew.SCH_ITEM_LOCATE_BUS_T
 
SCH_ITEM_LOCATE_GRAPHIC_LINE_T = _pcbnew.SCH_ITEM_LOCATE_GRAPHIC_LINE_T
 
SCH_LABEL_LOCATE_ANY_T = _pcbnew.SCH_LABEL_LOCATE_ANY_T
 
SCH_LABEL_LOCATE_WIRE_T = _pcbnew.SCH_LABEL_LOCATE_WIRE_T
 
SCH_LABEL_LOCATE_BUS_T = _pcbnew.SCH_LABEL_LOCATE_BUS_T
 
SCH_SYMBOL_LOCATE_POWER_T = _pcbnew.SCH_SYMBOL_LOCATE_POWER_T
 
SCH_LOCATE_ANY_T = _pcbnew.SCH_LOCATE_ANY_T
 
SCH_SCREEN_T = _pcbnew.SCH_SCREEN_T
 
SCHEMATIC_T = _pcbnew.SCHEMATIC_T
 
GERBER_LAYOUT_T = _pcbnew.GERBER_LAYOUT_T
 
GERBER_DRAW_ITEM_T = _pcbnew.GERBER_DRAW_ITEM_T
 
GERBER_IMAGE_T = _pcbnew.GERBER_IMAGE_T
 
WSG_LINE_T = _pcbnew.WSG_LINE_T
 
WSG_RECT_T = _pcbnew.WSG_RECT_T
 
WSG_POLY_T = _pcbnew.WSG_POLY_T
 
WSG_TEXT_T = _pcbnew.WSG_TEXT_T
 
WSG_BITMAP_T = _pcbnew.WSG_BITMAP_T
 
WSG_PAGE_T = _pcbnew.WSG_PAGE_T
 
WS_PROXY_UNDO_ITEM_T = _pcbnew.WS_PROXY_UNDO_ITEM_T
 
WS_PROXY_UNDO_ITEM_PLUS_T = _pcbnew.WS_PROXY_UNDO_ITEM_PLUS_T
 
SYMBOL_LIB_TABLE_T = _pcbnew.SYMBOL_LIB_TABLE_T
 
FP_LIB_TABLE_T = _pcbnew.FP_LIB_TABLE_T
 
DESIGN_BLOCK_LIB_TABLE_T = _pcbnew.DESIGN_BLOCK_LIB_TABLE_T
 
SYMBOL_LIBS_T = _pcbnew.SYMBOL_LIBS_T
 
SEARCH_STACK_T = _pcbnew.SEARCH_STACK_T
 
S3D_CACHE_T = _pcbnew.S3D_CACHE_T
 
MAX_STRUCT_TYPE_ID = _pcbnew.MAX_STRUCT_TYPE_ID
 
 
def BaseType(aType):
    r"""BaseType(KICAD_T const aType) -> KICAD_T"""
    return _pcbnew.BaseType(aType)
 
def IsNullType(aType):
    r"""IsNullType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsNullType(aType)
 
def IsInstantiableType(aType):
    r"""IsInstantiableType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsInstantiableType(aType)
 
def IsEeschemaType(aType):
    r"""IsEeschemaType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsEeschemaType(aType)
 
def IsPcbnewType(aType):
    r"""IsPcbnewType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsPcbnewType(aType)
 
def IsGerbviewType(aType):
    r"""IsGerbviewType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsGerbviewType(aType)
 
def IsPageLayoutEditorType(aType):
    r"""IsPageLayoutEditorType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsPageLayoutEditorType(aType)
 
def IsMiscType(aType):
    r"""IsMiscType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsMiscType(aType)
 
def IsTypeCorrect(aType):
    r"""IsTypeCorrect(KICAD_T aType) -> bool"""
    return _pcbnew.IsTypeCorrect(aType)
INSPECT_RESULT_QUIT = _pcbnew.INSPECT_RESULT_QUIT
 
INSPECT_RESULT_CONTINUE = _pcbnew.INSPECT_RESULT_CONTINUE
 
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")
    __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 GetParent(self):
        r"""GetParent(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_GetParent(self)
 
    def SetParent(self, aParent):
        r"""SetParent(EDA_ITEM self, EDA_ITEM aParent)"""
        return _pcbnew.EDA_ITEM_SetParent(self, aParent)
 
    def IsModified(self):
        r"""IsModified(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsModified(self)
 
    def IsNew(self):
        r"""IsNew(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsNew(self)
 
    def IsMoving(self):
        r"""IsMoving(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsMoving(self)
 
    def IsSelected(self):
        r"""IsSelected(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsSelected(self)
 
    def IsEntered(self):
        r"""IsEntered(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsEntered(self)
 
    def IsBrightened(self):
        r"""IsBrightened(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsBrightened(self)
 
    def IsRollover(self):
        r"""IsRollover(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsRollover(self)
 
    def SetIsRollover(self, aIsRollover):
        r"""SetIsRollover(EDA_ITEM self, bool aIsRollover)"""
        return _pcbnew.EDA_ITEM_SetIsRollover(self, aIsRollover)
 
    def SetSelected(self):
        r"""SetSelected(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetSelected(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 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 SetFlags(self, aMask):
        r"""SetFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask)"""
        return _pcbnew.EDA_ITEM_SetFlags(self, aMask)
 
    def XorFlags(self, aMask):
        r"""XorFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask)"""
        return _pcbnew.EDA_ITEM_XorFlags(self, aMask)
 
    def ClearFlags(self, *args):
        r"""ClearFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)"""
        return _pcbnew.EDA_ITEM_ClearFlags(self, *args)
 
    def GetFlags(self):
        r"""GetFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
        return _pcbnew.EDA_ITEM_GetFlags(self)
 
    def HasFlag(self, aFlag):
        r"""HasFlag(EDA_ITEM self, EDA_ITEM_FLAGS aFlag) -> bool"""
        return _pcbnew.EDA_ITEM_HasFlag(self, aFlag)
 
    def GetEditFlags(self):
        r"""GetEditFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
        return _pcbnew.EDA_ITEM_GetEditFlags(self)
 
    def ClearEditFlags(self):
        r"""ClearEditFlags(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearEditFlags(self)
 
    def GetTempFlags(self):
        r"""GetTempFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
        return _pcbnew.EDA_ITEM_GetTempFlags(self)
 
    def ClearTempFlags(self):
        r"""ClearTempFlags(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearTempFlags(self)
 
    def RenderAsBitmap(self, aWorldScale):
        r"""RenderAsBitmap(EDA_ITEM self, double aWorldScale) -> bool"""
        return _pcbnew.EDA_ITEM_RenderAsBitmap(self, aWorldScale)
 
    def SetIsShownAsBitmap(self, aBitmap):
        r"""SetIsShownAsBitmap(EDA_ITEM self, bool aBitmap)"""
        return _pcbnew.EDA_ITEM_SetIsShownAsBitmap(self, aBitmap)
 
    def IsShownAsBitmap(self):
        r"""IsShownAsBitmap(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsShownAsBitmap(self)
 
    def IsType(self, aScanTypes):
        r"""IsType(EDA_ITEM self, std::vector< KICAD_T,std::allocator< 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 IsForceVisible(self):
        r"""IsForceVisible(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsForceVisible(self)
 
    def GetMsgPanelInfo(self, aFrame, aList):
        r"""GetMsgPanelInfo(EDA_ITEM self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDA_ITEM_GetMsgPanelInfo(self, aFrame, aList)
 
    def GetFriendlyName(self):
        r"""GetFriendlyName(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_GetFriendlyName(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(EDA_ITEM self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(EDA_ITEM self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.EDA_ITEM_HitTest(self, *args)
 
    def GetBoundingBox(self):
        r"""GetBoundingBox(EDA_ITEM self) -> BOX2I"""
        return _pcbnew.EDA_ITEM_GetBoundingBox(self)
 
    def GetPosition(self):
        r"""GetPosition(EDA_ITEM self) -> VECTOR2I"""
        return _pcbnew.EDA_ITEM_GetPosition(self)
 
    def SetPosition(self, aPos):
        r"""SetPosition(EDA_ITEM self, VECTOR2I aPos)"""
        return _pcbnew.EDA_ITEM_SetPosition(self, aPos)
 
    def GetFocusPosition(self):
        r"""GetFocusPosition(EDA_ITEM self) -> VECTOR2I"""
        return _pcbnew.EDA_ITEM_GetFocusPosition(self)
 
    def GetSortPosition(self):
        r"""GetSortPosition(EDA_ITEM self) -> VECTOR2I"""
        return _pcbnew.EDA_ITEM_GetSortPosition(self)
 
    def Clone(self):
        r"""Clone(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_Clone(self)
 
    def Visit(self, inspector, testData, aScanTypes):
        r"""Visit(EDA_ITEM self, INSPECTOR inspector, void * testData, std::vector< KICAD_T,std::allocator< KICAD_T > > const & aScanTypes) -> INSPECT_RESULT"""
        return _pcbnew.EDA_ITEM_Visit(self, inspector, testData, aScanTypes)
 
    def GetTypeDesc(self):
        r"""GetTypeDesc(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_GetTypeDesc(self)
 
    def GetItemDescription(self, aUnitsProvider, aFull):
        r"""GetItemDescription(EDA_ITEM self, UNITS_PROVIDER aUnitsProvider, bool aFull) -> wxString"""
        return _pcbnew.EDA_ITEM_GetItemDescription(self, aUnitsProvider, aFull)
 
    def GetMenuImage(self):
        r"""GetMenuImage(EDA_ITEM self) -> BITMAPS"""
        return _pcbnew.EDA_ITEM_GetMenuImage(self)
 
    def Matches(self, aSearchData, aAuxData):
        r"""Matches(EDA_ITEM self, EDA_SEARCH_DATA const & aSearchData, void * aAuxData) -> bool"""
        return _pcbnew.EDA_ITEM_Matches(self, aSearchData, aAuxData)
 
    def Replace(self, *args):
        r"""
        Replace(EDA_ITEM self, EDA_SEARCH_DATA const & aSearchData, wxString aText) -> bool
        Replace(EDA_ITEM self, EDA_SEARCH_DATA const & 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"""
        return _pcbnew.EDA_ITEM_ViewBBox(self)
 
    def ViewGetLayers(self):
        r"""ViewGetLayers(EDA_ITEM self) -> intVector"""
        return _pcbnew.EDA_ITEM_ViewGetLayers(self)
 
    def GetEmbeddedFiles(self):
        r"""GetEmbeddedFiles(EDA_ITEM self) -> EMBEDDED_FILES *"""
        return _pcbnew.EDA_ITEM_GetEmbeddedFiles(self)
    m_Uuid = property(_pcbnew.EDA_ITEM_m_Uuid_get, doc=r"""m_Uuid : q(const).KIID""")
 
    def PyGetClass(self):
        r"""PyGetClass(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_PyGetClass(self)
 
    def GetClass(self):
        return self.PyGetClass()
 
 
# Register EDA_ITEM in _pcbnew:
_pcbnew.EDA_ITEM_swigregister(EDA_ITEM)
 
def new_clone(aItem):
    r"""new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
    return _pcbnew.new_clone(aItem)
class CompareByUuid(object):
    r"""Proxy of C++ CompareByUuid class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __call__(self, item1, item2):
        r"""__call__(CompareByUuid self, EDA_ITEM item1, EDA_ITEM item2) -> bool"""
        return _pcbnew.CompareByUuid___call__(self, item1, item2)
 
    def __init__(self):
        r"""__init__(CompareByUuid self) -> CompareByUuid"""
        _pcbnew.CompareByUuid_swiginit(self, _pcbnew.new_CompareByUuid())
    __swig_destroy__ = _pcbnew.delete_CompareByUuid
 
# Register CompareByUuid in _pcbnew:
_pcbnew.CompareByUuid_swigregister(CompareByUuid)
class EDA_IU_SCALE(object):
    r"""Proxy of C++ EDA_IU_SCALE class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IU_PER_MM = property(_pcbnew.EDA_IU_SCALE_IU_PER_MM_get, doc=r"""IU_PER_MM : q(const).double""")
    IU_PER_MILS = property(_pcbnew.EDA_IU_SCALE_IU_PER_MILS_get, doc=r"""IU_PER_MILS : q(const).double""")
    MM_PER_IU = property(_pcbnew.EDA_IU_SCALE_MM_PER_IU_get, doc=r"""MM_PER_IU : q(const).double""")
 
    def __init__(self, aIUPerMM):
        r"""__init__(EDA_IU_SCALE self, double aIUPerMM) -> EDA_IU_SCALE"""
        _pcbnew.EDA_IU_SCALE_swiginit(self, _pcbnew.new_EDA_IU_SCALE(aIUPerMM))
 
    def IUTomm(self, iu):
        r"""IUTomm(EDA_IU_SCALE self, int iu) -> double"""
        return _pcbnew.EDA_IU_SCALE_IUTomm(self, iu)
 
    def mmToIU(self, mm):
        r"""mmToIU(EDA_IU_SCALE self, double mm) -> int"""
        return _pcbnew.EDA_IU_SCALE_mmToIU(self, mm)
 
    def MilsToIU(self, mils):
        r"""MilsToIU(EDA_IU_SCALE self, int mils) -> int"""
        return _pcbnew.EDA_IU_SCALE_MilsToIU(self, mils)
 
    def IUToMils(self, iu):
        r"""IUToMils(EDA_IU_SCALE self, int iu) -> int"""
        return _pcbnew.EDA_IU_SCALE_IUToMils(self, iu)
    __swig_destroy__ = _pcbnew.delete_EDA_IU_SCALE
 
# Register EDA_IU_SCALE in _pcbnew:
_pcbnew.EDA_IU_SCALE_swigregister(EDA_IU_SCALE)
GERB_IU_PER_MM = cvar.GERB_IU_PER_MM
PCB_IU_PER_MM = cvar.PCB_IU_PER_MM
PL_IU_PER_MM = cvar.PL_IU_PER_MM
SCH_IU_PER_MM = cvar.SCH_IU_PER_MM
 
EDA_DATA_TYPE_DISTANCE = _pcbnew.EDA_DATA_TYPE_DISTANCE
 
EDA_DATA_TYPE_AREA = _pcbnew.EDA_DATA_TYPE_AREA
 
EDA_DATA_TYPE_VOLUME = _pcbnew.EDA_DATA_TYPE_VOLUME
 
EDA_DATA_TYPE_UNITLESS = _pcbnew.EDA_DATA_TYPE_UNITLESS
 
EDA_UNITS_INCH = _pcbnew.EDA_UNITS_INCH
 
EDA_UNITS_MM = _pcbnew.EDA_UNITS_MM
 
EDA_UNITS_UNSCALED = _pcbnew.EDA_UNITS_UNSCALED
 
EDA_UNITS_DEGREES = _pcbnew.EDA_UNITS_DEGREES
 
EDA_UNITS_PERCENT = _pcbnew.EDA_UNITS_PERCENT
 
EDA_UNITS_MILS = _pcbnew.EDA_UNITS_MILS
 
EDA_UNITS_UM = _pcbnew.EDA_UNITS_UM
 
EDA_UNITS_CM = _pcbnew.EDA_UNITS_CM
 
 
def IsImperialUnit(aUnit):
    r"""IsImperialUnit(EDA_UNITS aUnit) -> bool"""
    return _pcbnew.IsImperialUnit(aUnit)
 
def IsMetricUnit(aUnit):
    r"""IsMetricUnit(EDA_UNITS aUnit) -> bool"""
    return _pcbnew.IsMetricUnit(aUnit)
 
def Mm2mils(aVal):
    r"""Mm2mils(double aVal) -> int"""
    return _pcbnew.Mm2mils(aVal)
 
def Mils2mm(aVal):
    r"""Mils2mm(double aVal) -> int"""
    return _pcbnew.Mils2mm(aVal)
 
def FetchUnitsFromString(aTextValue, aUnits):
    r"""FetchUnitsFromString(wxString aTextValue, EDA_UNITS & aUnits) -> bool"""
    return _pcbnew.FetchUnitsFromString(aTextValue, aUnits)
 
def GetText(*args):
    r"""GetText(EDA_UNITS aUnits, EDA_DATA_TYPE aType=DISTANCE) -> wxString"""
    return _pcbnew.GetText(*args)
 
def GetLabel(*args):
    r"""GetLabel(EDA_UNITS aUnits, EDA_DATA_TYPE aType=DISTANCE) -> wxString"""
    return _pcbnew.GetLabel(*args)
 
def FormatAngle(aAngle):
    r"""FormatAngle(EDA_ANGLE aAngle) -> string"""
    return _pcbnew.FormatAngle(aAngle)
 
def FormatInternalUnits(*args):
    r"""
    FormatInternalUnits(EDA_IU_SCALE aIuScale, int aValue) -> string
    FormatInternalUnits(EDA_IU_SCALE aIuScale, VECTOR2I aPoint) -> string
    """
    return _pcbnew.FormatInternalUnits(*args)
 
def Mils2IU(aIuScale, mils):
    r"""Mils2IU(EDA_IU_SCALE aIuScale, int mils) -> int"""
    return _pcbnew.Mils2IU(aIuScale, mils)
 
def ToUserUnit(aIuScale, aUnit, aValue):
    r"""ToUserUnit(EDA_IU_SCALE aIuScale, EDA_UNITS aUnit, double aValue) -> double"""
    return _pcbnew.ToUserUnit(aIuScale, aUnit, aValue)
 
def StringFromValue(*args):
    r"""StringFromValue(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, double aValue, bool aAddUnitsText=False, EDA_DATA_TYPE aType=DISTANCE) -> wxString"""
    return _pcbnew.StringFromValue(*args)
 
def MessageTextFromValue(*args):
    r"""
    MessageTextFromValue(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, double aValue, bool aAddUnitsText=True, EDA_DATA_TYPE aType=DISTANCE) -> wxString
    MessageTextFromValue(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, int aValue, bool aAddUnitLabel=True, EDA_DATA_TYPE aType=DISTANCE) -> wxString
    MessageTextFromValue(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, long long aValue, bool aAddUnitLabel=True, EDA_DATA_TYPE aType=DISTANCE) -> wxString
    MessageTextFromValue(EDA_ANGLE aValue, bool aAddUnitLabel=True) -> wxString
    """
    return _pcbnew.MessageTextFromValue(*args)
 
def MessageTextFromMinOptMax(aIuScale, aUnits, aValue):
    r"""MessageTextFromMinOptMax(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, MINOPTMAX< int > const & aValue) -> wxString"""
    return _pcbnew.MessageTextFromMinOptMax(aIuScale, aUnits, aValue)
 
def FromUserUnit(aIuScale, aUnit, aValue):
    r"""FromUserUnit(EDA_IU_SCALE aIuScale, EDA_UNITS aUnit, double aValue) -> double"""
    return _pcbnew.FromUserUnit(aIuScale, aUnit, aValue)
 
def DoubleValueFromString(*args):
    r"""
    DoubleValueFromString(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, wxString aTextValue, EDA_DATA_TYPE aType=DISTANCE) -> double
    DoubleValueFromString(wxString aTextValue) -> double
    DoubleValueFromString(EDA_IU_SCALE aIuScale, wxString aTextValue, double & aDoubleValue) -> bool
    """
    return _pcbnew.DoubleValueFromString(*args)
 
def ValueFromString(*args):
    r"""
    ValueFromString(EDA_IU_SCALE aIuScale, EDA_UNITS aUnits, wxString aTextValue, EDA_DATA_TYPE aType=DISTANCE) -> long long
    ValueFromString(wxString aTextValue) -> long long
    """
    return _pcbnew.ValueFromString(*args)
 
def SearchHelpFileFullPath(aBaseName):
    r"""SearchHelpFileFullPath(wxString aBaseName) -> wxString"""
    return _pcbnew.SearchHelpFileFullPath(aBaseName)
 
def EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter=None):
    r"""EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename, REPORTER * aReporter=None) -> bool"""
    return _pcbnew.EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter)
 
def EnsureFileExtension(aFilename, aExtension):
    r"""EnsureFileExtension(wxString aFilename, wxString aExtension) -> wxString"""
    return _pcbnew.EnsureFileExtension(aFilename, aExtension)
 
def ExpandEnvVarSubstitutions(aString, aProject):
    r"""ExpandEnvVarSubstitutions(wxString aString, PROJECT const * aProject) -> wxString"""
    return _pcbnew.ExpandEnvVarSubstitutions(aString, aProject)
FOR_ERC_DRC = _pcbnew.FOR_ERC_DRC
 
 
def ExpandTextVars(*args):
    r"""
    ExpandTextVars(wxString aSource, std::function< bool (wxString *) > const * aResolver, int aFlags=0) -> wxString
    ExpandTextVars(wxString aSource, PROJECT const * aProject, int aFlags=0) -> wxString
    """
    return _pcbnew.ExpandTextVars(*args)
 
def GetGeneratedFieldDisplayName(aSource):
    r"""GetGeneratedFieldDisplayName(wxString aSource) -> wxString"""
    return _pcbnew.GetGeneratedFieldDisplayName(aSource)
 
def IsGeneratedField(aSource):
    r"""IsGeneratedField(wxString aSource) -> bool"""
    return _pcbnew.IsGeneratedField(aSource)
 
def ResolveUriByEnvVars(aUri, aProject):
    r"""ResolveUriByEnvVars(wxString aUri, PROJECT const * aProject) -> wxString"""
    return _pcbnew.ResolveUriByEnvVars(aUri, aProject)
 
def TimestampDir(aDirPath, aFilespec):
    r"""TimestampDir(wxString aDirPath, wxString aFilespec) -> long long"""
    return _pcbnew.TimestampDir(aDirPath, aFilespec)
 
def WarnUserIfOperatingSystemUnsupported():
    r"""WarnUserIfOperatingSystemUnsupported() -> bool"""
    return _pcbnew.WarnUserIfOperatingSystemUnsupported()
 
def StrPrintf(*args):
    r"""
    StrPrintf(string aResult, char const * aFormat) -> int
    StrPrintf(char const * format) -> string
    """
    return _pcbnew.StrPrintf(*args)
 
def SafeReadFile(aFilePath, aReadType):
    r"""SafeReadFile(wxString aFilePath, wxString aReadType) -> wxString"""
    return _pcbnew.SafeReadFile(aFilePath, aReadType)
LINE_READER_LINE_DEFAULT_MAX = _pcbnew.LINE_READER_LINE_DEFAULT_MAX
 
LINE_READER_LINE_INITIAL_SIZE = _pcbnew.LINE_READER_LINE_INITIAL_SIZE
 
class LINE_READER(object):
    r"""Proxy of C++ LINE_READER 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_LINE_READER
 
    def ReadLine(self):
        r"""ReadLine(LINE_READER self) -> char *"""
        return _pcbnew.LINE_READER_ReadLine(self)
 
    def GetSource(self):
        r"""GetSource(LINE_READER self) -> wxString"""
        return _pcbnew.LINE_READER_GetSource(self)
 
    def Line(self):
        r"""Line(LINE_READER self) -> char *"""
        return _pcbnew.LINE_READER_Line(self)
 
    def LineNumber(self):
        r"""LineNumber(LINE_READER self) -> unsigned int"""
        return _pcbnew.LINE_READER_LineNumber(self)
 
    def Length(self):
        r"""Length(LINE_READER self) -> unsigned int"""
        return _pcbnew.LINE_READER_Length(self)
 
# Register LINE_READER in _pcbnew:
_pcbnew.LINE_READER_swigregister(LINE_READER)
gerbIUScale = cvar.gerbIUScale
pcbIUScale = cvar.pcbIUScale
drawSheetIUScale = cvar.drawSheetIUScale
schIUScale = cvar.schIUScale
unityScale = cvar.unityScale
ARC_LOW_DEF_MM = cvar.ARC_LOW_DEF_MM
ARC_HIGH_DEF_MM = cvar.ARC_HIGH_DEF_MM
 
class FILE_LINE_READER(LINE_READER):
    r"""Proxy of C++ FILE_LINE_READER 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__(FILE_LINE_READER self, wxString aFileName, unsigned int aStartingLineNumber=0, unsigned int aMaxLineLength=1000000) -> FILE_LINE_READER
        __init__(FILE_LINE_READER self, FILE * aFile, wxString aFileName, bool doOwn=True, unsigned int aStartingLineNumber=0, unsigned int aMaxLineLength=1000000) -> FILE_LINE_READER
        """
        _pcbnew.FILE_LINE_READER_swiginit(self, _pcbnew.new_FILE_LINE_READER(*args))
    __swig_destroy__ = _pcbnew.delete_FILE_LINE_READER
 
    def Rewind(self):
        r"""Rewind(FILE_LINE_READER self)"""
        return _pcbnew.FILE_LINE_READER_Rewind(self)
 
    def FileLength(self):
        r"""FileLength(FILE_LINE_READER self) -> long"""
        return _pcbnew.FILE_LINE_READER_FileLength(self)
 
    def CurPos(self):
        r"""CurPos(FILE_LINE_READER self) -> long"""
        return _pcbnew.FILE_LINE_READER_CurPos(self)
 
# Register FILE_LINE_READER in _pcbnew:
_pcbnew.FILE_LINE_READER_swigregister(FILE_LINE_READER)
class STRING_LINE_READER(LINE_READER):
    r"""Proxy of C++ STRING_LINE_READER 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__(STRING_LINE_READER self, string aString, wxString aSource) -> STRING_LINE_READER
        __init__(STRING_LINE_READER self, STRING_LINE_READER aStartingPoint) -> STRING_LINE_READER
        """
        _pcbnew.STRING_LINE_READER_swiginit(self, _pcbnew.new_STRING_LINE_READER(*args))
    __swig_destroy__ = _pcbnew.delete_STRING_LINE_READER
 
# Register STRING_LINE_READER in _pcbnew:
_pcbnew.STRING_LINE_READER_swigregister(STRING_LINE_READER)
class INPUTSTREAM_LINE_READER(LINE_READER):
    r"""Proxy of C++ INPUTSTREAM_LINE_READER 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, aStream, aSource):
        r"""__init__(INPUTSTREAM_LINE_READER self, wxInputStream * aStream, wxString aSource) -> INPUTSTREAM_LINE_READER"""
        _pcbnew.INPUTSTREAM_LINE_READER_swiginit(self, _pcbnew.new_INPUTSTREAM_LINE_READER(aStream, aSource))
    __swig_destroy__ = _pcbnew.delete_INPUTSTREAM_LINE_READER
 
# Register INPUTSTREAM_LINE_READER in _pcbnew:
_pcbnew.INPUTSTREAM_LINE_READER_swigregister(INPUTSTREAM_LINE_READER)
OUTPUTFMTBUFZ = _pcbnew.OUTPUTFMTBUFZ
 
class OUTPUTFORMATTER(object):
    r"""Proxy of C++ OUTPUTFORMATTER 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_OUTPUTFORMATTER
 
    def Print(self, *args):
        r"""
        Print(OUTPUTFORMATTER self, int nestLevel, char const * fmt) -> int
        Print(OUTPUTFORMATTER self, char const * fmt) -> int
        """
        return _pcbnew.OUTPUTFORMATTER_Print(self, *args)
 
    def GetQuoteChar(self, wrapee):
        r"""GetQuoteChar(OUTPUTFORMATTER self, char const * wrapee) -> char const *"""
        return _pcbnew.OUTPUTFORMATTER_GetQuoteChar(self, wrapee)
 
    def Quotes(self, aWrapee):
        r"""Quotes(OUTPUTFORMATTER self, string aWrapee) -> string"""
        return _pcbnew.OUTPUTFORMATTER_Quotes(self, aWrapee)
 
    def Quotew(self, aWrapee):
        r"""Quotew(OUTPUTFORMATTER self, wxString aWrapee) -> string"""
        return _pcbnew.OUTPUTFORMATTER_Quotew(self, aWrapee)
 
    def Finish(self):
        r"""Finish(OUTPUTFORMATTER self) -> bool"""
        return _pcbnew.OUTPUTFORMATTER_Finish(self)
 
# Register OUTPUTFORMATTER in _pcbnew:
_pcbnew.OUTPUTFORMATTER_swigregister(OUTPUTFORMATTER)
class STRING_FORMATTER(OUTPUTFORMATTER):
    r"""Proxy of C++ STRING_FORMATTER 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__(STRING_FORMATTER self, int aReserve=500, char aQuoteChar='\"') -> STRING_FORMATTER"""
        _pcbnew.STRING_FORMATTER_swiginit(self, _pcbnew.new_STRING_FORMATTER(*args))
 
    def Clear(self):
        r"""Clear(STRING_FORMATTER self)"""
        return _pcbnew.STRING_FORMATTER_Clear(self)
 
    def StripUseless(self):
        r"""StripUseless(STRING_FORMATTER self)"""
        return _pcbnew.STRING_FORMATTER_StripUseless(self)
 
    def GetString(self):
        r"""GetString(STRING_FORMATTER self) -> string"""
        return _pcbnew.STRING_FORMATTER_GetString(self)
    __swig_destroy__ = _pcbnew.delete_STRING_FORMATTER
 
# Register STRING_FORMATTER in _pcbnew:
_pcbnew.STRING_FORMATTER_swigregister(STRING_FORMATTER)
class FILE_OUTPUTFORMATTER(OUTPUTFORMATTER):
    r"""Proxy of C++ FILE_OUTPUTFORMATTER 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__(FILE_OUTPUTFORMATTER self, wxString aFileName, wxChar const * aMode=wxT( "wt" ), char aQuoteChar='\"') -> FILE_OUTPUTFORMATTER"""
        _pcbnew.FILE_OUTPUTFORMATTER_swiginit(self, _pcbnew.new_FILE_OUTPUTFORMATTER(*args))
    __swig_destroy__ = _pcbnew.delete_FILE_OUTPUTFORMATTER
 
# Register FILE_OUTPUTFORMATTER in _pcbnew:
_pcbnew.FILE_OUTPUTFORMATTER_swigregister(FILE_OUTPUTFORMATTER)
class PRETTIFIED_FILE_OUTPUTFORMATTER(OUTPUTFORMATTER):
    r"""Proxy of C++ PRETTIFIED_FILE_OUTPUTFORMATTER 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__(PRETTIFIED_FILE_OUTPUTFORMATTER self, wxString aFileName, wxChar const * aMode=wxT( "wt" ), char aQuoteChar='\"') -> PRETTIFIED_FILE_OUTPUTFORMATTER"""
        _pcbnew.PRETTIFIED_FILE_OUTPUTFORMATTER_swiginit(self, _pcbnew.new_PRETTIFIED_FILE_OUTPUTFORMATTER(*args))
    __swig_destroy__ = _pcbnew.delete_PRETTIFIED_FILE_OUTPUTFORMATTER
 
# Register PRETTIFIED_FILE_OUTPUTFORMATTER in _pcbnew:
_pcbnew.PRETTIFIED_FILE_OUTPUTFORMATTER_swigregister(PRETTIFIED_FILE_OUTPUTFORMATTER)
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 Clear(self):
        r"""Clear(TITLE_BLOCK self)"""
        return _pcbnew.TITLE_BLOCK_Clear(self)
 
    @staticmethod
    def GetContextualTextVars(aVars):
        r"""GetContextualTextVars(wxArrayString * aVars)"""
        return _pcbnew.TITLE_BLOCK_GetContextualTextVars(aVars)
 
    def TextVarResolver(self, aToken, aProject, aFlags=0):
        r"""TextVarResolver(TITLE_BLOCK self, wxString aToken, PROJECT const * aProject, int aFlags=0) -> bool"""
        return _pcbnew.TITLE_BLOCK_TextVarResolver(self, aToken, aProject, aFlags)
 
    def Format(self, aFormatter):
        r"""Format(TITLE_BLOCK self, OUTPUTFORMATTER aFormatter)"""
        return _pcbnew.TITLE_BLOCK_Format(self, aFormatter)
 
    @staticmethod
    def GetCurrentDate():
        r"""GetCurrentDate() -> wxString"""
        return _pcbnew.TITLE_BLOCK_GetCurrentDate()
 
# Register TITLE_BLOCK in _pcbnew:
_pcbnew.TITLE_BLOCK_swigregister(TITLE_BLOCK)
UNSPECIFIED_COLOR = _pcbnew.UNSPECIFIED_COLOR
 
BLACK = _pcbnew.BLACK
 
DARKDARKGRAY = _pcbnew.DARKDARKGRAY
 
DARKGRAY = _pcbnew.DARKGRAY
 
LIGHTGRAY = _pcbnew.LIGHTGRAY
 
WHITE = _pcbnew.WHITE
 
LIGHTYELLOW = _pcbnew.LIGHTYELLOW
 
DARKBLUE = _pcbnew.DARKBLUE
 
DARKGREEN = _pcbnew.DARKGREEN
 
DARKCYAN = _pcbnew.DARKCYAN
 
DARKRED = _pcbnew.DARKRED
 
DARKMAGENTA = _pcbnew.DARKMAGENTA
 
DARKBROWN = _pcbnew.DARKBROWN
 
BLUE = _pcbnew.BLUE
 
GREEN = _pcbnew.GREEN
 
CYAN = _pcbnew.CYAN
 
RED = _pcbnew.RED
 
MAGENTA = _pcbnew.MAGENTA
 
BROWN = _pcbnew.BROWN
 
LIGHTBLUE = _pcbnew.LIGHTBLUE
 
LIGHTGREEN = _pcbnew.LIGHTGREEN
 
LIGHTCYAN = _pcbnew.LIGHTCYAN
 
LIGHTRED = _pcbnew.LIGHTRED
 
LIGHTMAGENTA = _pcbnew.LIGHTMAGENTA
 
YELLOW = _pcbnew.YELLOW
 
PUREBLUE = _pcbnew.PUREBLUE
 
PUREGREEN = _pcbnew.PUREGREEN
 
PURECYAN = _pcbnew.PURECYAN
 
PURERED = _pcbnew.PURERED
 
PUREMAGENTA = _pcbnew.PUREMAGENTA
 
PUREYELLOW = _pcbnew.PUREYELLOW
 
LIGHTERORANGE = _pcbnew.LIGHTERORANGE
 
DARKORANGE = _pcbnew.DARKORANGE
 
ORANGE = _pcbnew.ORANGE
 
LIGHTORANGE = _pcbnew.LIGHTORANGE
 
PUREORANGE = _pcbnew.PUREORANGE
 
NBCOLORS = _pcbnew.NBCOLORS
 
HIGHLIGHT_FLAG = _pcbnew.HIGHLIGHT_FLAG
 
MASKCOLOR = _pcbnew.MASKCOLOR
 
class StructColors(object):
    r"""Proxy of C++ StructColors class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Blue = property(_pcbnew.StructColors_m_Blue_get, _pcbnew.StructColors_m_Blue_set, doc=r"""m_Blue : unsigned char""")
    m_Green = property(_pcbnew.StructColors_m_Green_get, _pcbnew.StructColors_m_Green_set, doc=r"""m_Green : unsigned char""")
    m_Red = property(_pcbnew.StructColors_m_Red_get, _pcbnew.StructColors_m_Red_set, doc=r"""m_Red : unsigned char""")
    m_Numcolor = property(_pcbnew.StructColors_m_Numcolor_get, _pcbnew.StructColors_m_Numcolor_set, doc=r"""m_Numcolor : EDA_COLOR_T""")
    m_ColorName = property(_pcbnew.StructColors_m_ColorName_get, _pcbnew.StructColors_m_ColorName_set, doc=r"""m_ColorName : std::string""")
    m_LightColor = property(_pcbnew.StructColors_m_LightColor_get, _pcbnew.StructColors_m_LightColor_set, doc=r"""m_LightColor : EDA_COLOR_T""")
 
    def __init__(self):
        r"""__init__(StructColors self) -> StructColors"""
        _pcbnew.StructColors_swiginit(self, _pcbnew.new_StructColors())
    __swig_destroy__ = _pcbnew.delete_StructColors
 
# Register StructColors in _pcbnew:
_pcbnew.StructColors_swigregister(StructColors)
 
def colorRefs():
    r"""colorRefs() -> StructColors"""
    return _pcbnew.colorRefs()
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 FromCSSRGBA(self, aRed, aGreen, aBlue, aAlpha=1.0):
        r"""FromCSSRGBA(COLOR4D self, int aRed, int aGreen, int aBlue, double aAlpha=1.0) -> COLOR4D"""
        return _pcbnew.COLOR4D_FromCSSRGBA(self, aRed, aGreen, aBlue, aAlpha)
 
    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, wxString aColorStr) -> 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 ToCSSString(self):
        r"""ToCSSString(COLOR4D self) -> wxString"""
        return _pcbnew.COLOR4D_ToCSSString(self)
 
    def SetFromHexString(self, aColorString):
        r"""SetFromHexString(COLOR4D self, wxString aColorString) -> bool"""
        return _pcbnew.COLOR4D_SetFromHexString(self, aColorString)
 
    def ToHexString(self):
        r"""ToHexString(COLOR4D self) -> wxString"""
        return _pcbnew.COLOR4D_ToHexString(self)
 
    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 ToHSL(self, aOutHue, aOutSaturation, aOutLightness):
        r"""ToHSL(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutLightness)"""
        return _pcbnew.COLOR4D_ToHSL(self, aOutHue, aOutSaturation, aOutLightness)
 
    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 Desaturate(self):
        r"""Desaturate(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_Desaturate(self)
 
    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 Mix(self, aColor, aFactor):
        r"""Mix(COLOR4D self, COLOR4D aColor, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Mix(self, aColor, 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)
 
    def Distance(self, other):
        r"""Distance(COLOR4D self, COLOR4D other) -> double"""
        return _pcbnew.COLOR4D_Distance(self, other)
 
    def Compare(self, aRhs):
        r"""Compare(COLOR4D self, COLOR4D aRhs) -> int"""
        return _pcbnew.COLOR4D_Compare(self, aRhs)
 
    def RelativeLuminance(self):
        r"""RelativeLuminance(COLOR4D self) -> double"""
        return _pcbnew.COLOR4D_RelativeLuminance(self)
 
    @staticmethod
    def ContrastRatio(aLeft, aRight):
        r"""ContrastRatio(COLOR4D aLeft, COLOR4D aRight) -> double"""
        return _pcbnew.COLOR4D_ContrastRatio(aLeft, aRight)
 
    @staticmethod
    def FindNearestLegacyColor(aR, aG, aB):
        r"""FindNearestLegacyColor(int aR, int aG, int aB) -> EDA_COLOR_T"""
        return _pcbnew.COLOR4D_FindNearestLegacyColor(aR, aG, aB)
    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)
COLOR4D.UNSPECIFIED = _pcbnew.cvar.COLOR4D_UNSPECIFIED
COLOR4D.WHITE = _pcbnew.cvar.COLOR4D_WHITE
COLOR4D.BLACK = _pcbnew.cvar.COLOR4D_BLACK
COLOR4D.CLEAR = _pcbnew.cvar.COLOR4D_CLEAR
 
 
def __eq__(lhs, rhs):
    r"""__eq__(COLOR4D lhs, COLOR4D rhs) -> bool"""
    return _pcbnew.__eq__(lhs, rhs)
 
def __ne__(lhs, rhs):
    r"""__ne__(COLOR4D lhs, COLOR4D rhs) -> bool"""
    return _pcbnew.__ne__(lhs, rhs)
 
def __lt__(lhs, rhs):
    r"""__lt__(COLOR4D lhs, COLOR4D rhs) -> bool"""
    return _pcbnew.__lt__(lhs, rhs)
 
def __lshift__(aStream, aColor):
    r"""__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
    return _pcbnew.__lshift__(aStream, aColor)
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")
 
    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    MARKER_UNSPEC = _pcbnew.MARKER_BASE_MARKER_UNSPEC
    
    MARKER_ERC = _pcbnew.MARKER_BASE_MARKER_ERC
    
    MARKER_DRC = _pcbnew.MARKER_BASE_MARKER_DRC
    
    MARKER_DRAWING_SHEET = _pcbnew.MARKER_BASE_MARKER_DRAWING_SHEET
    
    MARKER_RATSNEST = _pcbnew.MARKER_BASE_MARKER_RATSNEST
    
    MARKER_PARITY = _pcbnew.MARKER_BASE_MARKER_PARITY
    
    MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
    
    __swig_destroy__ = _pcbnew.delete_MARKER_BASE
 
    def MarkerScale(self):
        r"""MarkerScale(MARKER_BASE self) -> int"""
        return _pcbnew.MARKER_BASE_MarkerScale(self)
 
    def SetMarkerScale(self, aScale):
        r"""SetMarkerScale(MARKER_BASE self, int aScale)"""
        return _pcbnew.MARKER_BASE_SetMarkerScale(self, aScale)
 
    def ShapeToPolygon(self, aPolygon, aScale=-1):
        r"""ShapeToPolygon(MARKER_BASE self, SHAPE_LINE_CHAIN aPolygon, int aScale=-1)"""
        return _pcbnew.MARKER_BASE_ShapeToPolygon(self, aPolygon, aScale)
 
    def PrintMarker(self, aSettings, aOffset):
        r"""PrintMarker(MARKER_BASE self, RENDER_SETTINGS const * aSettings, VECTOR2I aOffset)"""
        return _pcbnew.MARKER_BASE_PrintMarker(self, aSettings, aOffset)
 
    def GetPos(self):
        r"""GetPos(MARKER_BASE self) -> VECTOR2I"""
        return _pcbnew.MARKER_BASE_GetPos(self)
 
    def GetUUID(self):
        r"""GetUUID(MARKER_BASE self) -> KIID"""
        return _pcbnew.MARKER_BASE_GetUUID(self)
 
    def SetMarkerType(self, aMarkerType):
        r"""SetMarkerType(MARKER_BASE self, enum MARKER_BASE::MARKER_T aMarkerType)"""
        return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)
 
    def GetMarkerType(self):
        r"""GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::MARKER_T"""
        return _pcbnew.MARKER_BASE_GetMarkerType(self)
 
    def IsExcluded(self):
        r"""IsExcluded(MARKER_BASE self) -> bool"""
        return _pcbnew.MARKER_BASE_IsExcluded(self)
 
    def SetExcluded(self, *args):
        r"""SetExcluded(MARKER_BASE self, bool aExcluded, wxString aComment=wxEmptyString)"""
        return _pcbnew.MARKER_BASE_SetExcluded(self, *args)
 
    def GetComment(self):
        r"""GetComment(MARKER_BASE self) -> wxString"""
        return _pcbnew.MARKER_BASE_GetComment(self)
 
    def GetSeverity(self):
        r"""GetSeverity(MARKER_BASE self) -> SEVERITY"""
        return _pcbnew.MARKER_BASE_GetSeverity(self)
 
    def GetRCItem(self):
        r"""GetRCItem(MARKER_BASE self) -> std::shared_ptr< RC_ITEM >"""
        return _pcbnew.MARKER_BASE_GetRCItem(self)
 
    def HitTestMarker(self, *args):
        r"""
        HitTestMarker(MARKER_BASE self, VECTOR2I aHitPosition, int aAccuracy) -> bool
        HitTestMarker(MARKER_BASE self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.MARKER_BASE_HitTestMarker(self, *args)
 
    def GetBoundingBoxMarker(self):
        r"""GetBoundingBoxMarker(MARKER_BASE self) -> BOX2I"""
        return _pcbnew.MARKER_BASE_GetBoundingBoxMarker(self)
    m_Pos = property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set, doc=r"""m_Pos : VECTOR2I""")
 
# Register MARKER_BASE in _pcbnew:
_pcbnew.MARKER_BASE_swigregister(MARKER_BASE)
TEXT_MIN_SIZE_MM = _pcbnew.TEXT_MIN_SIZE_MM
 
TEXT_MAX_SIZE_MM = _pcbnew.TEXT_MAX_SIZE_MM
 
DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT
 
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, EDA_IU_SCALE aIuScale, wxString aText=wxEmptyString) -> EDA_TEXT
        __init__(EDA_TEXT self, EDA_TEXT aText) -> EDA_TEXT
        """
        _pcbnew.EDA_TEXT_swiginit(self, _pcbnew.new_EDA_TEXT(*args))
    __swig_destroy__ = _pcbnew.delete_EDA_TEXT
 
    def Serialize(self, aContainer):
        r"""Serialize(EDA_TEXT self, google::protobuf::Any & aContainer)"""
        return _pcbnew.EDA_TEXT_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(EDA_TEXT self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.EDA_TEXT_Deserialize(self, aContainer)
 
    def GetText(self):
        r"""GetText(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetText(self)
 
    def GetShownText(self, aAllowExtraText, aDepth=0):
        r"""GetShownText(EDA_TEXT self, bool aAllowExtraText, int aDepth=0) -> wxString"""
        return _pcbnew.EDA_TEXT_GetShownText(self, aAllowExtraText, aDepth)
 
    def HasTextVars(self):
        r"""HasTextVars(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_HasTextVars(self)
 
    def SetText(self, aText):
        r"""SetText(EDA_TEXT self, wxString aText)"""
        return _pcbnew.EDA_TEXT_SetText(self, aText)
 
    def SetTextThickness(self, aWidth):
        r"""SetTextThickness(EDA_TEXT self, int aWidth)"""
        return _pcbnew.EDA_TEXT_SetTextThickness(self, aWidth)
 
    def GetTextThickness(self):
        r"""GetTextThickness(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetTextThickness(self)
 
    def GetEffectiveTextPenWidth(self, aDefaultPenWidth=0):
        r"""GetEffectiveTextPenWidth(EDA_TEXT self, int aDefaultPenWidth=0) -> int"""
        return _pcbnew.EDA_TEXT_GetEffectiveTextPenWidth(self, aDefaultPenWidth)
 
    def SetTextAngle(self, aAngle):
        r"""SetTextAngle(EDA_TEXT self, EDA_ANGLE aAngle)"""
        return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)
 
    def GetTextAngle(self):
        r"""GetTextAngle(EDA_TEXT self) -> EDA_ANGLE"""
        return _pcbnew.EDA_TEXT_GetTextAngle(self)
 
    def SetTextAngleDegrees(self, aOrientation):
        r"""SetTextAngleDegrees(EDA_TEXT self, double aOrientation)"""
        return _pcbnew.EDA_TEXT_SetTextAngleDegrees(self, aOrientation)
 
    def GetTextAngleDegrees(self):
        r"""GetTextAngleDegrees(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)
 
    def SetItalic(self, aItalic):
        r"""SetItalic(EDA_TEXT self, bool aItalic)"""
        return _pcbnew.EDA_TEXT_SetItalic(self, aItalic)
 
    def SetItalicFlag(self, aItalic):
        r"""SetItalicFlag(EDA_TEXT self, bool aItalic)"""
        return _pcbnew.EDA_TEXT_SetItalicFlag(self, aItalic)
 
    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 SetBoldFlag(self, aBold):
        r"""SetBoldFlag(EDA_TEXT self, bool aBold)"""
        return _pcbnew.EDA_TEXT_SetBoldFlag(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 SetHorizJustify(self, aType):
        r"""SetHorizJustify(EDA_TEXT self, GR_TEXT_H_ALIGN_T aType)"""
        return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)
 
    def GetHorizJustify(self):
        r"""GetHorizJustify(EDA_TEXT self) -> GR_TEXT_H_ALIGN_T"""
        return _pcbnew.EDA_TEXT_GetHorizJustify(self)
 
    def SetVertJustify(self, aType):
        r"""SetVertJustify(EDA_TEXT self, GR_TEXT_V_ALIGN_T aType)"""
        return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)
 
    def GetVertJustify(self):
        r"""GetVertJustify(EDA_TEXT self) -> GR_TEXT_V_ALIGN_T"""
        return _pcbnew.EDA_TEXT_GetVertJustify(self)
 
    def SetKeepUpright(self, aKeepUpright):
        r"""SetKeepUpright(EDA_TEXT self, bool aKeepUpright)"""
        return _pcbnew.EDA_TEXT_SetKeepUpright(self, aKeepUpright)
 
    def IsKeepUpright(self):
        r"""IsKeepUpright(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsKeepUpright(self)
 
    def FlipHJustify(self):
        r"""FlipHJustify(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_FlipHJustify(self)
 
    def SwapAttributes(self, aTradingPartner):
        r"""SwapAttributes(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
        return _pcbnew.EDA_TEXT_SwapAttributes(self, aTradingPartner)
 
    def SwapText(self, aTradingPartner):
        r"""SwapText(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
        return _pcbnew.EDA_TEXT_SwapText(self, aTradingPartner)
 
    def CopyText(self, aSrc):
        r"""CopyText(EDA_TEXT self, EDA_TEXT aSrc)"""
        return _pcbnew.EDA_TEXT_CopyText(self, aSrc)
 
    def SetAttributes(self, *args):
        r"""
        SetAttributes(EDA_TEXT self, EDA_TEXT aSrc, bool aSetPosition=True)
        SetAttributes(EDA_TEXT self, TEXT_ATTRIBUTES aTextAttrs)
        """
        return _pcbnew.EDA_TEXT_SetAttributes(self, *args)
 
    def GetAttributes(self):
        r"""GetAttributes(EDA_TEXT self) -> TEXT_ATTRIBUTES"""
        return _pcbnew.EDA_TEXT_GetAttributes(self)
 
    def Replace(self, aSearchData):
        r"""Replace(EDA_TEXT self, EDA_SEARCH_DATA const & aSearchData) -> bool"""
        return _pcbnew.EDA_TEXT_Replace(self, aSearchData)
 
    def IsDefaultFormatting(self):
        r"""IsDefaultFormatting(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)
 
    def SetFont(self, aFont):
        r"""SetFont(EDA_TEXT self, KIFONT::FONT * aFont)"""
        return _pcbnew.EDA_TEXT_SetFont(self, aFont)
 
    def GetFont(self):
        r"""GetFont(EDA_TEXT self) -> KIFONT::FONT *"""
        return _pcbnew.EDA_TEXT_GetFont(self)
 
    def SetUnresolvedFontName(self, aFontName):
        r"""SetUnresolvedFontName(EDA_TEXT self, wxString aFontName)"""
        return _pcbnew.EDA_TEXT_SetUnresolvedFontName(self, aFontName)
 
    def ResolveFont(self, aEmbeddedFonts):
        r"""ResolveFont(EDA_TEXT self, std::vector< wxString,std::allocator< wxString > > const * aEmbeddedFonts) -> bool"""
        return _pcbnew.EDA_TEXT_ResolveFont(self, aEmbeddedFonts)
 
    def GetFontName(self):
        r"""GetFontName(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetFontName(self)
 
    def SetFontIndex(self, aIdx):
        r"""SetFontIndex(EDA_TEXT self, int aIdx)"""
        return _pcbnew.EDA_TEXT_SetFontIndex(self, aIdx)
 
    def GetFontIndex(self):
        r"""GetFontIndex(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetFontIndex(self)
 
    def SetLineSpacing(self, aLineSpacing):
        r"""SetLineSpacing(EDA_TEXT self, double aLineSpacing)"""
        return _pcbnew.EDA_TEXT_SetLineSpacing(self, aLineSpacing)
 
    def GetLineSpacing(self):
        r"""GetLineSpacing(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetLineSpacing(self)
 
    def SetTextSize(self, aNewSize, aEnforceMinTextSize=True):
        r"""SetTextSize(EDA_TEXT self, VECTOR2I aNewSize, bool aEnforceMinTextSize=True)"""
        return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize, aEnforceMinTextSize)
 
    def GetTextSize(self):
        r"""GetTextSize(EDA_TEXT self) -> VECTOR2I"""
        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 SetTextColor(self, aColor):
        r"""SetTextColor(EDA_TEXT self, COLOR4D aColor)"""
        return _pcbnew.EDA_TEXT_SetTextColor(self, aColor)
 
    def GetTextColor(self):
        r"""GetTextColor(EDA_TEXT self) -> COLOR4D"""
        return _pcbnew.EDA_TEXT_GetTextColor(self)
 
    def SetTextPos(self, aPoint):
        r"""SetTextPos(EDA_TEXT self, VECTOR2I aPoint)"""
        return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)
 
    def GetTextPos(self):
        r"""GetTextPos(EDA_TEXT self) -> VECTOR2I"""
        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, VECTOR2I aOffset)"""
        return _pcbnew.EDA_TEXT_Offset(self, aOffset)
 
    def Empty(self):
        r"""Empty(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_Empty(self)
 
    @staticmethod
    def MapHorizJustify(aHorizJustify):
        r"""MapHorizJustify(int aHorizJustify) -> GR_TEXT_H_ALIGN_T"""
        return _pcbnew.EDA_TEXT_MapHorizJustify(aHorizJustify)
 
    @staticmethod
    def MapVertJustify(aVertJustify):
        r"""MapVertJustify(int aVertJustify) -> GR_TEXT_V_ALIGN_T"""
        return _pcbnew.EDA_TEXT_MapVertJustify(aVertJustify)
 
    def Print(self, aSettings, aOffset, aColor, aDisplay_mode=FILLED):
        r"""Print(EDA_TEXT self, RENDER_SETTINGS const * aSettings, VECTOR2I aOffset, COLOR4D aColor, OUTLINE_MODE aDisplay_mode=FILLED)"""
        return _pcbnew.EDA_TEXT_Print(self, aSettings, aOffset, aColor, aDisplay_mode)
 
    def GetEffectiveTextShape(self, *args):
        r"""GetEffectiveTextShape(EDA_TEXT self, bool aTriangulate=True, BOX2I aBBox=BOX2I(), EDA_ANGLE aAngle=ANGLE_0) -> std::shared_ptr< SHAPE_COMPOUND >"""
        return _pcbnew.EDA_TEXT_GetEffectiveTextShape(self, *args)
 
    def TextHitTest(self, *args):
        r"""
        TextHitTest(EDA_TEXT self, VECTOR2I aPoint, int aAccuracy=0) -> bool
        TextHitTest(EDA_TEXT self, BOX2I aRect, bool aContains, int aAccuracy=0) -> bool
        """
        return _pcbnew.EDA_TEXT_TextHitTest(self, *args)
 
    def GetTextBox(self, aSettings, aLine=-1):
        r"""GetTextBox(EDA_TEXT self, RENDER_SETTINGS const * aSettings, int aLine=-1) -> BOX2I"""
        return _pcbnew.EDA_TEXT_GetTextBox(self, aSettings, aLine)
 
    def GetInterline(self, aSettings):
        r"""GetInterline(EDA_TEXT self, RENDER_SETTINGS const * aSettings) -> int"""
        return _pcbnew.EDA_TEXT_GetInterline(self, aSettings)
 
    def GetTextStyleName(self):
        r"""GetTextStyleName(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetTextStyleName(self)
 
    def GetLinePositions(self, aSettings, aPositions, aLineCount):
        r"""GetLinePositions(EDA_TEXT self, RENDER_SETTINGS const * aSettings, VECTOR_VECTOR2I aPositions, int aLineCount)"""
        return _pcbnew.EDA_TEXT_GetLinePositions(self, aSettings, aPositions, aLineCount)
 
    def Levenshtein(self, aOther):
        r"""Levenshtein(EDA_TEXT self, EDA_TEXT aOther) -> double"""
        return _pcbnew.EDA_TEXT_Levenshtein(self, aOther)
 
    def Similarity(self, aOther):
        r"""Similarity(EDA_TEXT self, EDA_TEXT aOther) -> double"""
        return _pcbnew.EDA_TEXT_Similarity(self, aOther)
 
    def Format(self, aFormatter, aControlBits):
        r"""Format(EDA_TEXT self, OUTPUTFORMATTER aFormatter, int aControlBits)"""
        return _pcbnew.EDA_TEXT_Format(self, aFormatter, aControlBits)
 
    def GetDrawRotation(self):
        r"""GetDrawRotation(EDA_TEXT self) -> EDA_ANGLE"""
        return _pcbnew.EDA_TEXT_GetDrawRotation(self)
 
    def GetDrawPos(self):
        r"""GetDrawPos(EDA_TEXT self) -> VECTOR2I"""
        return _pcbnew.EDA_TEXT_GetDrawPos(self)
 
    def GetDrawFont(self, aSettings):
        r"""GetDrawFont(EDA_TEXT self, RENDER_SETTINGS const * aSettings) -> KIFONT::FONT *"""
        return _pcbnew.EDA_TEXT_GetDrawFont(self, aSettings)
 
    def ClearRenderCache(self):
        r"""ClearRenderCache(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_ClearRenderCache(self)
 
    def ClearBoundingBoxCache(self):
        r"""ClearBoundingBoxCache(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_ClearBoundingBoxCache(self)
 
    def GetRenderCache(self, *args):
        r"""GetRenderCache(EDA_TEXT self, KIFONT::FONT const * aFont, wxString forResolvedText, VECTOR2I aOffset={ 0, 0 }) -> std::vector< std::unique_ptr< KIFONT::GLYPH >,std::allocator< std::unique_ptr< KIFONT::GLYPH > > >"""
        return _pcbnew.EDA_TEXT_GetRenderCache(self, *args)
 
    def SetupRenderCache(self, aResolvedText, aFont, aAngle, aOffset):
        r"""SetupRenderCache(EDA_TEXT self, wxString aResolvedText, KIFONT::FONT const * aFont, EDA_ANGLE aAngle, VECTOR2I aOffset)"""
        return _pcbnew.EDA_TEXT_SetupRenderCache(self, aResolvedText, aFont, aAngle, aOffset)
 
    def AddRenderCacheGlyph(self, aPoly):
        r"""AddRenderCacheGlyph(EDA_TEXT self, SHAPE_POLY_SET aPoly)"""
        return _pcbnew.EDA_TEXT_AddRenderCacheGlyph(self, aPoly)
 
    def Compare(self, aOther):
        r"""Compare(EDA_TEXT self, EDA_TEXT aOther) -> int"""
        return _pcbnew.EDA_TEXT_Compare(self, aOther)
 
    def __eq__(self, aRhs):
        r"""__eq__(EDA_TEXT self, EDA_TEXT aRhs) -> bool"""
        return _pcbnew.EDA_TEXT___eq__(self, aRhs)
 
    def __lt__(self, aRhs):
        r"""__lt__(EDA_TEXT self, EDA_TEXT aRhs) -> bool"""
        return _pcbnew.EDA_TEXT___lt__(self, aRhs)
 
    def __gt__(self, aRhs):
        r"""__gt__(EDA_TEXT self, EDA_TEXT aRhs) -> bool"""
        return _pcbnew.EDA_TEXT___gt__(self, aRhs)
 
    def HasHyperlink(self):
        r"""HasHyperlink(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_HasHyperlink(self)
 
    def GetHyperlink(self):
        r"""GetHyperlink(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetHyperlink(self)
 
    def SetHyperlink(self, aLink):
        r"""SetHyperlink(EDA_TEXT self, wxString aLink)"""
        return _pcbnew.EDA_TEXT_SetHyperlink(self, aLink)
 
    def RemoveHyperlink(self):
        r"""RemoveHyperlink(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_RemoveHyperlink(self)
 
    @staticmethod
    def ValidateHyperlink(aURL):
        r"""ValidateHyperlink(wxString aURL) -> bool"""
        return _pcbnew.EDA_TEXT_ValidateHyperlink(aURL)
 
    @staticmethod
    def IsGotoPageHref(aHref, aDestination=None):
        r"""IsGotoPageHref(wxString aHref, wxString aDestination=None) -> bool"""
        return _pcbnew.EDA_TEXT_IsGotoPageHref(aHref, aDestination)
 
    @staticmethod
    def GotoPageHref(aDestination):
        r"""GotoPageHref(wxString aDestination) -> wxString"""
        return _pcbnew.EDA_TEXT_GotoPageHref(aDestination)
 
# Register EDA_TEXT in _pcbnew:
_pcbnew.EDA_TEXT_swigregister(EDA_TEXT)
 
def GetBuildVersion():
    r"""GetBuildVersion() -> wxString"""
    return _pcbnew.GetBuildVersion()
 
def GetBaseVersion():
    r"""GetBaseVersion() -> wxString"""
    return _pcbnew.GetBaseVersion()
 
def GetPlatformGetBitnessName():
    r"""GetPlatformGetBitnessName() -> wxString"""
    return _pcbnew.GetPlatformGetBitnessName()
 
def GetSemanticVersion():
    r"""GetSemanticVersion() -> wxString"""
    return _pcbnew.GetSemanticVersion()
 
def GetMajorMinorVersion():
    r"""GetMajorMinorVersion() -> wxString"""
    return _pcbnew.GetMajorMinorVersion()
 
def GetMajorMinorPatchVersion():
    r"""GetMajorMinorPatchVersion() -> wxString"""
    return _pcbnew.GetMajorMinorPatchVersion()
 
def GetBuildDate():
    r"""GetBuildDate() -> wxString"""
    return _pcbnew.GetBuildDate()
 
def GetCommitHash():
    r"""GetCommitHash() -> wxString"""
    return _pcbnew.GetCommitHash()
 
def GetMajorMinorPatchTuple():
    r"""GetMajorMinorPatchTuple() -> std::tuple< int,int,int > const &"""
    return _pcbnew.GetMajorMinorPatchTuple()
 
def IsNightlyVersion():
    r"""IsNightlyVersion() -> bool"""
    return _pcbnew.IsNightlyVersion()
 
def SetOpenGLInfo(aRenderer, aVendor, aVersion):
    r"""SetOpenGLInfo(char const * aRenderer, char const * aVendor, char const * aVersion)"""
    return _pcbnew.SetOpenGLInfo(aRenderer, aVendor, aVersion)
 
def GetVersionInfoData(aTitle, aHtml=False, aBrief=False):
    r"""GetVersionInfoData(wxString aTitle, bool aHtml=False, bool aBrief=False) -> wxString"""
    return _pcbnew.GetVersionInfoData(aTitle, aHtml, aBrief)
UNDEFINED_LAYER = _pcbnew.UNDEFINED_LAYER
 
UNSELECTED_LAYER = _pcbnew.UNSELECTED_LAYER
 
F_Cu = _pcbnew.F_Cu
 
B_Cu = _pcbnew.B_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
 
F_Mask = _pcbnew.F_Mask
 
B_Mask = _pcbnew.B_Mask
 
F_SilkS = _pcbnew.F_SilkS
 
B_SilkS = _pcbnew.B_SilkS
 
F_Adhes = _pcbnew.F_Adhes
 
B_Adhes = _pcbnew.B_Adhes
 
F_Paste = _pcbnew.F_Paste
 
B_Paste = _pcbnew.B_Paste
 
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
 
User_1 = _pcbnew.User_1
 
User_2 = _pcbnew.User_2
 
User_3 = _pcbnew.User_3
 
User_4 = _pcbnew.User_4
 
User_5 = _pcbnew.User_5
 
User_6 = _pcbnew.User_6
 
User_7 = _pcbnew.User_7
 
User_8 = _pcbnew.User_8
 
User_9 = _pcbnew.User_9
 
User_10 = _pcbnew.User_10
 
User_11 = _pcbnew.User_11
 
User_12 = _pcbnew.User_12
 
User_13 = _pcbnew.User_13
 
User_14 = _pcbnew.User_14
 
User_15 = _pcbnew.User_15
 
User_16 = _pcbnew.User_16
 
User_17 = _pcbnew.User_17
 
User_18 = _pcbnew.User_18
 
User_19 = _pcbnew.User_19
 
User_20 = _pcbnew.User_20
 
User_21 = _pcbnew.User_21
 
User_22 = _pcbnew.User_22
 
User_23 = _pcbnew.User_23
 
User_24 = _pcbnew.User_24
 
User_25 = _pcbnew.User_25
 
User_26 = _pcbnew.User_26
 
User_27 = _pcbnew.User_27
 
User_28 = _pcbnew.User_28
 
User_29 = _pcbnew.User_29
 
User_30 = _pcbnew.User_30
 
User_31 = _pcbnew.User_31
 
User_32 = _pcbnew.User_32
 
User_33 = _pcbnew.User_33
 
User_34 = _pcbnew.User_34
 
User_35 = _pcbnew.User_35
 
User_36 = _pcbnew.User_36
 
User_37 = _pcbnew.User_37
 
User_38 = _pcbnew.User_38
 
User_39 = _pcbnew.User_39
 
User_40 = _pcbnew.User_40
 
User_41 = _pcbnew.User_41
 
User_42 = _pcbnew.User_42
 
User_43 = _pcbnew.User_43
 
User_44 = _pcbnew.User_44
 
User_45 = _pcbnew.User_45
 
PCB_LAYER_ID_COUNT = _pcbnew.PCB_LAYER_ID_COUNT
 
MAX_CU_LAYERS = _pcbnew.MAX_CU_LAYERS
 
MAX_USER_DEFINED_LAYERS = _pcbnew.MAX_USER_DEFINED_LAYERS
 
FLASHING_DEFAULT = _pcbnew.FLASHING_DEFAULT
 
FLASHING_ALWAYS_FLASHED = _pcbnew.FLASHING_ALWAYS_FLASHED
 
FLASHING_NEVER_FLASHED = _pcbnew.FLASHING_NEVER_FLASHED
 
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_PAD_NETNAMES = _pcbnew.LAYER_PAD_NETNAMES
 
LAYER_VIA_NETNAMES = _pcbnew.LAYER_VIA_NETNAMES
 
NETNAMES_LAYER_ID_END = _pcbnew.NETNAMES_LAYER_ID_END
 
GAL_UI_LAYER_COUNT = _pcbnew.GAL_UI_LAYER_COUNT
 
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_FP_TEXT = _pcbnew.LAYER_FP_TEXT
 
LAYER_ANCHOR = _pcbnew.LAYER_ANCHOR
 
LAYER_RATSNEST = _pcbnew.LAYER_RATSNEST
 
LAYER_GRID = _pcbnew.LAYER_GRID
 
LAYER_GRID_AXES = _pcbnew.LAYER_GRID_AXES
 
LAYER_FOOTPRINTS_FR = _pcbnew.LAYER_FOOTPRINTS_FR
 
LAYER_FOOTPRINTS_BK = _pcbnew.LAYER_FOOTPRINTS_BK
 
LAYER_FP_VALUES = _pcbnew.LAYER_FP_VALUES
 
LAYER_FP_REFERENCES = _pcbnew.LAYER_FP_REFERENCES
 
LAYER_TRACKS = _pcbnew.LAYER_TRACKS
 
LAYER_PAD_PLATEDHOLES = _pcbnew.LAYER_PAD_PLATEDHOLES
 
LAYER_VIA_HOLES = _pcbnew.LAYER_VIA_HOLES
 
LAYER_DRC_ERROR = _pcbnew.LAYER_DRC_ERROR
 
LAYER_DRAWINGSHEET = _pcbnew.LAYER_DRAWINGSHEET
 
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
 
LAYER_PADS = _pcbnew.LAYER_PADS
 
LAYER_ZONES = _pcbnew.LAYER_ZONES
 
LAYER_PAD_HOLEWALLS = _pcbnew.LAYER_PAD_HOLEWALLS
 
LAYER_VIA_HOLEWALLS = _pcbnew.LAYER_VIA_HOLEWALLS
 
LAYER_DRC_WARNING = _pcbnew.LAYER_DRC_WARNING
 
LAYER_DRC_EXCLUSION = _pcbnew.LAYER_DRC_EXCLUSION
 
LAYER_MARKER_SHADOWS = _pcbnew.LAYER_MARKER_SHADOWS
 
LAYER_LOCKED_ITEM_SHADOW = _pcbnew.LAYER_LOCKED_ITEM_SHADOW
 
LAYER_CONFLICTS_SHADOW = _pcbnew.LAYER_CONFLICTS_SHADOW
 
LAYER_FILLED_SHAPES = _pcbnew.LAYER_FILLED_SHAPES
 
LAYER_DRC_SHAPE1 = _pcbnew.LAYER_DRC_SHAPE1
 
LAYER_DRC_SHAPE2 = _pcbnew.LAYER_DRC_SHAPE2
 
LAYER_DRAWINGSHEET_PAGE1 = _pcbnew.LAYER_DRAWINGSHEET_PAGE1
 
LAYER_DRAWINGSHEET_PAGEn = _pcbnew.LAYER_DRAWINGSHEET_PAGEn
 
LAYER_PAGE_LIMITS = _pcbnew.LAYER_PAGE_LIMITS
 
LAYER_ZONE_START = _pcbnew.LAYER_ZONE_START
 
LAYER_ZONE_END = _pcbnew.LAYER_ZONE_END
 
LAYER_PAD_COPPER_START = _pcbnew.LAYER_PAD_COPPER_START
 
LAYER_PAD_COPPER_END = _pcbnew.LAYER_PAD_COPPER_END
 
LAYER_VIA_COPPER_START = _pcbnew.LAYER_VIA_COPPER_START
 
LAYER_VIA_COPPER_END = _pcbnew.LAYER_VIA_COPPER_END
 
LAYER_CLEARANCE_START = _pcbnew.LAYER_CLEARANCE_START
 
LAYER_CLEARANCE_END = _pcbnew.LAYER_CLEARANCE_END
 
LAYER_BITMAP_START = _pcbnew.LAYER_BITMAP_START
 
LAYER_BITMAP_END = _pcbnew.LAYER_BITMAP_END
 
LAYER_UI_START = _pcbnew.LAYER_UI_START
 
LAYER_UI_END = _pcbnew.LAYER_UI_END
 
GAL_LAYER_ID_END = _pcbnew.GAL_LAYER_ID_END
 
 
def ToGalLayer(aInteger):
    r"""ToGalLayer(int aInteger) -> GAL_LAYER_ID"""
    return _pcbnew.ToGalLayer(aInteger)
class GAL_SET(object):
    r"""Proxy of C++ GAL_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__(GAL_SET self) -> GAL_SET
        __init__(GAL_SET self, GAL_SET aOther) -> GAL_SET
        __init__(GAL_SET self, GAL_LAYER_ID const * aArray, unsigned int aCount) -> GAL_SET
        """
        _pcbnew.GAL_SET_swiginit(self, _pcbnew.new_GAL_SET(*args))
 
    def set(self, *args):
        r"""
        set(GAL_SET self) -> GAL_SET
        set(GAL_SET self, int aPos, bool aVal=True) -> GAL_SET
        set(GAL_SET self, GAL_LAYER_ID aPos, bool aVal=True) -> GAL_SET
        """
        return _pcbnew.GAL_SET_set(self, *args)
 
    def Contains(self, aPos):
        r"""Contains(GAL_SET self, GAL_LAYER_ID aPos) -> bool"""
        return _pcbnew.GAL_SET_Contains(self, aPos)
 
    def Seq(self):
        r"""Seq(GAL_SET self) -> std::vector< GAL_LAYER_ID,std::allocator< GAL_LAYER_ID > >"""
        return _pcbnew.GAL_SET_Seq(self)
 
    @staticmethod
    def DefaultVisible():
        r"""DefaultVisible() -> GAL_SET"""
        return _pcbnew.GAL_SET_DefaultVisible()
    __swig_destroy__ = _pcbnew.delete_GAL_SET
 
# Register GAL_SET in _pcbnew:
_pcbnew.GAL_SET_swigregister(GAL_SET)
PCBNEW_LAYER_ID_START = cvar.PCBNEW_LAYER_ID_START
GAL_LAYER_ID_COUNT = cvar.GAL_LAYER_ID_COUNT
 
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_INTERSHEET_REFS = _pcbnew.LAYER_INTERSHEET_REFS
 
LAYER_NETCLASS_REFS = _pcbnew.LAYER_NETCLASS_REFS
 
LAYER_RULE_AREAS = _pcbnew.LAYER_RULE_AREAS
 
LAYER_DEVICE = _pcbnew.LAYER_DEVICE
 
LAYER_NOTES = _pcbnew.LAYER_NOTES
 
LAYER_PRIVATE_NOTES = _pcbnew.LAYER_PRIVATE_NOTES
 
LAYER_NOTES_BACKGROUND = _pcbnew.LAYER_NOTES_BACKGROUND
 
LAYER_PIN = _pcbnew.LAYER_PIN
 
LAYER_SHEET = _pcbnew.LAYER_SHEET
 
LAYER_SHEETNAME = _pcbnew.LAYER_SHEETNAME
 
LAYER_SHEETFILENAME = _pcbnew.LAYER_SHEETFILENAME
 
LAYER_SHEETFIELDS = _pcbnew.LAYER_SHEETFIELDS
 
LAYER_SHEETLABEL = _pcbnew.LAYER_SHEETLABEL
 
LAYER_NOCONNECT = _pcbnew.LAYER_NOCONNECT
 
LAYER_DANGLING = _pcbnew.LAYER_DANGLING
 
LAYER_DNP_MARKER = _pcbnew.LAYER_DNP_MARKER
 
LAYER_ERC_WARN = _pcbnew.LAYER_ERC_WARN
 
LAYER_ERC_ERR = _pcbnew.LAYER_ERC_ERR
 
LAYER_ERC_EXCLUSION = _pcbnew.LAYER_ERC_EXCLUSION
 
LAYER_EXCLUDED_FROM_SIM = _pcbnew.LAYER_EXCLUDED_FROM_SIM
 
LAYER_SHAPES_BACKGROUND = _pcbnew.LAYER_SHAPES_BACKGROUND
 
LAYER_DEVICE_BACKGROUND = _pcbnew.LAYER_DEVICE_BACKGROUND
 
LAYER_SHEET_BACKGROUND = _pcbnew.LAYER_SHEET_BACKGROUND
 
LAYER_SCHEMATIC_GRID = _pcbnew.LAYER_SCHEMATIC_GRID
 
LAYER_SCHEMATIC_GRID_AXES = _pcbnew.LAYER_SCHEMATIC_GRID_AXES
 
LAYER_SCHEMATIC_BACKGROUND = _pcbnew.LAYER_SCHEMATIC_BACKGROUND
 
LAYER_SCHEMATIC_CURSOR = _pcbnew.LAYER_SCHEMATIC_CURSOR
 
LAYER_HOVERED = _pcbnew.LAYER_HOVERED
 
LAYER_BRIGHTENED = _pcbnew.LAYER_BRIGHTENED
 
LAYER_HIDDEN = _pcbnew.LAYER_HIDDEN
 
LAYER_NET_COLOR_HIGHLIGHT = _pcbnew.LAYER_NET_COLOR_HIGHLIGHT
 
LAYER_SELECTION_SHADOWS = _pcbnew.LAYER_SELECTION_SHADOWS
 
LAYER_SCHEMATIC_DRAWINGSHEET = _pcbnew.LAYER_SCHEMATIC_DRAWINGSHEET
 
LAYER_SCHEMATIC_PAGE_LIMITS = _pcbnew.LAYER_SCHEMATIC_PAGE_LIMITS
 
LAYER_BUS_JUNCTION = _pcbnew.LAYER_BUS_JUNCTION
 
LAYER_SCHEMATIC_AUX_ITEMS = _pcbnew.LAYER_SCHEMATIC_AUX_ITEMS
 
LAYER_SCHEMATIC_ANCHOR = _pcbnew.LAYER_SCHEMATIC_ANCHOR
 
LAYER_OP_VOLTAGES = _pcbnew.LAYER_OP_VOLTAGES
 
LAYER_OP_CURRENTS = _pcbnew.LAYER_OP_CURRENTS
 
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
 
LAYER_GERBVIEW_DRAWINGSHEET = _pcbnew.LAYER_GERBVIEW_DRAWINGSHEET
 
LAYER_GERBVIEW_PAGE_LIMITS = _pcbnew.LAYER_GERBVIEW_PAGE_LIMITS
 
GERBVIEW_LAYER_ID_END = _pcbnew.GERBVIEW_LAYER_ID_END
 
LAYER_3D_START = _pcbnew.LAYER_3D_START
 
LAYER_3D_BACKGROUND_BOTTOM = _pcbnew.LAYER_3D_BACKGROUND_BOTTOM
 
LAYER_3D_BACKGROUND_TOP = _pcbnew.LAYER_3D_BACKGROUND_TOP
 
LAYER_3D_BOARD = _pcbnew.LAYER_3D_BOARD
 
LAYER_3D_COPPER_TOP = _pcbnew.LAYER_3D_COPPER_TOP
 
LAYER_3D_COPPER_BOTTOM = _pcbnew.LAYER_3D_COPPER_BOTTOM
 
LAYER_3D_SILKSCREEN_BOTTOM = _pcbnew.LAYER_3D_SILKSCREEN_BOTTOM
 
LAYER_3D_SILKSCREEN_TOP = _pcbnew.LAYER_3D_SILKSCREEN_TOP
 
LAYER_3D_SOLDERMASK_BOTTOM = _pcbnew.LAYER_3D_SOLDERMASK_BOTTOM
 
LAYER_3D_SOLDERMASK_TOP = _pcbnew.LAYER_3D_SOLDERMASK_TOP
 
LAYER_3D_SOLDERPASTE = _pcbnew.LAYER_3D_SOLDERPASTE
 
LAYER_3D_ADHESIVE = _pcbnew.LAYER_3D_ADHESIVE
 
LAYER_3D_USER_COMMENTS = _pcbnew.LAYER_3D_USER_COMMENTS
 
LAYER_3D_USER_DRAWINGS = _pcbnew.LAYER_3D_USER_DRAWINGS
 
LAYER_3D_USER_ECO1 = _pcbnew.LAYER_3D_USER_ECO1
 
LAYER_3D_USER_ECO2 = _pcbnew.LAYER_3D_USER_ECO2
 
LAYER_3D_USER_1 = _pcbnew.LAYER_3D_USER_1
 
LAYER_3D_USER_2 = _pcbnew.LAYER_3D_USER_2
 
LAYER_3D_USER_3 = _pcbnew.LAYER_3D_USER_3
 
LAYER_3D_USER_4 = _pcbnew.LAYER_3D_USER_4
 
LAYER_3D_USER_5 = _pcbnew.LAYER_3D_USER_5
 
LAYER_3D_USER_6 = _pcbnew.LAYER_3D_USER_6
 
LAYER_3D_USER_7 = _pcbnew.LAYER_3D_USER_7
 
LAYER_3D_USER_8 = _pcbnew.LAYER_3D_USER_8
 
LAYER_3D_USER_9 = _pcbnew.LAYER_3D_USER_9
 
LAYER_3D_USER_10 = _pcbnew.LAYER_3D_USER_10
 
LAYER_3D_USER_11 = _pcbnew.LAYER_3D_USER_11
 
LAYER_3D_USER_12 = _pcbnew.LAYER_3D_USER_12
 
LAYER_3D_USER_13 = _pcbnew.LAYER_3D_USER_13
 
LAYER_3D_USER_14 = _pcbnew.LAYER_3D_USER_14
 
LAYER_3D_USER_15 = _pcbnew.LAYER_3D_USER_15
 
LAYER_3D_USER_16 = _pcbnew.LAYER_3D_USER_16
 
LAYER_3D_USER_17 = _pcbnew.LAYER_3D_USER_17
 
LAYER_3D_USER_18 = _pcbnew.LAYER_3D_USER_18
 
LAYER_3D_USER_19 = _pcbnew.LAYER_3D_USER_19
 
LAYER_3D_USER_20 = _pcbnew.LAYER_3D_USER_20
 
LAYER_3D_USER_21 = _pcbnew.LAYER_3D_USER_21
 
LAYER_3D_USER_22 = _pcbnew.LAYER_3D_USER_22
 
LAYER_3D_USER_23 = _pcbnew.LAYER_3D_USER_23
 
LAYER_3D_USER_24 = _pcbnew.LAYER_3D_USER_24
 
LAYER_3D_USER_25 = _pcbnew.LAYER_3D_USER_25
 
LAYER_3D_USER_26 = _pcbnew.LAYER_3D_USER_26
 
LAYER_3D_USER_27 = _pcbnew.LAYER_3D_USER_27
 
LAYER_3D_USER_28 = _pcbnew.LAYER_3D_USER_28
 
LAYER_3D_USER_29 = _pcbnew.LAYER_3D_USER_29
 
LAYER_3D_USER_30 = _pcbnew.LAYER_3D_USER_30
 
LAYER_3D_USER_31 = _pcbnew.LAYER_3D_USER_31
 
LAYER_3D_USER_32 = _pcbnew.LAYER_3D_USER_32
 
LAYER_3D_USER_33 = _pcbnew.LAYER_3D_USER_33
 
LAYER_3D_USER_34 = _pcbnew.LAYER_3D_USER_34
 
LAYER_3D_USER_35 = _pcbnew.LAYER_3D_USER_35
 
LAYER_3D_USER_36 = _pcbnew.LAYER_3D_USER_36
 
LAYER_3D_USER_37 = _pcbnew.LAYER_3D_USER_37
 
LAYER_3D_USER_38 = _pcbnew.LAYER_3D_USER_38
 
LAYER_3D_USER_39 = _pcbnew.LAYER_3D_USER_39
 
LAYER_3D_USER_40 = _pcbnew.LAYER_3D_USER_40
 
LAYER_3D_USER_41 = _pcbnew.LAYER_3D_USER_41
 
LAYER_3D_USER_42 = _pcbnew.LAYER_3D_USER_42
 
LAYER_3D_USER_43 = _pcbnew.LAYER_3D_USER_43
 
LAYER_3D_USER_44 = _pcbnew.LAYER_3D_USER_44
 
LAYER_3D_USER_45 = _pcbnew.LAYER_3D_USER_45
 
LAYER_3D_TH_MODELS = _pcbnew.LAYER_3D_TH_MODELS
 
LAYER_3D_SMD_MODELS = _pcbnew.LAYER_3D_SMD_MODELS
 
LAYER_3D_VIRTUAL_MODELS = _pcbnew.LAYER_3D_VIRTUAL_MODELS
 
LAYER_3D_MODELS_NOT_IN_POS = _pcbnew.LAYER_3D_MODELS_NOT_IN_POS
 
LAYER_3D_MODELS_MARKED_DNP = _pcbnew.LAYER_3D_MODELS_MARKED_DNP
 
LAYER_3D_AXES = _pcbnew.LAYER_3D_AXES
 
LAYER_3D_BOUNDING_BOXES = _pcbnew.LAYER_3D_BOUNDING_BOXES
 
LAYER_3D_OFF_BOARD_SILK = _pcbnew.LAYER_3D_OFF_BOARD_SILK
 
LAYER_3D_END = _pcbnew.LAYER_3D_END
 
 
def LayerName(aLayer):
    r"""LayerName(int aLayer) -> wxString"""
    return _pcbnew.LayerName(aLayer)
 
def IsValidLayer(aLayerId):
    r"""IsValidLayer(int aLayerId) -> bool"""
    return _pcbnew.IsValidLayer(aLayerId)
 
def IsPcbLayer(aLayer):
    r"""IsPcbLayer(int aLayer) -> bool"""
    return _pcbnew.IsPcbLayer(aLayer)
 
def IsExternalCopperLayer(aLayerId):
    r"""IsExternalCopperLayer(int aLayerId) -> bool"""
    return _pcbnew.IsExternalCopperLayer(aLayerId)
 
def IsInnerCopperLayer(aLayerId):
    r"""IsInnerCopperLayer(int aLayerId) -> bool"""
    return _pcbnew.IsInnerCopperLayer(aLayerId)
 
def IsNonCopperLayer(aLayerId):
    r"""IsNonCopperLayer(int aLayerId) -> bool"""
    return _pcbnew.IsNonCopperLayer(aLayerId)
 
def IsCopperLayer(*args):
    r"""
    IsCopperLayer(int aLayerId) -> bool
    IsCopperLayer(int aLayerId, bool aIncludeSyntheticCopperLayers) -> bool
    """
    return _pcbnew.IsCopperLayer(*args)
 
def IsViaPadLayer(aLayer):
    r"""IsViaPadLayer(int aLayer) -> bool"""
    return _pcbnew.IsViaPadLayer(aLayer)
 
def IsHoleLayer(aLayer):
    r"""IsHoleLayer(int aLayer) -> bool"""
    return _pcbnew.IsHoleLayer(aLayer)
 
def IsSolderMaskLayer(aLayer):
    r"""IsSolderMaskLayer(int aLayer) -> bool"""
    return _pcbnew.IsSolderMaskLayer(aLayer)
 
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 IsCopperLayerLowerThan(aLayerA, aLayerB):
    r"""IsCopperLayerLowerThan(PCB_LAYER_ID aLayerA, PCB_LAYER_ID aLayerB) -> bool"""
    return _pcbnew.IsCopperLayerLowerThan(aLayerA, aLayerB)
 
def FlipLayer(aLayerId, aCopperLayersCount=0):
    r"""FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount=0) -> PCB_LAYER_ID"""
    return _pcbnew.FlipLayer(aLayerId, aCopperLayersCount)
 
def GetNetnameLayer(aLayer):
    r"""GetNetnameLayer(int aLayer) -> int"""
    return _pcbnew.GetNetnameLayer(aLayer)
 
def IsNetnameLayer(aLayer):
    r"""IsNetnameLayer(int aLayer) -> bool"""
    return _pcbnew.IsNetnameLayer(aLayer)
 
def IsZoneFillLayer(aLayer):
    r"""IsZoneFillLayer(int aLayer) -> bool"""
    return _pcbnew.IsZoneFillLayer(aLayer)
 
def IsPadCopperLayer(aLayer):
    r"""IsPadCopperLayer(int aLayer) -> bool"""
    return _pcbnew.IsPadCopperLayer(aLayer)
 
def IsViaCopperLayer(aLayer):
    r"""IsViaCopperLayer(int aLayer) -> bool"""
    return _pcbnew.IsViaCopperLayer(aLayer)
 
def IsClearanceLayer(aLayer):
    r"""IsClearanceLayer(int aLayer) -> bool"""
    return _pcbnew.IsClearanceLayer(aLayer)
 
def IsDCodeLayer(aLayer):
    r"""IsDCodeLayer(int aLayer) -> bool"""
    return _pcbnew.IsDCodeLayer(aLayer)
 
def CopperLayerToOrdinal(aLayer):
    r"""CopperLayerToOrdinal(PCB_LAYER_ID aLayer) -> size_t"""
    return _pcbnew.CopperLayerToOrdinal(aLayer)
 
def BoardLayerFromLegacyId(aLegacyId):
    r"""BoardLayerFromLegacyId(int aLegacyId) -> PCB_LAYER_ID"""
    return _pcbnew.BoardLayerFromLegacyId(aLegacyId)
 
def Map3DLayerToPCBLayer(aLayer):
    r"""Map3DLayerToPCBLayer(int aLayer) -> PCB_LAYER_ID"""
    return _pcbnew.Map3DLayerToPCBLayer(aLayer)
 
def MapPCBLayerTo3DLayer(aLayer):
    r"""MapPCBLayerTo3DLayer(PCB_LAYER_ID aLayer) -> int"""
    return _pcbnew.MapPCBLayerTo3DLayer(aLayer)
 
def ToLAYER_ID(aLayer):
    r"""ToLAYER_ID(int aLayer) -> PCB_LAYER_ID"""
    return _pcbnew.ToLAYER_ID(aLayer)
class SETTINGS_MANAGER(object):
    r"""Proxy of C++ SETTINGS_MANAGER 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, aHeadless=False):
        r"""__init__(SETTINGS_MANAGER self, bool aHeadless=False) -> SETTINGS_MANAGER"""
        _pcbnew.SETTINGS_MANAGER_swiginit(self, _pcbnew.new_SETTINGS_MANAGER(aHeadless))
    __swig_destroy__ = _pcbnew.delete_SETTINGS_MANAGER
 
    def IsOK(self):
        r"""IsOK(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsOK(self)
 
    def SetKiway(self, aKiway):
        r"""SetKiway(SETTINGS_MANAGER self, KIWAY * aKiway)"""
        return _pcbnew.SETTINGS_MANAGER_SetKiway(self, aKiway)
 
    def Load(self, *args):
        r"""
        Load(SETTINGS_MANAGER self)
        Load(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings)
        """
        return _pcbnew.SETTINGS_MANAGER_Load(self, *args)
 
    def Save(self, *args):
        r"""
        Save(SETTINGS_MANAGER self)
        Save(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings)
        """
        return _pcbnew.SETTINGS_MANAGER_Save(self, *args)
 
    def FlushAndRelease(self, aSettings, aSave=True):
        r"""FlushAndRelease(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings, bool aSave=True)"""
        return _pcbnew.SETTINGS_MANAGER_FlushAndRelease(self, aSettings, aSave)
 
    def GetColorSettings(self, *args):
        r"""GetColorSettings(SETTINGS_MANAGER self, wxString aName="user") -> COLOR_SETTINGS"""
        return _pcbnew.SETTINGS_MANAGER_GetColorSettings(self, *args)
 
    def GetColorSettingsList(self):
        r"""GetColorSettingsList(SETTINGS_MANAGER self) -> std::vector< COLOR_SETTINGS *,std::allocator< COLOR_SETTINGS * > >"""
        return _pcbnew.SETTINGS_MANAGER_GetColorSettingsList(self)
 
    def SaveColorSettings(self, *args):
        r"""SaveColorSettings(SETTINGS_MANAGER self, COLOR_SETTINGS * aSettings, string aNamespace="")"""
        return _pcbnew.SETTINGS_MANAGER_SaveColorSettings(self, *args)
 
    def AddNewColorSettings(self, aFilename):
        r"""AddNewColorSettings(SETTINGS_MANAGER self, wxString aFilename) -> COLOR_SETTINGS *"""
        return _pcbnew.SETTINGS_MANAGER_AddNewColorSettings(self, aFilename)
 
    def GetMigratedColorSettings(self):
        r"""GetMigratedColorSettings(SETTINGS_MANAGER self) -> COLOR_SETTINGS *"""
        return _pcbnew.SETTINGS_MANAGER_GetMigratedColorSettings(self)
 
    def GetCommonSettings(self):
        r"""GetCommonSettings(SETTINGS_MANAGER self) -> COMMON_SETTINGS *"""
        return _pcbnew.SETTINGS_MANAGER_GetCommonSettings(self)
 
    def GetPathForSettingsFile(self, aSettings):
        r"""GetPathForSettingsFile(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings) -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetPathForSettingsFile(self, aSettings)
 
    def MigrateIfNeeded(self):
        r"""MigrateIfNeeded(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_MigrateIfNeeded(self)
 
    def SetMigrationSource(self, aSource):
        r"""SetMigrationSource(SETTINGS_MANAGER self, wxString aSource)"""
        return _pcbnew.SETTINGS_MANAGER_SetMigrationSource(self, aSource)
 
    def SetMigrateLibraryTables(self, aMigrate=True):
        r"""SetMigrateLibraryTables(SETTINGS_MANAGER self, bool aMigrate=True)"""
        return _pcbnew.SETTINGS_MANAGER_SetMigrateLibraryTables(self, aMigrate)
 
    def GetPreviousVersionPaths(self, aName=None):
        r"""GetPreviousVersionPaths(SETTINGS_MANAGER self, std::vector< wxString,std::allocator< wxString > > * aName=None) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_GetPreviousVersionPaths(self, aName)
 
    def ReloadColorSettings(self):
        r"""ReloadColorSettings(SETTINGS_MANAGER self)"""
        return _pcbnew.SETTINGS_MANAGER_ReloadColorSettings(self)
 
    def LoadProject(self, aFullPath, aSetActive=True):
        r"""LoadProject(SETTINGS_MANAGER self, wxString aFullPath, bool aSetActive=True) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_LoadProject(self, aFullPath, aSetActive)
 
    def UnloadProject(self, aProject, aSave=True):
        r"""UnloadProject(SETTINGS_MANAGER self, PROJECT * aProject, bool aSave=True) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_UnloadProject(self, aProject, aSave)
 
    def IsProjectOpen(self):
        r"""IsProjectOpen(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsProjectOpen(self)
 
    def IsProjectOpenNotDummy(self):
        r"""IsProjectOpenNotDummy(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsProjectOpenNotDummy(self)
 
    def Prj(self):
        r"""Prj(SETTINGS_MANAGER self) -> PROJECT &"""
        return _pcbnew.SETTINGS_MANAGER_Prj(self)
 
    def GetProject(self, aFullPath):
        r"""GetProject(SETTINGS_MANAGER self, wxString aFullPath) -> PROJECT *"""
        return _pcbnew.SETTINGS_MANAGER_GetProject(self, aFullPath)
 
    def GetOpenProjects(self):
        r"""GetOpenProjects(SETTINGS_MANAGER self) -> std::vector< wxString,std::allocator< wxString > >"""
        return _pcbnew.SETTINGS_MANAGER_GetOpenProjects(self)
 
    def SaveProject(self, *args):
        r"""SaveProject(SETTINGS_MANAGER self, wxString aFullPath=wxEmptyString, PROJECT * aProject=None) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_SaveProject(self, *args)
 
    def SaveProjectAs(self, aFullPath, aProject=None):
        r"""SaveProjectAs(SETTINGS_MANAGER self, wxString aFullPath, PROJECT * aProject=None)"""
        return _pcbnew.SETTINGS_MANAGER_SaveProjectAs(self, aFullPath, aProject)
 
    def SaveProjectCopy(self, aFullPath, aProject=None):
        r"""SaveProjectCopy(SETTINGS_MANAGER self, wxString aFullPath, PROJECT * aProject=None)"""
        return _pcbnew.SETTINGS_MANAGER_SaveProjectCopy(self, aFullPath, aProject)
 
    def GetProjectBackupsPath(self):
        r"""GetProjectBackupsPath(SETTINGS_MANAGER self) -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetProjectBackupsPath(self)
 
    def BackupProject(self, aReporter, aTarget):
        r"""BackupProject(SETTINGS_MANAGER self, REPORTER & aReporter, wxFileName & aTarget) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_BackupProject(self, aReporter, aTarget)
 
    def TriggerBackupIfNeeded(self, aReporter):
        r"""TriggerBackupIfNeeded(SETTINGS_MANAGER self, REPORTER & aReporter) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_TriggerBackupIfNeeded(self, aReporter)
 
    @staticmethod
    def IsSettingsPathValid(aPath):
        r"""IsSettingsPathValid(wxString aPath) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsSettingsPathValid(aPath)
 
    @staticmethod
    def GetColorSettingsPath():
        r"""GetColorSettingsPath() -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetColorSettingsPath()
 
    @staticmethod
    def GetSettingsVersion():
        r"""GetSettingsVersion() -> string"""
        return _pcbnew.SETTINGS_MANAGER_GetSettingsVersion()
 
    @staticmethod
    def GetUserSettingsPath():
        r"""GetUserSettingsPath() -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetUserSettingsPath()
 
# Register SETTINGS_MANAGER in _pcbnew:
_pcbnew.SETTINGS_MANAGER_swigregister(SETTINGS_MANAGER)
class UTILS_BOX3D(object):
    r"""Proxy of C++ UTILS_BOX3D class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def Min(self):
        r"""Min(UTILS_BOX3D self) -> VECTOR3D"""
        return _pcbnew.UTILS_BOX3D_Min(self)
 
    def Max(self):
        r"""Max(UTILS_BOX3D self) -> VECTOR3D"""
        return _pcbnew.UTILS_BOX3D_Max(self)
 
    def GetCenter(self):
        r"""GetCenter(UTILS_BOX3D self) -> VECTOR3D"""
        return _pcbnew.UTILS_BOX3D_GetCenter(self)
 
    def GetSize(self):
        r"""GetSize(UTILS_BOX3D self) -> VECTOR3D"""
        return _pcbnew.UTILS_BOX3D_GetSize(self)
 
    def __init__(self):
        r"""__init__(UTILS_BOX3D self) -> UTILS_BOX3D"""
        _pcbnew.UTILS_BOX3D_swiginit(self, _pcbnew.new_UTILS_BOX3D())
    __swig_destroy__ = _pcbnew.delete_UTILS_BOX3D
 
# Register UTILS_BOX3D in _pcbnew:
_pcbnew.UTILS_BOX3D_swigregister(UTILS_BOX3D)
class UTILS_STEP_MODEL(object):
    r"""Proxy of C++ UTILS_STEP_MODEL class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def GetBoundingBox(self):
        r"""GetBoundingBox(UTILS_STEP_MODEL self) -> UTILS_BOX3D"""
        return _pcbnew.UTILS_STEP_MODEL_GetBoundingBox(self)
 
    def Translate(self, aX, aY, aZ):
        r"""Translate(UTILS_STEP_MODEL self, double aX, double aY, double aZ)"""
        return _pcbnew.UTILS_STEP_MODEL_Translate(self, aX, aY, aZ)
 
    def Scale(self, aScale):
        r"""Scale(UTILS_STEP_MODEL self, double aScale)"""
        return _pcbnew.UTILS_STEP_MODEL_Scale(self, aScale)
 
    def SaveSTEP(self, aFileName):
        r"""SaveSTEP(UTILS_STEP_MODEL self, wxString aFileName) -> bool"""
        return _pcbnew.UTILS_STEP_MODEL_SaveSTEP(self, aFileName)
 
    @staticmethod
    def LoadSTEP(aFileName):
        r"""LoadSTEP(wxString aFileName) -> UTILS_STEP_MODEL"""
        return _pcbnew.UTILS_STEP_MODEL_LoadSTEP(aFileName)
 
    def __init__(self):
        r"""__init__(UTILS_STEP_MODEL self) -> UTILS_STEP_MODEL"""
        _pcbnew.UTILS_STEP_MODEL_swiginit(self, _pcbnew.new_UTILS_STEP_MODEL())
 
# Register UTILS_STEP_MODEL in _pcbnew:
_pcbnew.UTILS_STEP_MODEL_swigregister(UTILS_STEP_MODEL)
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, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.intVector___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(intVector self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, intVector v)
        __setitem__(intVector self, SWIGPY_SLICEOBJECT * 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)
 
 
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
    Warning: strings (internally unicode) are returned as UTF-8 compatible C strings
"""
 
FULL_BACK_TRACE=""
 
def GetUnLoadableWizards():
    global NOT_LOADED_WIZARDS
    import sys
 
    if sys.version_info[0] < 3:
        utf8_str = NOT_LOADED_WIZARDS.encode( 'UTF-8' )
    else:
        utf8_str = NOT_LOADED_WIZARDS
 
    return utf8_str
 
def GetWizardsSearchPaths():
    global PLUGIN_DIRECTORIES_SEARCH
    import sys
 
    if sys.version_info[0] < 3:
        utf8_str = PLUGIN_DIRECTORIES_SEARCH.encode( 'UTF-8' )
    else:
        utf8_str = PLUGIN_DIRECTORIES_SEARCH
 
    return utf8_str
 
def GetWizardsBackTrace():
    global FULL_BACK_TRACE  # Already correct format
    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
    global KICAD_PLUGINS
 
    try:  # If there is an error loading the script, skip it
 
        module_filename = os.path.join( Dirname, FileName )
        mtime = os.path.getmtime( module_filename )
        mods_before = set( sys.modules )
 
        if ModuleName in KICAD_PLUGINS:
            plugin = KICAD_PLUGINS[ModuleName]
 
            for dependency in plugin["dependencies"]:
                if dependency in sys.modules:
                    del sys.modules[dependency]
 
            mods_before = set( sys.modules )
 
        if sys.version_info >= (3,0,0):
            import importlib
            mod = importlib.import_module( ModuleName )
        else:
            mod = __import__( ModuleName, locals(), globals() )
 
        mods_after = set( sys.modules ).difference( mods_before )
        dependencies = [m for m in mods_after if m.startswith(ModuleName)]
 
        KICAD_PLUGINS[ModuleName]={ "filename":module_filename,
                                    "modification_time":mtime,
                                    "ModuleName":mod,
                                    "dependencies": dependencies }
 
    except:
        if ModuleName in KICAD_PLUGINS:
            del KICAD_PLUGINS[ModuleName]
 
        if NOT_LOADED_WIZARDS != "" :
            NOT_LOADED_WIZARDS += "\n"
        NOT_LOADED_WIZARDS += module_filename
        FULL_BACK_TRACE += traceback.format_exc()
 
 
def LoadPlugins(bundlepath=None, userpath=None, thirdpartypath=None):
    """
    Initialise Scripting/Plugin python environment and load plugins.
 
    Arguments:
    Note: bundlepath and userpath are given  utf8 encoded, to be compatible with asimple C string
    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 Users configuration:
            <userpath>/
            <userpath>/plugins/
 
        The plugins from 3rd party packages:
            $KICAD_3RD_PARTY/plugins/
    """
    import os
    import sys
    import traceback
    import pcbnew
 
    if sys.version_info >= (3,3,0):
        import importlib
        importlib.invalidate_caches()
 
    """
    bundlepath and userpath are strings utf-8 encoded (compatible "C" strings).
    So convert these utf8 encoding to unicode strings to avoid any encoding issue.
    """
    try:
        bundlepath = bundlepath.decode( 'UTF-8' )
        userpath = userpath.decode( 'UTF-8' )
        thirdpartypath = thirdpartypath.decode( 'UTF-8' )
    except AttributeError:
        pass
 
    config_path = pcbnew.SETTINGS_MANAGER.GetUserSettingsPath()
    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'):
        if bundlepath:
            bundlepath = bundlepath.replace("/","\\")
        if thirdpartypath:
            thirdpartypath = thirdpartypath.replace("/","\\")
 
    if bundlepath:
        plugin_directories.append(bundlepath)
        plugin_directories.append(os.path.join(bundlepath, 'plugins'))
 
    if config_path:
        plugin_directories.append(os.path.join(config_path, 'scripting'))
        plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))
 
    if userpath:
        plugin_directories.append(userpath)
        plugin_directories.append(os.path.join(userpath, 'plugins'))
 
    if thirdpartypath:
        plugin_directories.append(thirdpartypath)
 
    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
 
        if plugins_dir not in sys.path:
            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.dark_icon_file_name = ""
        self.show_toolbar_button = False
        self.defaults()
 
    def defaults( self ):
        self.name = "Undefined Action plugin"
        self.category = "Undefined"
        self.description = ""
 
    def GetClassName(self):
        return type(self).__name__
 
    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, dark ):
        if dark and self.dark_icon_file_name:
            return self.dark_icon_file_name
        else:
            return self.icon_file_name
 
    def Run(self):
        return
 
 
 
def BOX2ISafe(*args):
    r"""
    BOX2ISafe(BOX2D const & aInput) -> BOX2I
    BOX2ISafe(VECTOR2D const & aPos, VECTOR2D const & aSize) -> BOX2I
    """
    return _pcbnew.BOX2ISafe(*args)
 
def KiROUND(*args):
    r"""
    KiROUND(VECTOR2D const & vec) -> VECTOR2I
    KiROUND(BOX2D const & aBoxD) -> BOX2I
    """
    return _pcbnew.KiROUND(*args)
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, int x, int y) -> VECTOR2I
        __init__(VECTOR2I self, VECTOR2I aVec) -> VECTOR2I
        """
        _pcbnew.VECTOR2I_swiginit(self, _pcbnew.new_VECTOR2I(*args))
 
    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 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 Distance(self, aVector):
        r"""Distance(VECTOR2I self, VECTOR2L aVector) -> double"""
        return _pcbnew.VECTOR2I_Distance(self, aVector)
 
    def SquaredDistance(self, aVector):
        r"""SquaredDistance(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_SquaredDistance(self, aVector)
 
    def __imul__(self, *args):
        r"""
        __imul__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __imul__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___imul__(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 __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 __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)
 
    def Set(self, x, y):
        r"""Set(VECTOR2I self, long x, long y)"""
        return _pcbnew.VECTOR2I_Set(self, x, y)
 
    def Get(self):
        r"""Get(VECTOR2I self) -> PyObject *"""
        return _pcbnew.VECTOR2I_Get(self)
 
    def __eq__(self,other):            return (self.xx==other.x and self.yy==other.y)
    def __ne__(self,other):            return not (self==other)
    def __str__(self):                 return str(self.Get())
    def __repr__(self):                return 'VECTOR2I'+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.xx = val
        elif index == 1:
            self.yy = val
        else:
            raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    def __add__(self, other):            return VECTOR2I(self.xx+other.x, self.yy+other.y)
    def __sub__(self, other):            return VECTOR2I(self.xx-other.x, self.yy-other.y)
 
 
    __swig_destroy__ = _pcbnew.delete_VECTOR2I
 
# Register VECTOR2I in _pcbnew:
_pcbnew.VECTOR2I_swigregister(VECTOR2I)
class VECTOR2L(object):
    r"""Proxy of C++ VECTOR2< long long > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ECOORD_MAX = _pcbnew.VECTOR2L_ECOORD_MAX
    
    ECOORD_MIN = _pcbnew.VECTOR2L_ECOORD_MIN
    
    x = property(_pcbnew.VECTOR2L_x_get, _pcbnew.VECTOR2L_x_set, doc=r"""x : long long""")
    y = property(_pcbnew.VECTOR2L_y_get, _pcbnew.VECTOR2L_y_set, doc=r"""y : long long""")
 
    def __init__(self, *args):
        r"""
        __init__(VECTOR2L self) -> VECTOR2L
        __init__(VECTOR2L self, long long x, long long y) -> VECTOR2L
        __init__(VECTOR2L self, VECTOR2L aVec) -> VECTOR2L
        """
        _pcbnew.VECTOR2L_swiginit(self, _pcbnew.new_VECTOR2L(*args))
 
    def EuclideanNorm(self):
        r"""EuclideanNorm(VECTOR2L self) -> long long"""
        return _pcbnew.VECTOR2L_EuclideanNorm(self)
 
    def SquaredEuclideanNorm(self):
        r"""SquaredEuclideanNorm(VECTOR2L self) -> VECTOR2< long long >::extended_type"""
        return _pcbnew.VECTOR2L_SquaredEuclideanNorm(self)
 
    def Perpendicular(self):
        r"""Perpendicular(VECTOR2L self) -> VECTOR2L"""
        return _pcbnew.VECTOR2L_Perpendicular(self)
 
    def Resize(self, aNewLength):
        r"""Resize(VECTOR2L self, long long aNewLength) -> VECTOR2L"""
        return _pcbnew.VECTOR2L_Resize(self, aNewLength)
 
    def Format(self):
        r"""Format(VECTOR2L self) -> string"""
        return _pcbnew.VECTOR2L_Format(self)
 
    def Cross(self, aVector):
        r"""Cross(VECTOR2L self, VECTOR2L aVector) -> VECTOR2< long long >::extended_type"""
        return _pcbnew.VECTOR2L_Cross(self, aVector)
 
    def Dot(self, aVector):
        r"""Dot(VECTOR2L self, VECTOR2L aVector) -> VECTOR2< long long >::extended_type"""
        return _pcbnew.VECTOR2L_Dot(self, aVector)
 
    def Distance(self, aVector):
        r"""Distance(VECTOR2L self, VECTOR2< VECTOR2< long long >::extended_type > const & aVector) -> double"""
        return _pcbnew.VECTOR2L_Distance(self, aVector)
 
    def SquaredDistance(self, aVector):
        r"""SquaredDistance(VECTOR2L self, VECTOR2L aVector) -> VECTOR2< long long >::extended_type"""
        return _pcbnew.VECTOR2L_SquaredDistance(self, aVector)
 
    def __imul__(self, *args):
        r"""
        __imul__(VECTOR2L self, VECTOR2L aVector) -> VECTOR2L
        __imul__(VECTOR2L self, long long const & aScalar) -> VECTOR2L
        """
        return _pcbnew.VECTOR2L___imul__(self, *args)
 
    def __iadd__(self, *args):
        r"""
        __iadd__(VECTOR2L self, VECTOR2L aVector) -> VECTOR2L
        __iadd__(VECTOR2L self, long long const & aScalar) -> VECTOR2L
        """
        return _pcbnew.VECTOR2L___iadd__(self, *args)
 
    def __isub__(self, *args):
        r"""
        __isub__(VECTOR2L self, VECTOR2L aVector) -> VECTOR2L
        __isub__(VECTOR2L self, long long const & aScalar) -> VECTOR2L
        """
        return _pcbnew.VECTOR2L___isub__(self, *args)
 
    def __neg__(self):
        r"""__neg__(VECTOR2L self) -> VECTOR2L"""
        return _pcbnew.VECTOR2L___neg__(self)
 
    def __truediv__(self, *args):
        return _pcbnew.VECTOR2L___truediv__(self, *args)
    __div__ = __truediv__
 
 
 
    def __eq__(self, aVector):
        r"""__eq__(VECTOR2L self, VECTOR2L aVector) -> bool"""
        return _pcbnew.VECTOR2L___eq__(self, aVector)
 
    def __ne__(self, aVector):
        r"""__ne__(VECTOR2L self, VECTOR2L aVector) -> bool"""
        return _pcbnew.VECTOR2L___ne__(self, aVector)
 
    def __lt__(self, aVector):
        r"""__lt__(VECTOR2L self, VECTOR2L aVector) -> bool"""
        return _pcbnew.VECTOR2L___lt__(self, aVector)
 
    def __le__(self, aVector):
        r"""__le__(VECTOR2L self, VECTOR2L aVector) -> bool"""
        return _pcbnew.VECTOR2L___le__(self, aVector)
 
    def __gt__(self, aVector):
        r"""__gt__(VECTOR2L self, VECTOR2L aVector) -> bool"""
        return _pcbnew.VECTOR2L___gt__(self, aVector)
 
    def __ge__(self, aVector):
        r"""__ge__(VECTOR2L self, VECTOR2L aVector) -> bool"""
        return _pcbnew.VECTOR2L___ge__(self, aVector)
 
    def Set(self, x, y):
        r"""Set(VECTOR2L self, long long x, long long y)"""
        return _pcbnew.VECTOR2L_Set(self, x, y)
 
    def Get(self):
        r"""Get(VECTOR2L self) -> PyObject *"""
        return _pcbnew.VECTOR2L_Get(self)
 
    def __eq__(self,other):            return (self.xx==other.x and self.yy==other.y)
    def __ne__(self,other):            return not (self==other)
    def __str__(self):                 return str(self.Get())
    def __repr__(self):                return 'VECTOR2L'+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.xx = val
        elif index == 1:
            self.yy = val
        else:
            raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    def __add__(self, other):            return VECTOR2L(self.xx+other.x, self.yy+other.y)
    def __sub__(self, other):            return VECTOR2L(self.xx-other.x, self.yy-other.y)
 
 
    __swig_destroy__ = _pcbnew.delete_VECTOR2L
 
# Register VECTOR2L in _pcbnew:
_pcbnew.VECTOR2L_swigregister(VECTOR2L)
class VECTOR2I_EXTENDED_TYPE(object):
    r"""Proxy of C++ VECTOR2_TRAITS< int > 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__(VECTOR2I_EXTENDED_TYPE self) -> VECTOR2I_EXTENDED_TYPE"""
        _pcbnew.VECTOR2I_EXTENDED_TYPE_swiginit(self, _pcbnew.new_VECTOR2I_EXTENDED_TYPE())
    __swig_destroy__ = _pcbnew.delete_VECTOR2I_EXTENDED_TYPE
 
# Register VECTOR2I_EXTENDED_TYPE in _pcbnew:
_pcbnew.VECTOR2I_EXTENDED_TYPE_swigregister(VECTOR2I_EXTENDED_TYPE)
class VECTOR3D(object):
    r"""Proxy of C++ VECTOR3< double > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ECOORD_MAX = _pcbnew.VECTOR3D_ECOORD_MAX
    
    ECOORD_MIN = _pcbnew.VECTOR3D_ECOORD_MIN
    
    x = property(_pcbnew.VECTOR3D_x_get, _pcbnew.VECTOR3D_x_set, doc=r"""x : double""")
    y = property(_pcbnew.VECTOR3D_y_get, _pcbnew.VECTOR3D_y_set, doc=r"""y : double""")
    z = property(_pcbnew.VECTOR3D_z_get, _pcbnew.VECTOR3D_z_set, doc=r"""z : double""")
 
    def __init__(self, *args):
        r"""
        __init__(VECTOR3D self) -> VECTOR3D
        __init__(VECTOR3D self, double x, double y, double z) -> VECTOR3D
        """
        _pcbnew.VECTOR3D_swiginit(self, _pcbnew.new_VECTOR3D(*args))
 
    def Cross(self, aVector):
        r"""Cross(VECTOR3D self, VECTOR3D aVector) -> VECTOR3D"""
        return _pcbnew.VECTOR3D_Cross(self, aVector)
 
    def Dot(self, aVector):
        r"""Dot(VECTOR3D self, VECTOR3D aVector) -> VECTOR3< double >::extended_type"""
        return _pcbnew.VECTOR3D_Dot(self, aVector)
 
    def EuclideanNorm(self):
        r"""EuclideanNorm(VECTOR3D self) -> double"""
        return _pcbnew.VECTOR3D_EuclideanNorm(self)
 
    def Normalize(self):
        r"""Normalize(VECTOR3D self) -> VECTOR3D"""
        return _pcbnew.VECTOR3D_Normalize(self)
 
    def SetAll(self, val):
        r"""SetAll(VECTOR3D self, double val) -> VECTOR3D"""
        return _pcbnew.VECTOR3D_SetAll(self, val)
 
    def __eq__(self, aVector):
        r"""__eq__(VECTOR3D self, VECTOR3D aVector) -> bool"""
        return _pcbnew.VECTOR3D___eq__(self, aVector)
 
    def __ne__(self, aVector):
        r"""__ne__(VECTOR3D self, VECTOR3D aVector) -> bool"""
        return _pcbnew.VECTOR3D___ne__(self, aVector)
 
    def __imul__(self, val):
        r"""__imul__(VECTOR3D self, double val) -> VECTOR3D"""
        return _pcbnew.VECTOR3D___imul__(self, val)
 
    def __itruediv__(self, *args):
        return _pcbnew.VECTOR3D___itruediv__(self, *args)
    __idiv__ = __itruediv__
 
 
 
    def Set(self, x, y, z):
        r"""Set(VECTOR3D self, double x, double y, double z)"""
        return _pcbnew.VECTOR3D_Set(self, x, y, z)
 
    def Get(self):
        r"""Get(VECTOR3D self) -> PyObject *"""
        return _pcbnew.VECTOR3D_Get(self)
 
    def __eq__(self,other):            return (self.xx==other.x and self.yy==other.y and self.zz==other.z)
    def __ne__(self,other):            return not (self==other)
    def __str__(self):                 return str(self.Get())
    def __repr__(self):                return 'VECTOR3D'+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.xx = val
        elif index == 1:
            self.yy = val
        elif index == 2:
            self.zz = val
        else:
            raise IndexError
    def __nonzero__(self):               return self.Get() != (0, 0, 0)
 
 
    __swig_destroy__ = _pcbnew.delete_VECTOR3D
 
# Register VECTOR3D in _pcbnew:
_pcbnew.VECTOR3D_swigregister(VECTOR3D)
class BOX2I(object):
    r"""Proxy of C++ BOX2< VECTOR2I > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    @staticmethod
    def ByCorners(aCorner1, aCorner2):
        r"""ByCorners(VECTOR2I aCorner1, VECTOR2I aCorner2) -> BOX2I"""
        return _pcbnew.BOX2I_ByCorners(aCorner1, aCorner2)
 
    @staticmethod
    def ByCenter(aCenter, aSize):
        r"""ByCenter(VECTOR2I aCenter, VECTOR2L aSize) -> BOX2I"""
        return _pcbnew.BOX2I_ByCenter(aCenter, aSize)
 
    def SetMaximum(self):
        r"""SetMaximum(BOX2I self)"""
        return _pcbnew.BOX2I_SetMaximum(self)
 
    def Centre(self):
        r"""Centre(BOX2I self) -> VECTOR2I"""
        return _pcbnew.BOX2I_Centre(self)
 
    def Move(self, aMoveVector):
        r"""Move(BOX2I self, VECTOR2I aMoveVector)"""
        return _pcbnew.BOX2I_Move(self, aMoveVector)
 
    def Normalize(self):
        r"""Normalize(BOX2I self) -> BOX2I"""
        return _pcbnew.BOX2I_Normalize(self)
 
    def Contains(self, *args):
        r"""
        Contains(BOX2I self, VECTOR2I aPoint) -> bool
        Contains(BOX2I self, BOX2< VECTOR2< int > >::coord_type x, BOX2< VECTOR2< int > >::coord_type y) -> bool
        Contains(BOX2I self, BOX2I aRect) -> bool
        """
        return _pcbnew.BOX2I_Contains(self, *args)
 
    def GetSize(self):
        r"""GetSize(BOX2I self) -> VECTOR2L"""
        return _pcbnew.BOX2I_GetSize(self)
 
    def GetX(self):
        r"""GetX(BOX2I self) -> BOX2< VECTOR2< int > >::coord_type"""
        return _pcbnew.BOX2I_GetX(self)
 
    def GetY(self):
        r"""GetY(BOX2I self) -> BOX2< VECTOR2< int > >::coord_type"""
        return _pcbnew.BOX2I_GetY(self)
 
    def GetOrigin(self):
        r"""GetOrigin(BOX2I self) -> VECTOR2I"""
        return _pcbnew.BOX2I_GetOrigin(self)
 
    def GetPosition(self):
        r"""GetPosition(BOX2I self) -> VECTOR2I"""
        return _pcbnew.BOX2I_GetPosition(self)
 
    def GetEnd(self):
        r"""GetEnd(BOX2I self) -> VECTOR2I"""
        return _pcbnew.BOX2I_GetEnd(self)
 
    def GetWidth(self):
        r"""GetWidth(BOX2I self) -> BOX2< VECTOR2< int > >::size_type"""
        return _pcbnew.BOX2I_GetWidth(self)
 
    def GetHeight(self):
        r"""GetHeight(BOX2I self) -> BOX2< VECTOR2< int > >::size_type"""
        return _pcbnew.BOX2I_GetHeight(self)
 
    def GetRight(self):
        r"""GetRight(BOX2I self) -> BOX2< VECTOR2< int > >::coord_type"""
        return _pcbnew.BOX2I_GetRight(self)
 
    def GetBottom(self):
        r"""GetBottom(BOX2I self) -> BOX2< VECTOR2< int > >::coord_type"""
        return _pcbnew.BOX2I_GetBottom(self)
 
    def GetLeft(self):
        r"""GetLeft(BOX2I self) -> BOX2< VECTOR2< int > >::coord_type"""
        return _pcbnew.BOX2I_GetLeft(self)
 
    def GetTop(self):
        r"""GetTop(BOX2I self) -> BOX2< VECTOR2< int > >::coord_type"""
        return _pcbnew.BOX2I_GetTop(self)
 
    def GetCenter(self):
        r"""GetCenter(BOX2I self) -> VECTOR2I"""
        return _pcbnew.BOX2I_GetCenter(self)
 
    def GetSizeMax(self):
        r"""GetSizeMax(BOX2I self) -> int"""
        return _pcbnew.BOX2I_GetSizeMax(self)
 
    def SetOrigin(self, *args):
        r"""
        SetOrigin(BOX2I self, VECTOR2I pos)
        SetOrigin(BOX2I self, BOX2< VECTOR2< int > >::coord_type x, BOX2< VECTOR2< int > >::coord_type y)
        """
        return _pcbnew.BOX2I_SetOrigin(self, *args)
 
    def SetSize(self, *args):
        r"""
        SetSize(BOX2I self, VECTOR2L size)
        SetSize(BOX2I self, BOX2< VECTOR2< int > >::size_type w, BOX2< VECTOR2< int > >::size_type h)
        """
        return _pcbnew.BOX2I_SetSize(self, *args)
 
    def Offset(self, *args):
        r"""
        Offset(BOX2I self, BOX2< VECTOR2< int > >::coord_type dx, BOX2< VECTOR2< int > >::coord_type dy)
        Offset(BOX2I self, VECTOR2I offset)
        """
        return _pcbnew.BOX2I_Offset(self, *args)
 
    def GetWithOffset(self, aMoveVector):
        r"""GetWithOffset(BOX2I self, VECTOR2I aMoveVector) -> BOX2I"""
        return _pcbnew.BOX2I_GetWithOffset(self, aMoveVector)
 
    def SetX(self, val):
        r"""SetX(BOX2I self, BOX2< VECTOR2< int > >::coord_type val)"""
        return _pcbnew.BOX2I_SetX(self, val)
 
    def SetY(self, val):
        r"""SetY(BOX2I self, BOX2< VECTOR2< int > >::coord_type val)"""
        return _pcbnew.BOX2I_SetY(self, val)
 
    def SetWidth(self, val):
        r"""SetWidth(BOX2I self, BOX2< VECTOR2< int > >::size_type val)"""
        return _pcbnew.BOX2I_SetWidth(self, val)
 
    def SetHeight(self, val):
        r"""SetHeight(BOX2I self, BOX2< VECTOR2< int > >::size_type val)"""
        return _pcbnew.BOX2I_SetHeight(self, val)
 
    def SetEnd(self, *args):
        r"""
        SetEnd(BOX2I self, BOX2< VECTOR2< int > >::coord_type x, BOX2< VECTOR2< int > >::coord_type y)
        SetEnd(BOX2I self, VECTOR2I pos)
        """
        return _pcbnew.BOX2I_SetEnd(self, *args)
 
    def Intersect(self, aRect):
        r"""Intersect(BOX2I self, BOX2I aRect) -> BOX2I"""
        return _pcbnew.BOX2I_Intersect(self, aRect)
 
    def Intersects(self, *args):
        r"""
        Intersects(BOX2I self, BOX2I aRect) -> bool
        Intersects(BOX2I self, VECTOR2I aPoint1, VECTOR2I aPoint2) -> bool
        Intersects(BOX2I self, BOX2I aRect, EDA_ANGLE aRotation) -> bool
        """
        return _pcbnew.BOX2I_Intersects(self, *args)
 
    def IntersectsCircle(self, aCenter, aRadius):
        r"""IntersectsCircle(BOX2I self, VECTOR2I aCenter, int const aRadius) -> bool"""
        return _pcbnew.BOX2I_IntersectsCircle(self, aCenter, aRadius)
 
    def IntersectsCircleEdge(self, aCenter, aRadius, aWidth):
        r"""IntersectsCircleEdge(BOX2I self, VECTOR2I aCenter, int const aRadius, int const aWidth) -> bool"""
        return _pcbnew.BOX2I_IntersectsCircleEdge(self, aCenter, aRadius, aWidth)
 
    def Format(self):
        r"""Format(BOX2I self) -> string"""
        return _pcbnew.BOX2I_Format(self)
 
    def Inflate(self, *args):
        r"""
        Inflate(BOX2I self, BOX2< VECTOR2< int > >::coord_type dx, BOX2< VECTOR2< int > >::coord_type dy) -> BOX2I
        Inflate(BOX2I self, BOX2< VECTOR2< int > >::coord_type aDelta) -> BOX2I
        """
        return _pcbnew.BOX2I_Inflate(self, *args)
 
    def GetInflated(self, *args):
        r"""
        GetInflated(BOX2I self, BOX2< VECTOR2< int > >::coord_type aDx, BOX2< VECTOR2< int > >::coord_type aDy) -> BOX2I
        GetInflated(BOX2I self, BOX2< VECTOR2< int > >::coord_type aDelta) -> BOX2I
        """
        return _pcbnew.BOX2I_GetInflated(self, *args)
 
    def Merge(self, *args):
        r"""
        Merge(BOX2I self, BOX2I aRect) -> BOX2I
        Merge(BOX2I self, VECTOR2I aPoint) -> BOX2I
        """
        return _pcbnew.BOX2I_Merge(self, *args)
 
    def GetBoundingBoxRotated(self, aRotCenter, aAngle):
        r"""GetBoundingBoxRotated(BOX2I self, VECTOR2I aRotCenter, EDA_ANGLE aAngle) -> BOX2I"""
        return _pcbnew.BOX2I_GetBoundingBoxRotated(self, aRotCenter, aAngle)
 
    def GetArea(self):
        r"""GetArea(BOX2I self) -> BOX2< VECTOR2< int > >::ecoord_type"""
        return _pcbnew.BOX2I_GetArea(self)
 
    def Diagonal(self):
        r"""Diagonal(BOX2I self) -> BOX2< VECTOR2< int > >::ecoord_type"""
        return _pcbnew.BOX2I_Diagonal(self)
 
    def SquaredDiagonal(self):
        r"""SquaredDiagonal(BOX2I self) -> BOX2< VECTOR2< int > >::ecoord_type"""
        return _pcbnew.BOX2I_SquaredDiagonal(self)
 
    def SquaredDistance(self, *args):
        r"""
        SquaredDistance(BOX2I self, VECTOR2I aP) -> BOX2< VECTOR2< int > >::ecoord_type
        SquaredDistance(BOX2I self, BOX2I aBox) -> BOX2< VECTOR2< int > >::ecoord_type
        """
        return _pcbnew.BOX2I_SquaredDistance(self, *args)
 
    def Distance(self, *args):
        r"""
        Distance(BOX2I self, VECTOR2I aP) -> BOX2< VECTOR2< int > >::ecoord_type
        Distance(BOX2I self, BOX2I aBox) -> BOX2< VECTOR2< int > >::ecoord_type
        """
        return _pcbnew.BOX2I_Distance(self, *args)
 
    def NearestPoint(self, aPoint):
        r"""NearestPoint(BOX2I self, VECTOR2I aPoint) -> VECTOR2I"""
        return _pcbnew.BOX2I_NearestPoint(self, aPoint)
 
    def FarthestPointTo(self, aPoint):
        r"""FarthestPointTo(BOX2I self, VECTOR2I aPoint) -> VECTOR2I"""
        return _pcbnew.BOX2I_FarthestPointTo(self, aPoint)
 
    def __eq__(self, aOther):
        r"""__eq__(BOX2I self, BOX2I aOther) -> bool"""
        return _pcbnew.BOX2I___eq__(self, aOther)
 
    def __ne__(self, aOther):
        r"""__ne__(BOX2I self, BOX2I aOther) -> bool"""
        return _pcbnew.BOX2I___ne__(self, aOther)
 
    def IsValid(self):
        r"""IsValid(BOX2I self) -> bool"""
        return _pcbnew.BOX2I_IsValid(self)
 
    def __init__(self, *args):
        r"""
        __init__(BOX2I self) -> BOX2I
        __init__(BOX2I self, VECTOR2I aPos, VECTOR2L aSize=BOX2< VECTOR2I >::SizeVec(0, 0)) -> BOX2I
        __init__(BOX2I self, VECTOR2I aPos, VECTOR2I aSize) -> BOX2I
        """
        _pcbnew.BOX2I_swiginit(self, _pcbnew.new_BOX2I(*args))
    __swig_destroy__ = _pcbnew.delete_BOX2I
 
# Register BOX2I in _pcbnew:
_pcbnew.BOX2I_swigregister(BOX2I)
class VECTOR_VECTOR2I(object):
    r"""Proxy of C++ std::vector< VECTOR2I > 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(VECTOR_VECTOR2I self) -> SwigPyIterator"""
        return _pcbnew.VECTOR_VECTOR2I_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(VECTOR_VECTOR2I self) -> bool"""
        return _pcbnew.VECTOR_VECTOR2I___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(VECTOR_VECTOR2I self) -> bool"""
        return _pcbnew.VECTOR_VECTOR2I___bool__(self)
 
    def __len__(self):
        r"""__len__(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
        return _pcbnew.VECTOR_VECTOR2I___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j) -> VECTOR_VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j)
        __setslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j, VECTOR_VECTOR2I v)
        """
        return _pcbnew.VECTOR_VECTOR2I___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j)"""
        return _pcbnew.VECTOR_VECTOR2I___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i)
        __delitem__(VECTOR_VECTOR2I self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.VECTOR_VECTOR2I___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(VECTOR_VECTOR2I self, SWIGPY_SLICEOBJECT * slice) -> VECTOR_VECTOR2I
        __getitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i) -> VECTOR2I
        """
        return _pcbnew.VECTOR_VECTOR2I___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(VECTOR_VECTOR2I self, SWIGPY_SLICEOBJECT * slice, VECTOR_VECTOR2I v)
        __setitem__(VECTOR_VECTOR2I self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, VECTOR2I x)
        """
        return _pcbnew.VECTOR_VECTOR2I___setitem__(self, *args)
 
    def pop(self):
        r"""pop(VECTOR_VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I_pop(self)
 
    def append(self, x):
        r"""append(VECTOR_VECTOR2I self, VECTOR2I x)"""
        return _pcbnew.VECTOR_VECTOR2I_append(self, x)
 
    def empty(self):
        r"""empty(VECTOR_VECTOR2I self) -> bool"""
        return _pcbnew.VECTOR_VECTOR2I_empty(self)
 
    def size(self):
        r"""size(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
        return _pcbnew.VECTOR_VECTOR2I_size(self)
 
    def swap(self, v):
        r"""swap(VECTOR_VECTOR2I self, VECTOR_VECTOR2I v)"""
        return _pcbnew.VECTOR_VECTOR2I_swap(self, v)
 
    def begin(self):
        r"""begin(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::iterator"""
        return _pcbnew.VECTOR_VECTOR2I_begin(self)
 
    def end(self):
        r"""end(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::iterator"""
        return _pcbnew.VECTOR_VECTOR2I_end(self)
 
    def rbegin(self):
        r"""rbegin(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::reverse_iterator"""
        return _pcbnew.VECTOR_VECTOR2I_rbegin(self)
 
    def rend(self):
        r"""rend(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::reverse_iterator"""
        return _pcbnew.VECTOR_VECTOR2I_rend(self)
 
    def clear(self):
        r"""clear(VECTOR_VECTOR2I self)"""
        return _pcbnew.VECTOR_VECTOR2I_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::allocator_type"""
        return _pcbnew.VECTOR_VECTOR2I_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(VECTOR_VECTOR2I self)"""
        return _pcbnew.VECTOR_VECTOR2I_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator pos) -> std::vector< VECTOR2< int > >::iterator
        erase(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator first, std::vector< VECTOR2< int > >::iterator last) -> std::vector< VECTOR2< int > >::iterator
        """
        return _pcbnew.VECTOR_VECTOR2I_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(VECTOR_VECTOR2I self) -> VECTOR_VECTOR2I
        __init__(VECTOR_VECTOR2I self, VECTOR_VECTOR2I other) -> VECTOR_VECTOR2I
        __init__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type size) -> VECTOR_VECTOR2I
        __init__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type size, VECTOR2I value) -> VECTOR_VECTOR2I
        """
        _pcbnew.VECTOR_VECTOR2I_swiginit(self, _pcbnew.new_VECTOR_VECTOR2I(*args))
 
    def push_back(self, x):
        r"""push_back(VECTOR_VECTOR2I self, VECTOR2I x)"""
        return _pcbnew.VECTOR_VECTOR2I_push_back(self, x)
 
    def front(self):
        r"""front(VECTOR_VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I_front(self)
 
    def back(self):
        r"""back(VECTOR_VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I_back(self)
 
    def assign(self, n, x):
        r"""assign(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type n, VECTOR2I x)"""
        return _pcbnew.VECTOR_VECTOR2I_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type new_size)
        resize(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type new_size, VECTOR2I x)
        """
        return _pcbnew.VECTOR_VECTOR2I_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator pos, VECTOR2I x) -> std::vector< VECTOR2< int > >::iterator
        insert(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator pos, std::vector< VECTOR2< int > >::size_type n, VECTOR2I x)
        """
        return _pcbnew.VECTOR_VECTOR2I_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type n)"""
        return _pcbnew.VECTOR_VECTOR2I_reserve(self, n)
 
    def capacity(self):
        r"""capacity(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
        return _pcbnew.VECTOR_VECTOR2I_capacity(self)
    __swig_destroy__ = _pcbnew.delete_VECTOR_VECTOR2I
 
# Register VECTOR_VECTOR2I in _pcbnew:
_pcbnew.VECTOR_VECTOR2I_swigregister(VECTOR_VECTOR2I)
CORNER_STRATEGY_ALLOW_ACUTE_CORNERS = _pcbnew.CORNER_STRATEGY_ALLOW_ACUTE_CORNERS
 
CORNER_STRATEGY_CHAMFER_ACUTE_CORNERS = _pcbnew.CORNER_STRATEGY_CHAMFER_ACUTE_CORNERS
 
CORNER_STRATEGY_ROUND_ACUTE_CORNERS = _pcbnew.CORNER_STRATEGY_ROUND_ACUTE_CORNERS
 
CORNER_STRATEGY_CHAMFER_ALL_CORNERS = _pcbnew.CORNER_STRATEGY_CHAMFER_ALL_CORNERS
 
CORNER_STRATEGY_ROUND_ALL_CORNERS = _pcbnew.CORNER_STRATEGY_ROUND_ALL_CORNERS
 
class SEG(object):
    r"""Proxy of C++ SEG class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    A = property(_pcbnew.SEG_A_get, _pcbnew.SEG_A_set, doc=r"""A : VECTOR2I""")
    B = property(_pcbnew.SEG_B_get, _pcbnew.SEG_B_set, doc=r"""B : VECTOR2I""")
 
    def __init__(self, *args):
        r"""
        __init__(SEG self) -> SEG
        __init__(SEG self, int aX1, int aY1, int aX2, int aY2) -> SEG
        __init__(SEG self, VECTOR2I aA, VECTOR2I aB) -> SEG
        __init__(SEG self, VECTOR2I aA, VECTOR2I aB, int aIndex) -> SEG
        __init__(SEG self, SEG aSeg) -> SEG
        """
        _pcbnew.SEG_swiginit(self, _pcbnew.new_SEG(*args))
 
    def __eq__(self, aSeg):
        r"""__eq__(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG___eq__(self, aSeg)
 
    def __ne__(self, aSeg):
        r"""__ne__(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG___ne__(self, aSeg)
 
    @staticmethod
    def Square(a):
        r"""Square(int a) -> SEG::ecoord"""
        return _pcbnew.SEG_Square(a)
 
    def LineProject(self, aP):
        r"""LineProject(SEG self, VECTOR2I aP) -> VECTOR2I"""
        return _pcbnew.SEG_LineProject(self, aP)
 
    def Side(self, aP):
        r"""Side(SEG self, VECTOR2I aP) -> int"""
        return _pcbnew.SEG_Side(self, aP)
 
    def LineDistance(self, aP, aDetermineSide=False):
        r"""LineDistance(SEG self, VECTOR2I aP, bool aDetermineSide=False) -> int"""
        return _pcbnew.SEG_LineDistance(self, aP, aDetermineSide)
 
    def Angle(self, aOther):
        r"""Angle(SEG self, SEG aOther) -> EDA_ANGLE"""
        return _pcbnew.SEG_Angle(self, aOther)
 
    def NearestPoint(self, *args):
        r"""
        NearestPoint(SEG self, VECTOR2I aP) -> VECTOR2I
        NearestPoint(SEG self, SEG aSeg) -> VECTOR2I
        """
        return _pcbnew.SEG_NearestPoint(self, *args)
 
    def NearestPoints(self, aSeg, aPtA, aPtB, aDistSq):
        r"""NearestPoints(SEG self, SEG aSeg, VECTOR2I aPtA, VECTOR2I aPtB, int64_t & aDistSq) -> bool"""
        return _pcbnew.SEG_NearestPoints(self, aSeg, aPtA, aPtB, aDistSq)
 
    def ReflectPoint(self, aP):
        r"""ReflectPoint(SEG self, VECTOR2I aP) -> VECTOR2I"""
        return _pcbnew.SEG_ReflectPoint(self, aP)
 
    def Intersect(self, aSeg, aIgnoreEndpoints=False, aLines=False):
        r"""Intersect(SEG self, SEG aSeg, bool aIgnoreEndpoints=False, bool aLines=False) -> OPT_VECTOR2I"""
        return _pcbnew.SEG_Intersect(self, aSeg, aIgnoreEndpoints, aLines)
 
    def Intersects(self, aSeg):
        r"""Intersects(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG_Intersects(self, aSeg)
 
    def IntersectLines(self, aSeg):
        r"""IntersectLines(SEG self, SEG aSeg) -> OPT_VECTOR2I"""
        return _pcbnew.SEG_IntersectLines(self, aSeg)
 
    def PerpendicularSeg(self, aP):
        r"""PerpendicularSeg(SEG self, VECTOR2I aP) -> SEG"""
        return _pcbnew.SEG_PerpendicularSeg(self, aP)
 
    def ParallelSeg(self, aP):
        r"""ParallelSeg(SEG self, VECTOR2I aP) -> SEG"""
        return _pcbnew.SEG_ParallelSeg(self, aP)
 
    def Collide(self, aSeg, aClearance, aActual=None):
        r"""Collide(SEG self, SEG aSeg, int aClearance, int * aActual=None) -> bool"""
        return _pcbnew.SEG_Collide(self, aSeg, aClearance, aActual)
 
    def SquaredDistance(self, *args):
        r"""
        SquaredDistance(SEG self, SEG aSeg) -> SEG::ecoord
        SquaredDistance(SEG self, VECTOR2I aP) -> SEG::ecoord
        """
        return _pcbnew.SEG_SquaredDistance(self, *args)
 
    def Distance(self, *args):
        r"""
        Distance(SEG self, SEG aSeg) -> int
        Distance(SEG self, VECTOR2I aP) -> int
        """
        return _pcbnew.SEG_Distance(self, *args)
 
    def CanonicalCoefs(self, qA, qB, qC):
        r"""CanonicalCoefs(SEG self, SEG::ecoord & qA, SEG::ecoord & qB, SEG::ecoord & qC)"""
        return _pcbnew.SEG_CanonicalCoefs(self, qA, qB, qC)
 
    def Collinear(self, aSeg):
        r"""Collinear(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG_Collinear(self, aSeg)
 
    def ApproxCollinear(self, aSeg, aDistanceThreshold=1):
        r"""ApproxCollinear(SEG self, SEG aSeg, int aDistanceThreshold=1) -> bool"""
        return _pcbnew.SEG_ApproxCollinear(self, aSeg, aDistanceThreshold)
 
    def ApproxParallel(self, aSeg, aDistanceThreshold=1):
        r"""ApproxParallel(SEG self, SEG aSeg, int aDistanceThreshold=1) -> bool"""
        return _pcbnew.SEG_ApproxParallel(self, aSeg, aDistanceThreshold)
 
    def ApproxPerpendicular(self, aSeg):
        r"""ApproxPerpendicular(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG_ApproxPerpendicular(self, aSeg)
 
    def Overlaps(self, aSeg):
        r"""Overlaps(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG_Overlaps(self, aSeg)
 
    def Length(self):
        r"""Length(SEG self) -> int"""
        return _pcbnew.SEG_Length(self)
 
    def SquaredLength(self):
        r"""SquaredLength(SEG self) -> SEG::ecoord"""
        return _pcbnew.SEG_SquaredLength(self)
 
    def TCoef(self, aP):
        r"""TCoef(SEG self, VECTOR2I aP) -> SEG::ecoord"""
        return _pcbnew.SEG_TCoef(self, aP)
 
    def Index(self):
        r"""Index(SEG self) -> int"""
        return _pcbnew.SEG_Index(self)
 
    def Contains(self, *args):
        r"""
        Contains(SEG self, SEG aSeg) -> bool
        Contains(SEG self, VECTOR2I aP) -> bool
        """
        return _pcbnew.SEG_Contains(self, *args)
 
    def Reverse(self):
        r"""Reverse(SEG self)"""
        return _pcbnew.SEG_Reverse(self)
 
    def Reversed(self):
        r"""Reversed(SEG self) -> SEG"""
        return _pcbnew.SEG_Reversed(self)
 
    def Center(self):
        r"""Center(SEG self) -> VECTOR2I"""
        return _pcbnew.SEG_Center(self)
 
    def __lt__(self, aSeg):
        r"""__lt__(SEG self, SEG aSeg) -> bool"""
        return _pcbnew.SEG___lt__(self, aSeg)
    __swig_destroy__ = _pcbnew.delete_SEG
 
# Register SEG in _pcbnew:
_pcbnew.SEG_swigregister(SEG)
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
 
SH_NULL = _pcbnew.SH_NULL
 
SH_POLY_SET_TRIANGLE = _pcbnew.SH_POLY_SET_TRIANGLE
 
 
def SHAPE_TYPE_asString(a):
    r"""SHAPE_TYPE_asString(SHAPE_TYPE a) -> wxString"""
    return _pcbnew.SHAPE_TYPE_asString(a)
class SHAPE_BASE(object):
    r"""Proxy of C++ SHAPE_BASE 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, aType):
        r"""__init__(SHAPE_BASE self, SHAPE_TYPE aType) -> SHAPE_BASE"""
        _pcbnew.SHAPE_BASE_swiginit(self, _pcbnew.new_SHAPE_BASE(aType))
    __swig_destroy__ = _pcbnew.delete_SHAPE_BASE
 
    def Type(self):
        r"""Type(SHAPE_BASE self) -> SHAPE_TYPE"""
        return _pcbnew.SHAPE_BASE_Type(self)
 
    def TypeName(self):
        r"""TypeName(SHAPE_BASE self) -> wxString"""
        return _pcbnew.SHAPE_BASE_TypeName(self)
 
    def HasIndexableSubshapes(self):
        r"""HasIndexableSubshapes(SHAPE_BASE self) -> bool"""
        return _pcbnew.SHAPE_BASE_HasIndexableSubshapes(self)
 
    def GetIndexableSubshapeCount(self):
        r"""GetIndexableSubshapeCount(SHAPE_BASE self) -> size_t"""
        return _pcbnew.SHAPE_BASE_GetIndexableSubshapeCount(self)
 
    def GetIndexableSubshapes(self, aSubshapes):
        r"""GetIndexableSubshapes(SHAPE_BASE self, std::vector< SHAPE const *,std::allocator< SHAPE const * > > & aSubshapes)"""
        return _pcbnew.SHAPE_BASE_GetIndexableSubshapes(self, aSubshapes)
 
# Register SHAPE_BASE in _pcbnew:
_pcbnew.SHAPE_BASE_swigregister(SHAPE_BASE)
class SHAPE(SHAPE_BASE):
    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
    MIN_PRECISION_IU = _pcbnew.SHAPE_MIN_PRECISION_IU
    
    __swig_destroy__ = _pcbnew.delete_SHAPE
 
    def Clone(self):
        r"""Clone(SHAPE self) -> SHAPE"""
        return _pcbnew.SHAPE_Clone(self)
 
    def GetClearance(self, aOther):
        r"""GetClearance(SHAPE self, SHAPE aOther) -> int"""
        return _pcbnew.SHAPE_GetClearance(self, aOther)
 
    def IsNull(self):
        r"""IsNull(SHAPE self) -> bool"""
        return _pcbnew.SHAPE_IsNull(self)
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE self, SHAPE aShape, int aClearance, VECTOR2I aMTV) -> bool
        Collide(SHAPE self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_Collide(self, *args)
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_BBox(self, aClearance)
 
    def Centre(self):
        r"""Centre(SHAPE self) -> VECTOR2I"""
        return _pcbnew.SHAPE_Centre(self)
 
    def Distance(self, aP):
        r"""Distance(SHAPE self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_Distance(self, aP)
 
    def SquaredDistance(self, aP, aOutlineOnly=False):
        r"""SquaredDistance(SHAPE self, VECTOR2I aP, bool aOutlineOnly=False) -> SEG::ecoord"""
        return _pcbnew.SHAPE_SquaredDistance(self, aP, aOutlineOnly)
 
    def PointInside(self, aPt, aAccuracy=0, aUseBBoxCache=False):
        r"""PointInside(SHAPE self, VECTOR2I aPt, int aAccuracy=0, bool aUseBBoxCache=False) -> bool"""
        return _pcbnew.SHAPE_PointInside(self, aPt, aAccuracy, aUseBBoxCache)
 
    def TransformToPolygon(self, aBuffer, aError, aErrorLoc):
        r"""TransformToPolygon(SHAPE self, SHAPE_POLY_SET aBuffer, int aError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.SHAPE_TransformToPolygon(self, aBuffer, aError, aErrorLoc)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_Rotate(self, *args)
 
    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, aCplusPlus=True):
        r"""Format(SHAPE self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_Format(self, aCplusPlus)
 
    def Cast(self):
        shape_type = SHAPE_TYPE_asString(self.Type())
 
        if shape_type == "SH_ARC":
            return Cast_to_SHAPE_ARC(self)
        elif shape_type == "SH_CIRCLE":
            return Cast_to_SHAPE_CIRCLE(self)
        elif shape_type == "SH_COMPOUND":
            return Cast_to_SHAPE_COMPOUND(self)
        elif shape_type == "SH_LINE_CHAIN":
            return Cast_to_SHAPE_LINE_CHAIN(self)
        elif shape_type == "SH_POLY_SET":
            return Cast_to_SHAPE_POLY_SET(self)
        elif shape_type == "SH_RECT":
            return Cast_to_SHAPE_RECT(self)
        elif shape_type == "SH_SEGMENT":
            return Cast_to_SHAPE_SEGMENT(self)
        elif shape_type == "SH_SIMPLE":
            return Cast_to_SHAPE_SIMPLE(self)
        else:
            raise TypeError("Unsupported shape class: %s" % shape_type)
 
 
# Register SHAPE in _pcbnew:
_pcbnew.SHAPE_swigregister(SHAPE)
class SHAPE_LINE_CHAIN_BASE(SHAPE):
    r"""Proxy of C++ SHAPE_LINE_CHAIN_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 - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pcbnew.delete_SHAPE_LINE_CHAIN_BASE
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_LINE_CHAIN_BASE self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_Collide(self, *args)
 
    def SquaredDistance(self, aP, aOutlineOnly=False):
        r"""SquaredDistance(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, bool aOutlineOnly=False) -> SEG::ecoord"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_SquaredDistance(self, aP, aOutlineOnly)
 
    def PointInside(self, aPt, aAccuracy=0, aUseBBoxCache=False):
        r"""PointInside(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aPt, int aAccuracy=0, bool aUseBBoxCache=False) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_PointInside(self, aPt, aAccuracy, aUseBBoxCache)
 
    def PointOnEdge(self, aP, aAccuracy=0):
        r"""PointOnEdge(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, int aAccuracy=0) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_PointOnEdge(self, aP, aAccuracy)
 
    def EdgeContainingPoint(self, aP, aAccuracy=0):
        r"""EdgeContainingPoint(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, int aAccuracy=0) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_EdgeContainingPoint(self, aP, aAccuracy)
 
    def GetPoint(self, aIndex):
        r"""GetPoint(SHAPE_LINE_CHAIN_BASE self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetPoint(self, aIndex)
 
    def GetSegment(self, aIndex):
        r"""GetSegment(SHAPE_LINE_CHAIN_BASE self, int aIndex) -> SEG"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetSegment(self, aIndex)
 
    def GetPointCount(self):
        r"""GetPointCount(SHAPE_LINE_CHAIN_BASE self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetPointCount(self)
 
    def GetSegmentCount(self):
        r"""GetSegmentCount(SHAPE_LINE_CHAIN_BASE self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetSegmentCount(self)
 
    def IsClosed(self):
        r"""IsClosed(SHAPE_LINE_CHAIN_BASE self) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_IsClosed(self)
 
    def GetCachedBBox(self):
        r"""GetCachedBBox(SHAPE_LINE_CHAIN_BASE self) -> BOX2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetCachedBBox(self)
 
# Register SHAPE_LINE_CHAIN_BASE in _pcbnew:
_pcbnew.SHAPE_LINE_CHAIN_BASE_swigregister(SHAPE_LINE_CHAIN_BASE)
class SHAPE_ARC(SHAPE):
    r"""Proxy of C++ SHAPE_ARC 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_ARC
 
    def ConstructFromStartEndAngle(self, aStart, aEnd, aAngle, aWidth=0):
        r"""ConstructFromStartEndAngle(SHAPE_ARC self, VECTOR2I aStart, VECTOR2I aEnd, EDA_ANGLE aAngle, double aWidth=0) -> SHAPE_ARC"""
        return _pcbnew.SHAPE_ARC_ConstructFromStartEndAngle(self, aStart, aEnd, aAngle, aWidth)
 
    def ConstructFromStartEndCenter(self, aStart, aEnd, aCenter, aClockwise=False, aWidth=0):
        r"""ConstructFromStartEndCenter(SHAPE_ARC self, VECTOR2I aStart, VECTOR2I aEnd, VECTOR2I aCenter, bool aClockwise=False, double aWidth=0) -> SHAPE_ARC"""
        return _pcbnew.SHAPE_ARC_ConstructFromStartEndCenter(self, aStart, aEnd, aCenter, aClockwise, aWidth)
 
    def GetP0(self):
        r"""GetP0(SHAPE_ARC self) -> VECTOR2I"""
        return _pcbnew.SHAPE_ARC_GetP0(self)
 
    def GetP1(self):
        r"""GetP1(SHAPE_ARC self) -> VECTOR2I"""
        return _pcbnew.SHAPE_ARC_GetP1(self)
 
    def GetArcMid(self):
        r"""GetArcMid(SHAPE_ARC self) -> VECTOR2I"""
        return _pcbnew.SHAPE_ARC_GetArcMid(self)
 
    def GetCenter(self):
        r"""GetCenter(SHAPE_ARC self) -> VECTOR2I"""
        return _pcbnew.SHAPE_ARC_GetCenter(self)
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_ARC self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_ARC_BBox(self, aClearance)
 
    def NearestPoint(self, aP):
        r"""NearestPoint(SHAPE_ARC self, VECTOR2I aP) -> VECTOR2I"""
        return _pcbnew.SHAPE_ARC_NearestPoint(self, aP)
 
    def NearestPoints(self, *args):
        r"""
        NearestPoints(SHAPE_ARC self, SHAPE_ARC aArc, VECTOR2I aPtA, VECTOR2I aPtB, int64_t & aDistSq) -> bool
        NearestPoints(SHAPE_ARC self, SHAPE_CIRCLE aCircle, VECTOR2I aPtA, VECTOR2I aPtB, int64_t & aDistSq) -> bool
        NearestPoints(SHAPE_ARC self, SEG aSeg, VECTOR2I aPtA, VECTOR2I aPtB, int64_t & aDistSq) -> bool
        NearestPoints(SHAPE_ARC self, SHAPE_RECT aRect, VECTOR2I aPtA, VECTOR2I aPtB, int64_t & aDistSq) -> bool
        """
        return _pcbnew.SHAPE_ARC_NearestPoints(self, *args)
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_ARC self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_ARC self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_ARC self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_ARC_Collide(self, *args)
 
    def IntersectLine(self, aSeg, aIpsBuffer):
        r"""IntersectLine(SHAPE_ARC self, SEG aSeg, VECTOR_VECTOR2I aIpsBuffer) -> int"""
        return _pcbnew.SHAPE_ARC_IntersectLine(self, aSeg, aIpsBuffer)
 
    def Intersect(self, *args):
        r"""
        Intersect(SHAPE_ARC self, CIRCLE const & aArc, VECTOR_VECTOR2I aIpsBuffer) -> int
        Intersect(SHAPE_ARC self, SHAPE_ARC aArc, VECTOR_VECTOR2I aIpsBuffer) -> int
        """
        return _pcbnew.SHAPE_ARC_Intersect(self, *args)
 
    def SetWidth(self, aWidth):
        r"""SetWidth(SHAPE_ARC self, int aWidth)"""
        return _pcbnew.SHAPE_ARC_SetWidth(self, aWidth)
 
    def GetWidth(self):
        r"""GetWidth(SHAPE_ARC self) -> int"""
        return _pcbnew.SHAPE_ARC_GetWidth(self)
 
    def IsEffectiveLine(self):
        r"""IsEffectiveLine(SHAPE_ARC self) -> bool"""
        return _pcbnew.SHAPE_ARC_IsEffectiveLine(self)
 
    def Mirror(self, *args):
        r"""
        Mirror(SHAPE_ARC self, VECTOR2I aRef, FLIP_DIRECTION aFlipDirection)
        Mirror(SHAPE_ARC self, SEG axis)
        """
        return _pcbnew.SHAPE_ARC_Mirror(self, *args)
 
    def Reverse(self):
        r"""Reverse(SHAPE_ARC self)"""
        return _pcbnew.SHAPE_ARC_Reverse(self)
 
    def Reversed(self):
        r"""Reversed(SHAPE_ARC self) -> SHAPE_ARC"""
        return _pcbnew.SHAPE_ARC_Reversed(self)
 
    def GetRadius(self):
        r"""GetRadius(SHAPE_ARC self) -> double"""
        return _pcbnew.SHAPE_ARC_GetRadius(self)
 
    def GetChord(self):
        r"""GetChord(SHAPE_ARC self) -> SEG"""
        return _pcbnew.SHAPE_ARC_GetChord(self)
 
    def GetCentralAngle(self):
        r"""GetCentralAngle(SHAPE_ARC self) -> EDA_ANGLE"""
        return _pcbnew.SHAPE_ARC_GetCentralAngle(self)
 
    def GetStartAngle(self):
        r"""GetStartAngle(SHAPE_ARC self) -> EDA_ANGLE"""
        return _pcbnew.SHAPE_ARC_GetStartAngle(self)
 
    def GetEndAngle(self):
        r"""GetEndAngle(SHAPE_ARC self) -> EDA_ANGLE"""
        return _pcbnew.SHAPE_ARC_GetEndAngle(self)
 
    def GetLength(self):
        r"""GetLength(SHAPE_ARC self) -> double"""
        return _pcbnew.SHAPE_ARC_GetLength(self)
 
    @staticmethod
    def DefaultAccuracyForPCB():
        r"""DefaultAccuracyForPCB() -> int"""
        return _pcbnew.SHAPE_ARC_DefaultAccuracyForPCB()
 
    def ConvertToPolyline(self, *args):
        r"""ConvertToPolyline(SHAPE_ARC self, int aMaxError=SHAPE_ARC::DefaultAccuracyForPCB(), int * aActualError=None) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_ARC_ConvertToPolyline(self, *args)
 
    def __eq__(self, aArc):
        r"""__eq__(SHAPE_ARC self, SHAPE_ARC aArc) -> bool"""
        return _pcbnew.SHAPE_ARC___eq__(self, aArc)
 
    def IsCCW(self):
        r"""IsCCW(SHAPE_ARC self) -> bool"""
        return _pcbnew.SHAPE_ARC_IsCCW(self)
 
    def IsClockwise(self):
        r"""IsClockwise(SHAPE_ARC self) -> bool"""
        return _pcbnew.SHAPE_ARC_IsClockwise(self)
 
# Register SHAPE_ARC in _pcbnew:
_pcbnew.SHAPE_ARC_swigregister(SHAPE_ARC)
class SHAPE_CIRCLE(SHAPE):
    r"""Proxy of C++ SHAPE_CIRCLE 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_CIRCLE self) -> SHAPE_CIRCLE
        __init__(SHAPE_CIRCLE self, VECTOR2I aCenter, int aRadius) -> SHAPE_CIRCLE
        __init__(SHAPE_CIRCLE self, CIRCLE const & aCircle) -> SHAPE_CIRCLE
        __init__(SHAPE_CIRCLE self, SHAPE_CIRCLE aOther) -> SHAPE_CIRCLE
        """
        _pcbnew.SHAPE_CIRCLE_swiginit(self, _pcbnew.new_SHAPE_CIRCLE(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_CIRCLE
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_CIRCLE self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_CIRCLE_BBox(self, aClearance)
 
    def Collide(self, aSeg, aClearance=0, aActual=None, aLocation=None):
        r"""Collide(SHAPE_CIRCLE self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool"""
        return _pcbnew.SHAPE_CIRCLE_Collide(self, aSeg, aClearance, aActual, aLocation)
 
    def SetRadius(self, aRadius):
        r"""SetRadius(SHAPE_CIRCLE self, int aRadius)"""
        return _pcbnew.SHAPE_CIRCLE_SetRadius(self, aRadius)
 
    def SetCenter(self, aCenter):
        r"""SetCenter(SHAPE_CIRCLE self, VECTOR2I aCenter)"""
        return _pcbnew.SHAPE_CIRCLE_SetCenter(self, aCenter)
 
    def GetRadius(self):
        r"""GetRadius(SHAPE_CIRCLE self) -> int"""
        return _pcbnew.SHAPE_CIRCLE_GetRadius(self)
 
    def GetCenter(self):
        r"""GetCenter(SHAPE_CIRCLE self) -> VECTOR2I"""
        return _pcbnew.SHAPE_CIRCLE_GetCenter(self)
 
    def GetCircle(self):
        r"""GetCircle(SHAPE_CIRCLE self) -> CIRCLE const"""
        return _pcbnew.SHAPE_CIRCLE_GetCircle(self)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_CIRCLE self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_CIRCLE_Rotate(self, *args)
 
    def Format(self, aCplusPlus=True):
        r"""Format(SHAPE_CIRCLE self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_CIRCLE_Format(self, aCplusPlus)
 
# Register SHAPE_CIRCLE in _pcbnew:
_pcbnew.SHAPE_CIRCLE_swigregister(SHAPE_CIRCLE)
class SHAPE_COMPOUND(SHAPE):
    r"""Proxy of C++ SHAPE_COMPOUND 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_COMPOUND self) -> SHAPE_COMPOUND
        __init__(SHAPE_COMPOUND self, std::vector< SHAPE *,std::allocator< SHAPE * > > const & aShapes) -> SHAPE_COMPOUND
        __init__(SHAPE_COMPOUND self, SHAPE_COMPOUND aOther) -> SHAPE_COMPOUND
        """
        _pcbnew.SHAPE_COMPOUND_swiginit(self, _pcbnew.new_SHAPE_COMPOUND(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_COMPOUND
 
    def Clone(self):
        r"""Clone(SHAPE_COMPOUND self) -> SHAPE_COMPOUND"""
        return _pcbnew.SHAPE_COMPOUND_Clone(self)
 
    def Format(self, aCplusPlus=True):
        r"""Format(SHAPE_COMPOUND self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_COMPOUND_Format(self, aCplusPlus)
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_COMPOUND self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_COMPOUND self, SHAPE aShape, int aClearance, VECTOR2I aMTV) -> bool
        Collide(SHAPE_COMPOUND self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_COMPOUND_Collide(self, *args)
 
    def Shapes(self):
        r"""Shapes(SHAPE_COMPOUND self) -> std::vector< SHAPE *,std::allocator< SHAPE * > > const &"""
        return _pcbnew.SHAPE_COMPOUND_Shapes(self)
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_COMPOUND self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_COMPOUND_BBox(self, aClearance)
 
    def Distance(self, *args):
        r"""
        Distance(SHAPE_COMPOUND self, VECTOR2I aP) -> int
        Distance(SHAPE_COMPOUND self, SEG aSeg) -> int
        """
        return _pcbnew.SHAPE_COMPOUND_Distance(self, *args)
 
    def AddShape(self, *args):
        r"""
        AddShape(SHAPE_COMPOUND self, SHAPE aShape)
        AddShape(SHAPE_COMPOUND self, std::shared_ptr< SHAPE > aShape)
        """
        return _pcbnew.SHAPE_COMPOUND_AddShape(self, *args)
 
    def Empty(self):
        r"""Empty(SHAPE_COMPOUND self) -> bool"""
        return _pcbnew.SHAPE_COMPOUND_Empty(self)
 
    def Size(self):
        r"""Size(SHAPE_COMPOUND self) -> int"""
        return _pcbnew.SHAPE_COMPOUND_Size(self)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_COMPOUND self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_COMPOUND_Rotate(self, *args)
 
    def UniqueSubshape(self):
        r"""UniqueSubshape(SHAPE_COMPOUND self) -> SHAPE"""
        return _pcbnew.SHAPE_COMPOUND_UniqueSubshape(self)
 
    def GetSubshapes(self):
        r"""GetSubshapes(SHAPE_COMPOUND self) -> VECTOR_SHAPEPTR"""
        return _pcbnew.SHAPE_COMPOUND_GetSubshapes(self)
 
# Register SHAPE_COMPOUND in _pcbnew:
_pcbnew.SHAPE_COMPOUND_swigregister(SHAPE_COMPOUND)
class CLIPPER_Z_VALUE(object):
    r"""Proxy of C++ CLIPPER_Z_VALUE 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__(CLIPPER_Z_VALUE self) -> CLIPPER_Z_VALUE
        __init__(CLIPPER_Z_VALUE self, std::pair< ssize_t,ssize_t > const aShapeIndices, ssize_t aOffset=0) -> CLIPPER_Z_VALUE
        """
        _pcbnew.CLIPPER_Z_VALUE_swiginit(self, _pcbnew.new_CLIPPER_Z_VALUE(*args))
    m_FirstArcIdx = property(_pcbnew.CLIPPER_Z_VALUE_m_FirstArcIdx_get, _pcbnew.CLIPPER_Z_VALUE_m_FirstArcIdx_set, doc=r"""m_FirstArcIdx : ssize_t""")
    m_SecondArcIdx = property(_pcbnew.CLIPPER_Z_VALUE_m_SecondArcIdx_get, _pcbnew.CLIPPER_Z_VALUE_m_SecondArcIdx_set, doc=r"""m_SecondArcIdx : ssize_t""")
    __swig_destroy__ = _pcbnew.delete_CLIPPER_Z_VALUE
 
# Register CLIPPER_Z_VALUE in _pcbnew:
_pcbnew.CLIPPER_Z_VALUE_swigregister(CLIPPER_Z_VALUE)
class SHAPE_LINE_CHAIN(SHAPE_LINE_CHAIN_BASE):
    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, intVector aV) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, VECTOR_VECTOR2I aV, bool aClosed=False) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, SHAPE_ARC aArc, bool aClosed=False, std::optional< int > aMaxError={}) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, Clipper2Lib::Path64 const & aPath, std::vector< CLIPPER_Z_VALUE,std::allocator< CLIPPER_Z_VALUE > > const & aZValueBuffer, std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > const & aArcBuffer) -> SHAPE_LINE_CHAIN
        """
        _pcbnew.SHAPE_LINE_CHAIN_swiginit(self, _pcbnew.new_SHAPE_LINE_CHAIN(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_LINE_CHAIN
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_LINE_CHAIN self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Collide(self, *args)
 
    @staticmethod
    def ClosestPoints(*args):
        r"""
        ClosestPoints(SHAPE_LINE_CHAIN aOther, VECTOR2I aPt0, VECTOR2I aPt1) -> bool
        ClosestPoints(SHAPE_LINE_CHAIN::point_citer const & aMyStart, SHAPE_LINE_CHAIN::point_citer const & aMyEnd, SHAPE_LINE_CHAIN::point_citer const & aOtherStart, SHAPE_LINE_CHAIN::point_citer const & aOtherEnd, VECTOR2I aPt0, VECTOR2I aPt1, int64_t & aDistSq) -> bool
        """
        return _pcbnew.SHAPE_LINE_CHAIN_ClosestPoints(*args)
 
    @staticmethod
    def ClosestSegments(aMyPrevPt, aMyStart, aMyEnd, aOtherPrevPt, aOtherStart, aOtherEnd, aPt0, aPt1, aDistSq):
        r"""ClosestSegments(VECTOR2I aMyPrevPt, SHAPE_LINE_CHAIN::point_citer const & aMyStart, SHAPE_LINE_CHAIN::point_citer const & aMyEnd, VECTOR2I aOtherPrevPt, SHAPE_LINE_CHAIN::point_citer const & aOtherStart, SHAPE_LINE_CHAIN::point_citer const & aOtherEnd, VECTOR2I aPt0, VECTOR2I aPt1, int64_t & aDistSq) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_ClosestSegments(aMyPrevPt, aMyStart, aMyEnd, aOtherPrevPt, aOtherStart, aOtherEnd, aPt0, aPt1, aDistSq)
 
    def ClosestSegmentsFast(self, aOther, aPt0, aPt1):
        r"""ClosestSegmentsFast(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aOther, VECTOR2I aPt0, VECTOR2I aPt1) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_ClosestSegmentsFast(self, aOther, aPt0, aPt1)
 
    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 SetWidth(self, aWidth):
        r"""SetWidth(SHAPE_LINE_CHAIN self, int aWidth)"""
        return _pcbnew.SHAPE_LINE_CHAIN_SetWidth(self, aWidth)
 
    def Width(self):
        r"""Width(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Width(self)
 
    def SegmentCount(self):
        r"""SegmentCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_SegmentCount(self)
 
    def ShapeCount(self):
        r"""ShapeCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_ShapeCount(self)
 
    def RemoveDuplicatePoints(self):
        r"""RemoveDuplicatePoints(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_RemoveDuplicatePoints(self)
 
    def Simplify(self, aTolerance=0):
        r"""Simplify(SHAPE_LINE_CHAIN self, int aTolerance=0)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Simplify(self, aTolerance)
 
    def Simplify2(self, aRemoveColinear=True):
        r"""Simplify2(SHAPE_LINE_CHAIN self, bool aRemoveColinear=True) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Simplify2(self, aRemoveColinear)
 
    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"""
        return _pcbnew.SHAPE_LINE_CHAIN_CSegment(self, aIndex)
 
    def NextShape(self, aPointIndex):
        r"""NextShape(SHAPE_LINE_CHAIN self, int aPointIndex) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_NextShape(self, aPointIndex)
 
    def SetPoint(self, aIndex, aPos):
        r"""SetPoint(SHAPE_LINE_CHAIN self, int aIndex, VECTOR2I aPos)"""
        return _pcbnew.SHAPE_LINE_CHAIN_SetPoint(self, aIndex, aPos)
 
    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) -> VECTOR_VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CPoints(self)
 
    def CLastPoint(self):
        r"""CLastPoint(SHAPE_LINE_CHAIN self) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CLastPoint(self)
 
    def CArcs(self):
        r"""CArcs(SHAPE_LINE_CHAIN self) -> std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > const &"""
        return _pcbnew.SHAPE_LINE_CHAIN_CArcs(self)
 
    def CShapes(self):
        r"""CShapes(SHAPE_LINE_CHAIN self) -> std::vector< std::pair< ssize_t,ssize_t >,std::allocator< std::pair< ssize_t,ssize_t > > > const &"""
        return _pcbnew.SHAPE_LINE_CHAIN_CShapes(self)
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_LINE_CHAIN self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_BBox(self, aClearance)
 
    def GenerateBBoxCache(self):
        r"""GenerateBBoxCache(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_GenerateBBoxCache(self)
 
    def Reverse(self):
        r"""Reverse(SHAPE_LINE_CHAIN self) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Reverse(self)
 
    def ClearArcs(self):
        r"""ClearArcs(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_ClearArcs(self)
 
    def Length(self):
        r"""Length(SHAPE_LINE_CHAIN self) -> long long"""
        return _pcbnew.SHAPE_LINE_CHAIN_Length(self)
 
    def ReservePoints(self, aSize):
        r"""ReservePoints(SHAPE_LINE_CHAIN self, size_t aSize)"""
        return _pcbnew.SHAPE_LINE_CHAIN_ReservePoints(self, aSize)
 
    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)
        Append(SHAPE_LINE_CHAIN self, SHAPE_ARC aArc)
        Append(SHAPE_LINE_CHAIN self, SHAPE_ARC aArc, int aMaxError)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Append(self, *args)
 
    def Insert(self, *args):
        r"""
        Insert(SHAPE_LINE_CHAIN self, size_t aVertex, VECTOR2I aP)
        Insert(SHAPE_LINE_CHAIN self, size_t aVertex, SHAPE_ARC aArc)
        Insert(SHAPE_LINE_CHAIN self, size_t aVertex, SHAPE_ARC aArc, int aMaxError)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Insert(self, *args)
 
    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 RemoveShape(self, aPointIndex):
        r"""RemoveShape(SHAPE_LINE_CHAIN self, int aPointIndex)"""
        return _pcbnew.SHAPE_LINE_CHAIN_RemoveShape(self, aPointIndex)
 
    def Find(self, aP, aThreshold=0):
        r"""Find(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aThreshold=0) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Find(self, aP, aThreshold)
 
    def FindSegment(self, aP, aThreshold=1):
        r"""FindSegment(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aThreshold=1) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_FindSegment(self, aP, aThreshold)
 
    def Slice(self, *args):
        r"""
        Slice(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex) -> SHAPE_LINE_CHAIN
        Slice(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex, int aMaxError) -> SHAPE_LINE_CHAIN
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Slice(self, *args)
 
    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 aSeg, SHAPE_LINE_CHAIN::INTERSECTIONS & aIp) -> int
        Intersect(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aChain, SHAPE_LINE_CHAIN::INTERSECTIONS & aIp, bool aExcludeColinearAndTouching=False, BOX2I aChainBBox=None) -> int
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Intersect(self, *args)
 
    def PathLength(self, aP, aIndex=-1):
        r"""PathLength(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aIndex=-1) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PathLength(self, aP, aIndex)
 
    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) -> std::optional< SHAPE_LINE_CHAIN::INTERSECTION > const"""
        return _pcbnew.SHAPE_LINE_CHAIN_SelfIntersecting(self)
 
    def SelfIntersectingWithArcs(self):
        r"""SelfIntersectingWithArcs(SHAPE_LINE_CHAIN self) -> std::optional< SHAPE_LINE_CHAIN::INTERSECTION > const"""
        return _pcbnew.SHAPE_LINE_CHAIN_SelfIntersectingWithArcs(self)
 
    def NearestSegment(self, aP):
        r"""NearestSegment(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_NearestSegment(self, aP)
 
    def NearestPoint(self, *args):
        r"""
        NearestPoint(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aAllowInternalShapePoints=True) -> VECTOR2I
        NearestPoint(SHAPE_LINE_CHAIN self, SEG aSeg, int & dist) -> VECTOR2I
        """
        return _pcbnew.SHAPE_LINE_CHAIN_NearestPoint(self, *args)
 
    def Format(self, aCplusPlus=True):
        r"""Format(SHAPE_LINE_CHAIN self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_LINE_CHAIN_Format(self, aCplusPlus)
 
    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, aCyclicalCompare=False, aEpsilon=0):
        r"""CompareGeometry(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aOther, bool aCyclicalCompare=False, int aEpsilon=0) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_CompareGeometry(self, aOther, aCyclicalCompare, aEpsilon)
 
    def Mirror(self, *args):
        r"""
        Mirror(SHAPE_LINE_CHAIN self, VECTOR2I aRef, FLIP_DIRECTION aFlipDirection)
        Mirror(SHAPE_LINE_CHAIN self, SEG axis)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Mirror(self, *args)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_LINE_CHAIN self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_LINE_CHAIN_Rotate(self, *args)
 
    def PointAlong(self, aPathLength):
        r"""PointAlong(SHAPE_LINE_CHAIN self, int aPathLength) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointAlong(self, aPathLength)
 
    def Area(self, aAbsolute=True):
        r"""Area(SHAPE_LINE_CHAIN self, bool aAbsolute=True) -> double"""
        return _pcbnew.SHAPE_LINE_CHAIN_Area(self, aAbsolute)
 
    def Split(self, *args):
        r"""
        Split(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aExact=False) -> int
        Split(SHAPE_LINE_CHAIN self, VECTOR2I aStart, VECTOR2I aEnd, SHAPE_LINE_CHAIN aPre, SHAPE_LINE_CHAIN aMid, SHAPE_LINE_CHAIN aPost)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Split(self, *args)
 
    def OffsetLine(self, aAmount, aCornerStrategy, aMaxError, aLeft, aRight, aSimplify=False):
        r"""OffsetLine(SHAPE_LINE_CHAIN self, int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, SHAPE_LINE_CHAIN aLeft, SHAPE_LINE_CHAIN aRight, bool aSimplify=False) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_OffsetLine(self, aAmount, aCornerStrategy, aMaxError, aLeft, aRight, aSimplify)
 
    def ArcCount(self):
        r"""ArcCount(SHAPE_LINE_CHAIN self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_ArcCount(self)
 
    def ArcIndex(self, aSegment):
        r"""ArcIndex(SHAPE_LINE_CHAIN self, size_t aSegment) -> ssize_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_ArcIndex(self, aSegment)
 
    def Arc(self, aArc):
        r"""Arc(SHAPE_LINE_CHAIN self, size_t aArc) -> SHAPE_ARC"""
        return _pcbnew.SHAPE_LINE_CHAIN_Arc(self, aArc)
 
    def IsSharedPt(self, aIndex):
        r"""IsSharedPt(SHAPE_LINE_CHAIN self, size_t aIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsSharedPt(self, aIndex)
 
    def IsPtOnArc(self, aPtIndex):
        r"""IsPtOnArc(SHAPE_LINE_CHAIN self, size_t aPtIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsPtOnArc(self, aPtIndex)
 
    def IsArcSegment(self, aSegment):
        r"""IsArcSegment(SHAPE_LINE_CHAIN self, size_t aSegment) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsArcSegment(self, aSegment)
 
    def IsArcStart(self, aIndex):
        r"""IsArcStart(SHAPE_LINE_CHAIN self, size_t aIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsArcStart(self, aIndex)
 
    def IsArcEnd(self, aIndex):
        r"""IsArcEnd(SHAPE_LINE_CHAIN self, size_t aIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsArcEnd(self, aIndex)
 
    def Distance(self, *args):
        r"""
        Distance(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int
        Distance(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aOutlineOnly) -> int
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Distance(self, *args)
 
# 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, BOX2D const & aRect) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aOutline) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON const & aPolygon) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_POLY_SET aOther) -> SHAPE_POLY_SET
        """
        _pcbnew.SHAPE_POLY_SET_swiginit(self, _pcbnew.new_SHAPE_POLY_SET(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_POLY_SET
 
    def CacheTriangulation(self, aPartition=True, aSimplify=False):
        r"""CacheTriangulation(SHAPE_POLY_SET self, bool aPartition=True, bool aSimplify=False)"""
        return _pcbnew.SHAPE_POLY_SET_CacheTriangulation(self, aPartition, aSimplify)
 
    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) -> HASH_128"""
        return _pcbnew.SHAPE_POLY_SET_GetHash(self)
 
    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 CloneDropTriangulation(self):
        r"""CloneDropTriangulation(SHAPE_POLY_SET self) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_CloneDropTriangulation(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 AddPolygon(self, apolygon):
        r"""AddPolygon(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON const & apolygon) -> int"""
        return _pcbnew.SHAPE_POLY_SET_AddPolygon(self, apolygon)
 
    def Area(self):
        r"""Area(SHAPE_POLY_SET self) -> double"""
        return _pcbnew.SHAPE_POLY_SET_Area(self)
 
    def ArcCount(self):
        r"""ArcCount(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_ArcCount(self)
 
    def GetArcs(self, aArcBuffer):
        r"""GetArcs(SHAPE_POLY_SET self, std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > & aArcBuffer)"""
        return _pcbnew.SHAPE_POLY_SET_GetArcs(self, aArcBuffer)
 
    def ClearArcs(self):
        r"""ClearArcs(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_ClearArcs(self)
 
    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)
        Append(SHAPE_POLY_SET self, SHAPE_ARC aArc, int aOutline=-1, int aHole=-1, std::optional< int > aMaxError={}) -> int
        """
        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 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 FullPointCount(self):
        r"""FullPointCount(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_FullPointCount(self)
 
    def HoleCount(self, aOutline):
        r"""HoleCount(SHAPE_POLY_SET self, int aOutline) -> int"""
        return _pcbnew.SHAPE_POLY_SET_HoleCount(self, aOutline)
 
    def Outline(self, *args):
        r"""
        Outline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN
        Outline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN
        """
        return _pcbnew.SHAPE_POLY_SET_Outline(self, *args)
 
    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 CPolygons(self):
        r"""CPolygons(SHAPE_POLY_SET self) -> std::vector< SHAPE_POLY_SET::POLYGON,std::allocator< SHAPE_POLY_SET::POLYGON > > const &"""
        return _pcbnew.SHAPE_POLY_SET_CPolygons(self)
 
    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 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 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
        CIterateSegments(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateSegments(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, *args):
        r"""
        CIterateSegmentsWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        CIterateSegmentsWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateSegmentsWithHoles(self, *args)
 
    def BooleanAdd(self, *args):
        r"""
        BooleanAdd(SHAPE_POLY_SET self, SHAPE_POLY_SET b)
        BooleanAdd(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanAdd(self, *args)
 
    def BooleanSubtract(self, *args):
        r"""
        BooleanSubtract(SHAPE_POLY_SET self, SHAPE_POLY_SET b)
        BooleanSubtract(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanSubtract(self, *args)
 
    def BooleanIntersection(self, *args):
        r"""
        BooleanIntersection(SHAPE_POLY_SET self, SHAPE_POLY_SET b)
        BooleanIntersection(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanIntersection(self, *args)
 
    def BooleanXor(self, *args):
        r"""
        BooleanXor(SHAPE_POLY_SET self, SHAPE_POLY_SET b)
        BooleanXor(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanXor(self, *args)
 
    def RebuildHolesFromContours(self):
        r"""RebuildHolesFromContours(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_RebuildHolesFromContours(self)
 
    def Inflate(self, aAmount, aCornerStrategy, aMaxError, aSimplify=False):
        r"""Inflate(SHAPE_POLY_SET self, int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, bool aSimplify=False)"""
        return _pcbnew.SHAPE_POLY_SET_Inflate(self, aAmount, aCornerStrategy, aMaxError, aSimplify)
 
    def Deflate(self, aAmount, aCornerStrategy, aMaxError):
        r"""Deflate(SHAPE_POLY_SET self, int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError)"""
        return _pcbnew.SHAPE_POLY_SET_Deflate(self, aAmount, aCornerStrategy, aMaxError)
 
    def OffsetLineChain(self, aLine, aAmount, aCornerStrategy, aMaxError, aSimplify):
        r"""OffsetLineChain(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aLine, int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, bool aSimplify)"""
        return _pcbnew.SHAPE_POLY_SET_OffsetLineChain(self, aLine, aAmount, aCornerStrategy, aMaxError, aSimplify)
 
    def InflateWithLinkedHoles(self, aFactor, aCornerStrategy, aMaxError):
        r"""InflateWithLinkedHoles(SHAPE_POLY_SET self, int aFactor, CORNER_STRATEGY aCornerStrategy, int aMaxError)"""
        return _pcbnew.SHAPE_POLY_SET_InflateWithLinkedHoles(self, aFactor, aCornerStrategy, aMaxError)
 
    def Fracture(self):
        r"""Fracture(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_Fracture(self)
 
    def Unfracture(self):
        r"""Unfracture(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_Unfracture(self)
 
    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):
        r"""Simplify(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_Simplify(self)
 
    def SimplifyOutlines(self, aMaxError=0):
        r"""SimplifyOutlines(SHAPE_POLY_SET self, int aMaxError=0)"""
        return _pcbnew.SHAPE_POLY_SET_SimplifyOutlines(self, aMaxError)
 
    def NormalizeAreaOutlines(self):
        r"""NormalizeAreaOutlines(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_NormalizeAreaOutlines(self)
 
    def Format(self, aCplusPlus=True):
        r"""Format(SHAPE_POLY_SET self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_POLY_SET_Format(self, aCplusPlus)
 
    def Mirror(self, aRef, aFlipDirection):
        r"""Mirror(SHAPE_POLY_SET self, VECTOR2I aRef, FLIP_DIRECTION aFlipDirection)"""
        return _pcbnew.SHAPE_POLY_SET_Mirror(self, aRef, aFlipDirection)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_POLY_SET self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_POLY_SET_Rotate(self, *args)
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_POLY_SET self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_POLY_SET_BBox(self, aClearance)
 
    def PointOnEdge(self, aP, aAccuracy=0):
        r"""PointOnEdge(SHAPE_POLY_SET self, VECTOR2I aP, int aAccuracy=0) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_PointOnEdge(self, aP, aAccuracy)
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_POLY_SET self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_POLY_SET self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_POLY_SET self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_POLY_SET_Collide(self, *args)
 
    def CollideVertex(self, aPoint, aClosestVertex=None, aClearance=0):
        r"""CollideVertex(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX * aClosestVertex=None, int aClearance=0) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_CollideVertex(self, aPoint, aClosestVertex, aClearance)
 
    def CollideEdge(self, aPoint, aClosestVertex=None, aClearance=0):
        r"""CollideEdge(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX * aClosestVertex=None, int aClearance=0) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_CollideEdge(self, aPoint, aClosestVertex, aClearance)
 
    def PointInside(self, aPt, aAccuracy=0, aUseBBoxCache=False):
        r"""PointInside(SHAPE_POLY_SET self, VECTOR2I aPt, int aAccuracy=0, bool aUseBBoxCache=False) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_PointInside(self, aPt, aAccuracy, aUseBBoxCache)
 
    def BuildBBoxCaches(self):
        r"""BuildBBoxCaches(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_BuildBBoxCaches(self)
 
    def BBoxFromCaches(self):
        r"""BBoxFromCaches(SHAPE_POLY_SET self) -> BOX2I"""
        return _pcbnew.SHAPE_POLY_SET_BBoxFromCaches(self)
 
    def Contains(self, aP, aSubpolyIndex=-1, aAccuracy=0, aUseBBoxCaches=False):
        r"""Contains(SHAPE_POLY_SET self, VECTOR2I aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=False) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_Contains(self, aP, aSubpolyIndex, aAccuracy, aUseBBoxCaches)
 
    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 RemoveOutline(self, aOutlineIdx):
        r"""RemoveOutline(SHAPE_POLY_SET self, int aOutlineIdx)"""
        return _pcbnew.SHAPE_POLY_SET_RemoveOutline(self, aOutlineIdx)
 
    def RemoveNullSegments(self):
        r"""RemoveNullSegments(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_RemoveNullSegments(self)
 
    def SetVertex(self, *args):
        r"""
        SetVertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX const & aIndex, VECTOR2I aPos)
        SetVertex(SHAPE_POLY_SET self, int aGlobalIndex, VECTOR2I aPos)
        """
        return _pcbnew.SHAPE_POLY_SET_SetVertex(self, *args)
 
    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 DeletePolygonAndTriangulationData(self, aIdx, aUpdateHash=True):
        r"""DeletePolygonAndTriangulationData(SHAPE_POLY_SET self, int aIdx, bool aUpdateHash=True)"""
        return _pcbnew.SHAPE_POLY_SET_DeletePolygonAndTriangulationData(self, aIdx, aUpdateHash)
 
    def UpdateTriangulationDataHash(self):
        r"""UpdateTriangulationDataHash(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_UpdateTriangulationDataHash(self)
 
    def ChamferPolygon(self, aDistance, aIndex):
        r"""ChamferPolygon(SHAPE_POLY_SET self, unsigned int aDistance, int aIndex) -> SHAPE_POLY_SET::POLYGON"""
        return _pcbnew.SHAPE_POLY_SET_ChamferPolygon(self, aDistance, aIndex)
 
    def FilletPolygon(self, aRadius, aErrorMax, aIndex):
        r"""FilletPolygon(SHAPE_POLY_SET self, unsigned int aRadius, int aErrorMax, int aIndex) -> 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 SquaredDistanceToPolygon(self, *args):
        r"""
        SquaredDistanceToPolygon(SHAPE_POLY_SET self, VECTOR2I aPoint, int aIndex, VECTOR2I aNearest) -> SEG::ecoord
        SquaredDistanceToPolygon(SHAPE_POLY_SET self, SEG aSegment, int aIndex, VECTOR2I aNearest) -> SEG::ecoord
        """
        return _pcbnew.SHAPE_POLY_SET_SquaredDistanceToPolygon(self, *args)
 
    def SquaredDistance(self, *args):
        r"""
        SquaredDistance(SHAPE_POLY_SET self, VECTOR2I aPoint, bool aOutlineOnly, VECTOR2I aNearest) -> SEG::ecoord
        SquaredDistance(SHAPE_POLY_SET self, VECTOR2I aPoint, bool aOutlineOnly=False) -> SEG::ecoord
        """
        return _pcbnew.SHAPE_POLY_SET_SquaredDistance(self, *args)
 
    def SquaredDistanceToSeg(self, aSegment, aNearest=None):
        r"""SquaredDistanceToSeg(SHAPE_POLY_SET self, SEG aSegment, VECTOR2I aNearest=None) -> SEG::ecoord"""
        return _pcbnew.SHAPE_POLY_SET_SquaredDistanceToSeg(self, aSegment, aNearest)
 
    def IsVertexInHole(self, aGlobalIdx):
        r"""IsVertexInHole(SHAPE_POLY_SET self, int aGlobalIdx) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsVertexInHole(self, aGlobalIdx)
 
    def BuildPolysetFromOrientedPaths(self, aPaths, aEvenOdd=False):
        r"""BuildPolysetFromOrientedPaths(SHAPE_POLY_SET self, std::vector< SHAPE_LINE_CHAIN,std::allocator< SHAPE_LINE_CHAIN > > const & aPaths, bool aEvenOdd=False)"""
        return _pcbnew.SHAPE_POLY_SET_BuildPolysetFromOrientedPaths(self, aPaths, aEvenOdd)
 
# Register SHAPE_POLY_SET in _pcbnew:
_pcbnew.SHAPE_POLY_SET_swigregister(SHAPE_POLY_SET)
class SHAPE_RECT(SHAPE):
    r"""Proxy of C++ SHAPE_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__(SHAPE_RECT self) -> SHAPE_RECT
        __init__(SHAPE_RECT self, BOX2I aBox) -> SHAPE_RECT
        __init__(SHAPE_RECT self, int aX0, int aY0, int aW, int aH) -> SHAPE_RECT
        __init__(SHAPE_RECT self, VECTOR2I aP0, int aW, int aH) -> SHAPE_RECT
        __init__(SHAPE_RECT self, VECTOR2I aP0, VECTOR2I aP1) -> SHAPE_RECT
        __init__(SHAPE_RECT self, SHAPE_RECT aOther) -> SHAPE_RECT
        """
        _pcbnew.SHAPE_RECT_swiginit(self, _pcbnew.new_SHAPE_RECT(*args))
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_RECT self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_RECT_BBox(self, aClearance)
 
    def GetInflated(self, aOffset):
        r"""GetInflated(SHAPE_RECT self, int aOffset) -> SHAPE_RECT"""
        return _pcbnew.SHAPE_RECT_GetInflated(self, aOffset)
 
    def Diagonal(self):
        r"""Diagonal(SHAPE_RECT self) -> int"""
        return _pcbnew.SHAPE_RECT_Diagonal(self)
 
    def MajorDimension(self):
        r"""MajorDimension(SHAPE_RECT self) -> int"""
        return _pcbnew.SHAPE_RECT_MajorDimension(self)
 
    def MinorDimension(self):
        r"""MinorDimension(SHAPE_RECT self) -> int"""
        return _pcbnew.SHAPE_RECT_MinorDimension(self)
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_RECT self, SHAPE aShape, int aClearance, VECTOR2I aMTV) -> bool
        Collide(SHAPE_RECT self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_RECT self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_RECT_Collide(self, *args)
 
    def GetPosition(self):
        r"""GetPosition(SHAPE_RECT self) -> VECTOR2I"""
        return _pcbnew.SHAPE_RECT_GetPosition(self)
 
    def GetSize(self):
        r"""GetSize(SHAPE_RECT self) -> VECTOR2I"""
        return _pcbnew.SHAPE_RECT_GetSize(self)
 
    def GetWidth(self):
        r"""GetWidth(SHAPE_RECT self) -> int"""
        return _pcbnew.SHAPE_RECT_GetWidth(self)
 
    def GetHeight(self):
        r"""GetHeight(SHAPE_RECT self) -> int"""
        return _pcbnew.SHAPE_RECT_GetHeight(self)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_RECT self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_RECT_Rotate(self, *args)
 
    def Outline(self):
        r"""Outline(SHAPE_RECT self) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_RECT_Outline(self)
 
    def Format(self, aCplusPlus=True):
        r"""Format(SHAPE_RECT self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_RECT_Format(self, aCplusPlus)
    __swig_destroy__ = _pcbnew.delete_SHAPE_RECT
 
# Register SHAPE_RECT in _pcbnew:
_pcbnew.SHAPE_RECT_swigregister(SHAPE_RECT)
class SHAPE_SEGMENT(SHAPE):
    r"""Proxy of C++ SHAPE_SEGMENT 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_SEGMENT self) -> SHAPE_SEGMENT
        __init__(SHAPE_SEGMENT self, VECTOR2I aA, VECTOR2I aB, int aWidth=0) -> SHAPE_SEGMENT
        __init__(SHAPE_SEGMENT self, SEG aSeg, int aWidth=0) -> SHAPE_SEGMENT
        """
        _pcbnew.SHAPE_SEGMENT_swiginit(self, _pcbnew.new_SHAPE_SEGMENT(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_SEGMENT
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_SEGMENT self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_SEGMENT_BBox(self, aClearance)
 
    def Collide(self, *args):
        r"""
        Collide(SHAPE_SEGMENT self, SHAPE aShape, int aClearance, VECTOR2I aMTV) -> bool
        Collide(SHAPE_SEGMENT self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_SEGMENT self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_SEGMENT self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_SEGMENT_Collide(self, *args)
 
    def SetSeg(self, aSeg):
        r"""SetSeg(SHAPE_SEGMENT self, SEG aSeg)"""
        return _pcbnew.SHAPE_SEGMENT_SetSeg(self, aSeg)
 
    def GetSeg(self):
        r"""GetSeg(SHAPE_SEGMENT self) -> SEG"""
        return _pcbnew.SHAPE_SEGMENT_GetSeg(self)
 
    def SetWidth(self, aWidth):
        r"""SetWidth(SHAPE_SEGMENT self, int aWidth)"""
        return _pcbnew.SHAPE_SEGMENT_SetWidth(self, aWidth)
 
    def GetWidth(self):
        r"""GetWidth(SHAPE_SEGMENT self) -> int"""
        return _pcbnew.SHAPE_SEGMENT_GetWidth(self)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_SEGMENT self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_SEGMENT_Rotate(self, *args)
 
    def Is45Degree(self, *args):
        r"""Is45Degree(SHAPE_SEGMENT self, EDA_ANGLE aTollerance=EDA_ANGLE( 1.0, DEGREES_T )) -> bool"""
        return _pcbnew.SHAPE_SEGMENT_Is45Degree(self, *args)
 
    def Format(self, aCplusPlus=True):
        r"""Format(SHAPE_SEGMENT self, bool aCplusPlus=True) -> string"""
        return _pcbnew.SHAPE_SEGMENT_Format(self, aCplusPlus)
 
# Register SHAPE_SEGMENT in _pcbnew:
_pcbnew.SHAPE_SEGMENT_swigregister(SHAPE_SEGMENT)
class SHAPE_SIMPLE(SHAPE_LINE_CHAIN_BASE):
    r"""Proxy of C++ SHAPE_SIMPLE 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_SIMPLE self) -> SHAPE_SIMPLE
        __init__(SHAPE_SIMPLE self, SHAPE_LINE_CHAIN aPoly) -> SHAPE_SIMPLE
        __init__(SHAPE_SIMPLE self, SHAPE_SIMPLE aOther) -> SHAPE_SIMPLE
        """
        _pcbnew.SHAPE_SIMPLE_swiginit(self, _pcbnew.new_SHAPE_SIMPLE(*args))
 
    def Clear(self):
        r"""Clear(SHAPE_SIMPLE self)"""
        return _pcbnew.SHAPE_SIMPLE_Clear(self)
 
    def BBox(self, aClearance=0):
        r"""BBox(SHAPE_SIMPLE self, int aClearance=0) -> BOX2I"""
        return _pcbnew.SHAPE_SIMPLE_BBox(self, aClearance)
 
    def PointCount(self):
        r"""PointCount(SHAPE_SIMPLE self) -> int"""
        return _pcbnew.SHAPE_SIMPLE_PointCount(self)
 
    def CPoint(self, aIndex):
        r"""CPoint(SHAPE_SIMPLE self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_SIMPLE_CPoint(self, aIndex)
 
    def CDPoint(self, aIndex):
        r"""CDPoint(SHAPE_SIMPLE self, int aIndex) -> VECTOR2D const"""
        return _pcbnew.SHAPE_SIMPLE_CDPoint(self, aIndex)
 
    def Vertices(self):
        r"""Vertices(SHAPE_SIMPLE self) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_SIMPLE_Vertices(self)
 
    def Append(self, *args):
        r"""
        Append(SHAPE_SIMPLE self, int aX, int aY)
        Append(SHAPE_SIMPLE self, VECTOR2I aP)
        """
        return _pcbnew.SHAPE_SIMPLE_Append(self, *args)
 
    def Collide(self, aSeg, aClearance=0, aActual=None, aLocation=None):
        r"""Collide(SHAPE_SIMPLE self, SEG aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool"""
        return _pcbnew.SHAPE_SIMPLE_Collide(self, aSeg, aClearance, aActual, aLocation)
 
    def Rotate(self, *args):
        r"""Rotate(SHAPE_SIMPLE self, EDA_ANGLE aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_SIMPLE_Rotate(self, *args)
    __swig_destroy__ = _pcbnew.delete_SHAPE_SIMPLE
 
# Register SHAPE_SIMPLE in _pcbnew:
_pcbnew.SHAPE_SIMPLE_swigregister(SHAPE_SIMPLE)
ERROR_OUTSIDE = _pcbnew.ERROR_OUTSIDE
 
ERROR_INSIDE = _pcbnew.ERROR_INSIDE
 
class VECTOR_SHAPEPTR(object):
    r"""Proxy of C++ std::vector< std::shared_ptr< SHAPE > > 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(VECTOR_SHAPEPTR self) -> SwigPyIterator"""
        return _pcbnew.VECTOR_SHAPEPTR_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(VECTOR_SHAPEPTR self) -> bool"""
        return _pcbnew.VECTOR_SHAPEPTR___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(VECTOR_SHAPEPTR self) -> bool"""
        return _pcbnew.VECTOR_SHAPEPTR___bool__(self)
 
    def __len__(self):
        r"""__len__(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::size_type"""
        return _pcbnew.VECTOR_SHAPEPTR___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i, std::vector< std::shared_ptr< SHAPE > >::difference_type j) -> VECTOR_SHAPEPTR"""
        return _pcbnew.VECTOR_SHAPEPTR___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i, std::vector< std::shared_ptr< SHAPE > >::difference_type j)
        __setslice__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i, std::vector< std::shared_ptr< SHAPE > >::difference_type j, VECTOR_SHAPEPTR v)
        """
        return _pcbnew.VECTOR_SHAPEPTR___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i, std::vector< std::shared_ptr< SHAPE > >::difference_type j)"""
        return _pcbnew.VECTOR_SHAPEPTR___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i)
        __delitem__(VECTOR_SHAPEPTR self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.VECTOR_SHAPEPTR___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(VECTOR_SHAPEPTR self, SWIGPY_SLICEOBJECT * slice) -> VECTOR_SHAPEPTR
        __getitem__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i) -> std::vector< std::shared_ptr< SHAPE > >::value_type const &
        """
        return _pcbnew.VECTOR_SHAPEPTR___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(VECTOR_SHAPEPTR self, SWIGPY_SLICEOBJECT * slice, VECTOR_SHAPEPTR v)
        __setitem__(VECTOR_SHAPEPTR self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::difference_type i, std::vector< std::shared_ptr< SHAPE > >::value_type const & x)
        """
        return _pcbnew.VECTOR_SHAPEPTR___setitem__(self, *args)
 
    def pop(self):
        r"""pop(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::value_type"""
        return _pcbnew.VECTOR_SHAPEPTR_pop(self)
 
    def append(self, x):
        r"""append(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::value_type const & x)"""
        return _pcbnew.VECTOR_SHAPEPTR_append(self, x)
 
    def empty(self):
        r"""empty(VECTOR_SHAPEPTR self) -> bool"""
        return _pcbnew.VECTOR_SHAPEPTR_empty(self)
 
    def size(self):
        r"""size(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::size_type"""
        return _pcbnew.VECTOR_SHAPEPTR_size(self)
 
    def swap(self, v):
        r"""swap(VECTOR_SHAPEPTR self, VECTOR_SHAPEPTR v)"""
        return _pcbnew.VECTOR_SHAPEPTR_swap(self, v)
 
    def begin(self):
        r"""begin(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::iterator"""
        return _pcbnew.VECTOR_SHAPEPTR_begin(self)
 
    def end(self):
        r"""end(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::iterator"""
        return _pcbnew.VECTOR_SHAPEPTR_end(self)
 
    def rbegin(self):
        r"""rbegin(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::reverse_iterator"""
        return _pcbnew.VECTOR_SHAPEPTR_rbegin(self)
 
    def rend(self):
        r"""rend(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::reverse_iterator"""
        return _pcbnew.VECTOR_SHAPEPTR_rend(self)
 
    def clear(self):
        r"""clear(VECTOR_SHAPEPTR self)"""
        return _pcbnew.VECTOR_SHAPEPTR_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::allocator_type"""
        return _pcbnew.VECTOR_SHAPEPTR_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(VECTOR_SHAPEPTR self)"""
        return _pcbnew.VECTOR_SHAPEPTR_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::iterator pos) -> std::vector< std::shared_ptr< SHAPE > >::iterator
        erase(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::iterator first, std::vector< std::shared_ptr< SHAPE > >::iterator last) -> std::vector< std::shared_ptr< SHAPE > >::iterator
        """
        return _pcbnew.VECTOR_SHAPEPTR_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(VECTOR_SHAPEPTR self) -> VECTOR_SHAPEPTR
        __init__(VECTOR_SHAPEPTR self, VECTOR_SHAPEPTR other) -> VECTOR_SHAPEPTR
        __init__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::size_type size) -> VECTOR_SHAPEPTR
        __init__(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::size_type size, std::vector< std::shared_ptr< SHAPE > >::value_type const & value) -> VECTOR_SHAPEPTR
        """
        _pcbnew.VECTOR_SHAPEPTR_swiginit(self, _pcbnew.new_VECTOR_SHAPEPTR(*args))
 
    def push_back(self, x):
        r"""push_back(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::value_type const & x)"""
        return _pcbnew.VECTOR_SHAPEPTR_push_back(self, x)
 
    def front(self):
        r"""front(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::value_type const &"""
        return _pcbnew.VECTOR_SHAPEPTR_front(self)
 
    def back(self):
        r"""back(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::value_type const &"""
        return _pcbnew.VECTOR_SHAPEPTR_back(self)
 
    def assign(self, n, x):
        r"""assign(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::size_type n, std::vector< std::shared_ptr< SHAPE > >::value_type const & x)"""
        return _pcbnew.VECTOR_SHAPEPTR_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::size_type new_size)
        resize(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::size_type new_size, std::vector< std::shared_ptr< SHAPE > >::value_type const & x)
        """
        return _pcbnew.VECTOR_SHAPEPTR_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::iterator pos, std::vector< std::shared_ptr< SHAPE > >::value_type const & x) -> std::vector< std::shared_ptr< SHAPE > >::iterator
        insert(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::iterator pos, std::vector< std::shared_ptr< SHAPE > >::size_type n, std::vector< std::shared_ptr< SHAPE > >::value_type const & x)
        """
        return _pcbnew.VECTOR_SHAPEPTR_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(VECTOR_SHAPEPTR self, std::vector< std::shared_ptr< SHAPE > >::size_type n)"""
        return _pcbnew.VECTOR_SHAPEPTR_reserve(self, n)
 
    def capacity(self):
        r"""capacity(VECTOR_SHAPEPTR self) -> std::vector< std::shared_ptr< SHAPE > >::size_type"""
        return _pcbnew.VECTOR_SHAPEPTR_capacity(self)
 
    def __iter__(self):
        it = self.iterator()
        try:
            while True:
                item = it.next()  # throws StopIteration when iterator reached the end.
                yield item.Cast()
        except StopIteration:
            return
 
    __swig_destroy__ = _pcbnew.delete_VECTOR_SHAPEPTR
 
# Register VECTOR_SHAPEPTR in _pcbnew:
_pcbnew.VECTOR_SHAPEPTR_swigregister(VECTOR_SHAPEPTR)
 
def Cast_to_SHAPE_ARC(_self):
    r"""Cast_to_SHAPE_ARC(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_ARC >"""
    return _pcbnew.Cast_to_SHAPE_ARC(_self)
 
def Cast_to_SHAPE_CIRCLE(_self):
    r"""Cast_to_SHAPE_CIRCLE(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_CIRCLE >"""
    return _pcbnew.Cast_to_SHAPE_CIRCLE(_self)
 
def Cast_to_SHAPE_COMPOUND(_self):
    r"""Cast_to_SHAPE_COMPOUND(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_COMPOUND >"""
    return _pcbnew.Cast_to_SHAPE_COMPOUND(_self)
 
def Cast_to_SHAPE_LINE_CHAIN(_self):
    r"""Cast_to_SHAPE_LINE_CHAIN(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_LINE_CHAIN >"""
    return _pcbnew.Cast_to_SHAPE_LINE_CHAIN(_self)
 
def Cast_to_SHAPE_POLY_SET(_self):
    r"""Cast_to_SHAPE_POLY_SET(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_POLY_SET >"""
    return _pcbnew.Cast_to_SHAPE_POLY_SET(_self)
 
def Cast_to_SHAPE_RECT(_self):
    r"""Cast_to_SHAPE_RECT(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_RECT >"""
    return _pcbnew.Cast_to_SHAPE_RECT(_self)
 
def Cast_to_SHAPE_SEGMENT(_self):
    r"""Cast_to_SHAPE_SEGMENT(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_SEGMENT >"""
    return _pcbnew.Cast_to_SHAPE_SEGMENT(_self)
 
def Cast_to_SHAPE_SIMPLE(_self):
    r"""Cast_to_SHAPE_SIMPLE(std::shared_ptr< SHAPE > _self) -> std::shared_ptr< SHAPE_SIMPLE >"""
    return _pcbnew.Cast_to_SHAPE_SIMPLE(_self)
FLIP_DIRECTION_LEFT_RIGHT = _pcbnew.FLIP_DIRECTION_LEFT_RIGHT
 
FLIP_DIRECTION_TOP_BOTTOM = _pcbnew.FLIP_DIRECTION_TOP_BOTTOM
 
 
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 __ne__(self, rhs):
        r"""__ne__(UTF8 self, UTF8 rhs) -> bool"""
        return _pcbnew.UTF8___ne__(self, rhs)
 
    def __lt__(self, rhs):
        r"""__lt__(UTF8 self, UTF8 rhs) -> bool"""
        return _pcbnew.UTF8___lt__(self, rhs)
 
    def __gt__(self, rhs):
        r"""__gt__(UTF8 self, UTF8 rhs) -> bool"""
        return _pcbnew.UTF8___gt__(self, rhs)
 
    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)
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
 
    def __init__(self, *args):
        r"""
        __init__(LIB_ID self) -> LIB_ID
        __init__(LIB_ID self, wxString aLibraryName, wxString aItemName) -> LIB_ID
        """
        _pcbnew.LIB_ID_swiginit(self, _pcbnew.new_LIB_ID(*args))
 
    def Parse(self, aId, aFix=False):
        r"""Parse(LIB_ID self, UTF8 aId, bool aFix=False) -> int"""
        return _pcbnew.LIB_ID_Parse(self, aId, aFix)
 
    def GetLibNickname(self):
        r"""GetLibNickname(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetLibNickname(self)
 
    def GetUniStringLibNickname(self):
        r"""GetUniStringLibNickname(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetUniStringLibNickname(self)
 
    def SetLibNickname(self, aLibNickname):
        r"""SetLibNickname(LIB_ID self, UTF8 aLibNickname) -> int"""
        return _pcbnew.LIB_ID_SetLibNickname(self, aLibNickname)
 
    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):
        r"""SetLibItemName(LIB_ID self, UTF8 aLibItemName) -> int"""
        return _pcbnew.LIB_ID_SetLibItemName(self, aLibItemName)
 
    def GetSubLibraryName(self):
        r"""GetSubLibraryName(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetSubLibraryName(self)
 
    def SetSubLibraryName(self, aName):
        r"""SetSubLibraryName(LIB_ID self, UTF8 aName)"""
        return _pcbnew.LIB_ID_SetSubLibraryName(self, aName)
 
    def GetUniStringSubLibraryName(self):
        r"""GetUniStringSubLibraryName(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetUniStringSubLibraryName(self)
 
    def GetFullLibraryName(self):
        r"""GetFullLibraryName(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetFullLibraryName(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 aLibraryName, UTF8 aLibItemName) -> 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):
        r"""HasIllegalChars(UTF8 aLibItemName) -> int"""
        return _pcbnew.LIB_ID_HasIllegalChars(aLibItemName)
 
    @staticmethod
    def FixIllegalChars(aLibItemName, aLib):
        r"""FixIllegalChars(UTF8 aLibItemName, bool aLib) -> UTF8"""
        return _pcbnew.LIB_ID_FixIllegalChars(aLibItemName, aLib)
 
    @staticmethod
    def FindIllegalLibraryNameChar(aLibraryName):
        r"""FindIllegalLibraryNameChar(UTF8 aLibraryName) -> unsigned int"""
        return _pcbnew.LIB_ID_FindIllegalLibraryNameChar(aLibraryName)
    __swig_destroy__ = _pcbnew.delete_LIB_ID
 
# Register LIB_ID in _pcbnew:
_pcbnew.LIB_ID_swigregister(LIB_ID)
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 PCB_IO_MGR(object):
    r"""Proxy of C++ PCB_IO_MGR class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PCB_FILE_UNKNOWN = _pcbnew.PCB_IO_MGR_PCB_FILE_UNKNOWN
    
    KICAD_SEXP = _pcbnew.PCB_IO_MGR_KICAD_SEXP
    
    LEGACY = _pcbnew.PCB_IO_MGR_LEGACY
    
    ALTIUM_CIRCUIT_MAKER = _pcbnew.PCB_IO_MGR_ALTIUM_CIRCUIT_MAKER
    
    ALTIUM_CIRCUIT_STUDIO = _pcbnew.PCB_IO_MGR_ALTIUM_CIRCUIT_STUDIO
    
    ALTIUM_DESIGNER = _pcbnew.PCB_IO_MGR_ALTIUM_DESIGNER
    
    CADSTAR_PCB_ARCHIVE = _pcbnew.PCB_IO_MGR_CADSTAR_PCB_ARCHIVE
    
    EAGLE = _pcbnew.PCB_IO_MGR_EAGLE
    
    EASYEDA = _pcbnew.PCB_IO_MGR_EASYEDA
    
    EASYEDAPRO = _pcbnew.PCB_IO_MGR_EASYEDAPRO
    
    FABMASTER = _pcbnew.PCB_IO_MGR_FABMASTER
    
    GEDA_PCB = _pcbnew.PCB_IO_MGR_GEDA_PCB
    
    PCAD = _pcbnew.PCB_IO_MGR_PCAD
    
    SOLIDWORKS_PCB = _pcbnew.PCB_IO_MGR_SOLIDWORKS_PCB
    
    IPC2581 = _pcbnew.PCB_IO_MGR_IPC2581
    
    ODBPP = _pcbnew.PCB_IO_MGR_ODBPP
    
    FILE_TYPE_NONE = _pcbnew.PCB_IO_MGR_FILE_TYPE_NONE
    
 
    @staticmethod
    def PluginFind(aFileType):
        r"""PluginFind(PCB_IO_MGR::PCB_FILE_T aFileType) -> PCB_IO"""
        return _pcbnew.PCB_IO_MGR_PluginFind(aFileType)
 
    @staticmethod
    def ShowType(aFileType):
        r"""ShowType(PCB_IO_MGR::PCB_FILE_T aFileType) -> wxString"""
        return _pcbnew.PCB_IO_MGR_ShowType(aFileType)
 
    @staticmethod
    def EnumFromStr(aFileType):
        r"""EnumFromStr(wxString aFileType) -> PCB_IO_MGR::PCB_FILE_T"""
        return _pcbnew.PCB_IO_MGR_EnumFromStr(aFileType)
 
    @staticmethod
    def FindPluginTypeFromBoardPath(aFileName, aCtl=0):
        r"""FindPluginTypeFromBoardPath(wxString aFileName, int aCtl=0) -> PCB_IO_MGR::PCB_FILE_T"""
        return _pcbnew.PCB_IO_MGR_FindPluginTypeFromBoardPath(aFileName, aCtl)
 
    @staticmethod
    def GuessPluginTypeFromLibPath(aLibPath, aCtl=0):
        r"""GuessPluginTypeFromLibPath(wxString aLibPath, int aCtl=0) -> PCB_IO_MGR::PCB_FILE_T"""
        return _pcbnew.PCB_IO_MGR_GuessPluginTypeFromLibPath(aLibPath, aCtl)
 
    @staticmethod
    def Load(aFileType, aFileName, aAppendToMe=None, aProperties=None, aProject=None, aProgressReporter=None):
        r"""Load(PCB_IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aAppendToMe=None, str_utf8_Map aProperties=None, PROJECT * aProject=None, PROGRESS_REPORTER * aProgressReporter=None) -> BOARD"""
        return _pcbnew.PCB_IO_MGR_Load(aFileType, aFileName, aAppendToMe, aProperties, aProject, aProgressReporter)
 
    @staticmethod
    def Save(aFileType, aFileName, aBoard, aProperties=None):
        r"""Save(PCB_IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aBoard, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_MGR_Save(aFileType, aFileName, aBoard, aProperties)
 
    @staticmethod
    def ConvertLibrary(aOldFileProps, aOldFilePath, aNewFilePath, aReporter):
        r"""ConvertLibrary(str_utf8_Map aOldFileProps, wxString aOldFilePath, wxString aNewFilePath, REPORTER * aReporter) -> bool"""
        return _pcbnew.PCB_IO_MGR_ConvertLibrary(aOldFileProps, aOldFilePath, aNewFilePath, aReporter)
 
    def __init__(self):
        r"""__init__(PCB_IO_MGR self) -> PCB_IO_MGR"""
        _pcbnew.PCB_IO_MGR_swiginit(self, _pcbnew.new_PCB_IO_MGR())
    __swig_destroy__ = _pcbnew.delete_PCB_IO_MGR
 
# Register PCB_IO_MGR in _pcbnew:
_pcbnew.PCB_IO_MGR_swigregister(PCB_IO_MGR)
class PCB_IO(object):
    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")
 
    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
 
    def GetBoardFileDesc(self):
        r"""GetBoardFileDesc(PCB_IO self) -> IO_BASE::IO_FILE_DESC const"""
        return _pcbnew.PCB_IO_GetBoardFileDesc(self)
 
    def CanReadBoard(self, aFileName):
        r"""CanReadBoard(PCB_IO self, wxString aFileName) -> bool"""
        return _pcbnew.PCB_IO_CanReadBoard(self, aFileName)
 
    def CanReadFootprint(self, aFileName):
        r"""CanReadFootprint(PCB_IO self, wxString aFileName) -> bool"""
        return _pcbnew.PCB_IO_CanReadFootprint(self, aFileName)
 
    def SetQueryUserCallback(self, aCallback):
        r"""SetQueryUserCallback(PCB_IO self, std::function< bool (wxString,int,wxString,wxString) > aCallback)"""
        return _pcbnew.PCB_IO_SetQueryUserCallback(self, aCallback)
 
    def LoadBoard(self, aFileName, aAppendToMe, aProperties=None, aProject=None):
        r"""LoadBoard(PCB_IO self, wxString aFileName, BOARD aAppendToMe, str_utf8_Map aProperties=None, PROJECT * aProject=None) -> BOARD"""
        return _pcbnew.PCB_IO_LoadBoard(self, aFileName, aAppendToMe, aProperties, aProject)
 
    def GetImportedCachedLibraryFootprints(self):
        r"""GetImportedCachedLibraryFootprints(PCB_IO self) -> std::vector< FOOTPRINT *,std::allocator< FOOTPRINT * > >"""
        return _pcbnew.PCB_IO_GetImportedCachedLibraryFootprints(self)
 
    def SaveBoard(self, aFileName, aBoard, aProperties=None):
        r"""SaveBoard(PCB_IO self, wxString aFileName, BOARD aBoard, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_SaveBoard(self, aFileName, aBoard, aProperties)
 
    def FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties=None):
        r"""FootprintEnumerate(PCB_IO self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties)
 
    def GetLibraryTimestamp(self, aLibraryPath):
        r"""GetLibraryTimestamp(PCB_IO self, wxString aLibraryPath) -> long long"""
        return _pcbnew.PCB_IO_GetLibraryTimestamp(self, aLibraryPath)
 
    def ImportFootprint(self, aFootprintPath, aFootprintNameOut, aProperties=None):
        r"""ImportFootprint(PCB_IO self, wxString aFootprintPath, wxString aFootprintNameOut, str_utf8_Map aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_IO_ImportFootprint(self, aFootprintPath, aFootprintNameOut, aProperties)
 
    def FootprintLoad(self, aLibraryPath, aFootprintName, aKeepUUID=False, aProperties=None):
        r"""FootprintLoad(PCB_IO self, wxString aLibraryPath, wxString aFootprintName, bool aKeepUUID=False, str_utf8_Map aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_IO_FootprintLoad(self, aLibraryPath, aFootprintName, aKeepUUID, aProperties)
 
    def GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties=None):
        r"""GetEnumeratedFootprint(PCB_IO self, wxString aLibraryPath, wxString aFootprintName, str_utf8_Map aProperties=None) -> FOOTPRINT"""
        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, str_utf8_Map aProperties=None) -> bool"""
        return _pcbnew.PCB_IO_FootprintExists(self, aLibraryPath, aFootprintName, aProperties)
 
    def FootprintSave(self, aLibraryPath, aFootprint, aProperties=None):
        r"""FootprintSave(PCB_IO self, wxString aLibraryPath, FOOTPRINT aFootprint, str_utf8_Map 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, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)
 
    def GetLibraryOptions(self, aListToAppendTo):
        r"""GetLibraryOptions(PCB_IO self, str_utf8_Map aListToAppendTo)"""
        return _pcbnew.PCB_IO_GetLibraryOptions(self, aListToAppendTo)
    __swig_destroy__ = _pcbnew.delete_PCB_IO
 
    def footprintPyEnumerate(self, aLibraryPath, aExitOnError):
        r"""footprintPyEnumerate(PCB_IO self, wxString aLibraryPath, bool aExitOnError) -> wxArrayString"""
        return _pcbnew.PCB_IO_footprintPyEnumerate(self, aLibraryPath, aExitOnError)
 
    def FootprintEnumerate(self, libname):
        return self.footprintPyEnumerate( libname, True )
 
    # Old function name for compatibility with pre-v8 scripts, use CreateLibrary() for new scripts.
    def FootprintLibCreate(self, aLibraryPath, aProperties=None):
        self.CreateLibrary(aLibraryPath, aProperties)
 
    # Old function name for compatibility with pre-v8 scripts, use DeleteLibrary() for new scripts.
    def FootprintLibDelete(self, aLibraryPath, aProperties=None):
        return self.DeleteLibrary(aLibraryPath, aProperties)
 
    # Old function name for compatibility with pre-v8 scripts, use IsLibraryWritable() for new scripts.
    def IsFootprintLibWritable(self, aLibraryPath):
        return self.IsLibraryWritable(aLibraryPath)
 
 
# Register PCB_IO in _pcbnew:
_pcbnew.PCB_IO_swigregister(PCB_IO)
SEXPR_BOARD_FILE_VERSION = _pcbnew.SEXPR_BOARD_FILE_VERSION
 
BOARD_FILE_HOST_VERSION = _pcbnew.BOARD_FILE_HOST_VERSION
 
LEGACY_ARC_FORMATTING = _pcbnew.LEGACY_ARC_FORMATTING
 
LEGACY_NET_TIES = _pcbnew.LEGACY_NET_TIES
 
FIRST_NORMALIZED_VERISON = _pcbnew.FIRST_NORMALIZED_VERISON
 
class FP_CACHE_ENTRY(object):
    r"""Proxy of C++ FP_CACHE_ENTRY 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, aFootprint, aFileName):
        r"""__init__(FP_CACHE_ENTRY self, FOOTPRINT aFootprint, WX_FILENAME const & aFileName) -> FP_CACHE_ENTRY"""
        _pcbnew.FP_CACHE_ENTRY_swiginit(self, _pcbnew.new_FP_CACHE_ENTRY(aFootprint, aFileName))
 
    def GetFileName(self):
        r"""GetFileName(FP_CACHE_ENTRY self) -> WX_FILENAME const &"""
        return _pcbnew.FP_CACHE_ENTRY_GetFileName(self)
 
    def SetFilePath(self, aFilePath):
        r"""SetFilePath(FP_CACHE_ENTRY self, wxString aFilePath)"""
        return _pcbnew.FP_CACHE_ENTRY_SetFilePath(self, aFilePath)
 
    def GetFootprint(self):
        r"""GetFootprint(FP_CACHE_ENTRY self) -> std::unique_ptr< FOOTPRINT > &"""
        return _pcbnew.FP_CACHE_ENTRY_GetFootprint(self)
    __swig_destroy__ = _pcbnew.delete_FP_CACHE_ENTRY
 
# Register FP_CACHE_ENTRY in _pcbnew:
_pcbnew.FP_CACHE_ENTRY_swigregister(FP_CACHE_ENTRY)
class FP_CACHE(object):
    r"""Proxy of C++ FP_CACHE 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, aOwner, aLibraryPath):
        r"""__init__(FP_CACHE self, PCB_IO_KICAD_SEXPR aOwner, wxString aLibraryPath) -> FP_CACHE"""
        _pcbnew.FP_CACHE_swiginit(self, _pcbnew.new_FP_CACHE(aOwner, aLibraryPath))
 
    def GetPath(self):
        r"""GetPath(FP_CACHE self) -> wxString"""
        return _pcbnew.FP_CACHE_GetPath(self)
 
    def IsWritable(self):
        r"""IsWritable(FP_CACHE self) -> bool"""
        return _pcbnew.FP_CACHE_IsWritable(self)
 
    def Exists(self):
        r"""Exists(FP_CACHE self) -> bool"""
        return _pcbnew.FP_CACHE_Exists(self)
 
    def GetFootprints(self):
        r"""GetFootprints(FP_CACHE self) -> boost::ptr_map< wxString,FP_CACHE_ENTRY > &"""
        return _pcbnew.FP_CACHE_GetFootprints(self)
 
    def Save(self, aFootprintFilter=None):
        r"""Save(FP_CACHE self, FOOTPRINT aFootprintFilter=None)"""
        return _pcbnew.FP_CACHE_Save(self, aFootprintFilter)
 
    def Load(self):
        r"""Load(FP_CACHE self)"""
        return _pcbnew.FP_CACHE_Load(self)
 
    def Remove(self, aFootprintName):
        r"""Remove(FP_CACHE self, wxString aFootprintName)"""
        return _pcbnew.FP_CACHE_Remove(self, aFootprintName)
 
    @staticmethod
    def GetTimestamp(aLibPath):
        r"""GetTimestamp(wxString aLibPath) -> long long"""
        return _pcbnew.FP_CACHE_GetTimestamp(aLibPath)
 
    def IsModified(self):
        r"""IsModified(FP_CACHE self) -> bool"""
        return _pcbnew.FP_CACHE_IsModified(self)
 
    def IsPath(self, aPath):
        r"""IsPath(FP_CACHE self, wxString aPath) -> bool"""
        return _pcbnew.FP_CACHE_IsPath(self, aPath)
 
    def SetPath(self, aPath):
        r"""SetPath(FP_CACHE self, wxString aPath)"""
        return _pcbnew.FP_CACHE_SetPath(self, aPath)
    __swig_destroy__ = _pcbnew.delete_FP_CACHE
 
# Register FP_CACHE in _pcbnew:
_pcbnew.FP_CACHE_swigregister(FP_CACHE)
class PCB_IO_KICAD_SEXPR(PCB_IO):
    r"""Proxy of C++ PCB_IO_KICAD_SEXPR class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def GetLibraryFileDesc(self):
        r"""GetLibraryFileDesc(PCB_IO_KICAD_SEXPR self) -> IO_BASE::IO_FILE_DESC const"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_GetLibraryFileDesc(self)
 
    def GetLibraryDesc(self):
        r"""GetLibraryDesc(PCB_IO_KICAD_SEXPR self) -> IO_BASE::IO_FILE_DESC const"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_GetLibraryDesc(self)
 
    def SaveBoard(self, aFileName, aBoard, aProperties=None):
        r"""SaveBoard(PCB_IO_KICAD_SEXPR self, wxString aFileName, BOARD aBoard, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_SaveBoard(self, aFileName, aBoard, aProperties)
 
    def LoadBoard(self, aFileName, aAppendToMe, aProperties=None, aProject=None):
        r"""LoadBoard(PCB_IO_KICAD_SEXPR self, wxString aFileName, BOARD aAppendToMe, str_utf8_Map aProperties=None, PROJECT * aProject=None) -> BOARD"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_LoadBoard(self, aFileName, aAppendToMe, aProperties, aProject)
 
    def DoLoad(self, aReader, aAppendToMe, aProperties, aProgressReporter, aLineCount):
        r"""DoLoad(PCB_IO_KICAD_SEXPR self, LINE_READER aReader, BOARD aAppendToMe, str_utf8_Map aProperties, PROGRESS_REPORTER * aProgressReporter, unsigned int aLineCount) -> BOARD"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_DoLoad(self, aReader, aAppendToMe, aProperties, aProgressReporter, aLineCount)
 
    def FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties=None):
        r"""FootprintEnumerate(PCB_IO_KICAD_SEXPR self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties)
 
    def GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties=None):
        r"""GetEnumeratedFootprint(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, wxString aFootprintName, str_utf8_Map aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties)
 
    def FootprintExists(self, aLibraryPath, aFootprintName, aProperties=None):
        r"""FootprintExists(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, wxString aFootprintName, str_utf8_Map aProperties=None) -> bool"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_FootprintExists(self, aLibraryPath, aFootprintName, aProperties)
 
    def ImportFootprint(self, aFootprintPath, aFootprintNameOut, aProperties=None):
        r"""ImportFootprint(PCB_IO_KICAD_SEXPR self, wxString aFootprintPath, wxString aFootprintNameOut, str_utf8_Map aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_ImportFootprint(self, aFootprintPath, aFootprintNameOut, aProperties)
 
    def FootprintLoad(self, aLibraryPath, aFootprintName, aKeepUUID=False, aProperties=None):
        r"""FootprintLoad(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, wxString aFootprintName, bool aKeepUUID=False, str_utf8_Map aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_FootprintLoad(self, aLibraryPath, aFootprintName, aKeepUUID, aProperties)
 
    def FootprintSave(self, aLibraryPath, aFootprint, aProperties=None):
        r"""FootprintSave(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, FOOTPRINT aFootprint, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_FootprintSave(self, aLibraryPath, aFootprint, aProperties)
 
    def FootprintDelete(self, aLibraryPath, aFootprintName, aProperties=None):
        r"""FootprintDelete(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, wxString aFootprintName, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)
 
    def CreateLibrary(self, aLibraryPath, aProperties=None):
        r"""CreateLibrary(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, str_utf8_Map aProperties=None)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_CreateLibrary(self, aLibraryPath, aProperties)
 
    def DeleteLibrary(self, aLibraryPath, aProperties=None):
        r"""DeleteLibrary(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath, str_utf8_Map aProperties=None) -> bool"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_DeleteLibrary(self, aLibraryPath, aProperties)
 
    def IsLibraryWritable(self, aLibraryPath):
        r"""IsLibraryWritable(PCB_IO_KICAD_SEXPR self, wxString aLibraryPath) -> bool"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_IsLibraryWritable(self, aLibraryPath)
 
    def __init__(self, *args):
        r"""__init__(PCB_IO_KICAD_SEXPR self, int aControlFlags=(CTL_OMIT_INITIAL_COMMENTS|CTL_OMIT_FOOTPRINT_VERSION)) -> PCB_IO_KICAD_SEXPR"""
        _pcbnew.PCB_IO_KICAD_SEXPR_swiginit(self, _pcbnew.new_PCB_IO_KICAD_SEXPR(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_IO_KICAD_SEXPR
 
    def Format(self, aItem):
        r"""Format(PCB_IO_KICAD_SEXPR self, BOARD_ITEM aItem)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_Format(self, aItem)
 
    def GetStringOutput(self, doClear):
        r"""GetStringOutput(PCB_IO_KICAD_SEXPR self, bool doClear) -> string"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_GetStringOutput(self, doClear)
 
    def SetOutputFormatter(self, aFormatter):
        r"""SetOutputFormatter(PCB_IO_KICAD_SEXPR self, OUTPUTFORMATTER aFormatter)"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_SetOutputFormatter(self, aFormatter)
 
    def Parse(self, aClipboardSourceInput):
        r"""Parse(PCB_IO_KICAD_SEXPR self, wxString aClipboardSourceInput) -> BOARD_ITEM"""
        return _pcbnew.PCB_IO_KICAD_SEXPR_Parse(self, aClipboardSourceInput)
 
# Register PCB_IO_KICAD_SEXPR in _pcbnew:
_pcbnew.PCB_IO_KICAD_SEXPR_swigregister(PCB_IO_KICAD_SEXPR)
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, int aLayer)"""
        return _pcbnew.PLOT_CONTROLLER_SetLayer(self, aLayer)
 
    def GetLayer(self):
        r"""GetLayer(PLOT_CONTROLLER self) -> int"""
        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, *args):
        r"""OpenPlotfile(PLOT_CONTROLLER self, wxString aSuffix, PLOT_FORMAT aFormat, wxString aSheetName=wxEmptyString, wxString aSheetPath=wxEmptyString) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_OpenPlotfile(self, *args)
 
    def PlotLayer(self):
        r"""PlotLayer(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_PlotLayer(self)
 
    def PlotLayers(self, aLayerSequence):
        r"""PlotLayers(PLOT_CONTROLLER self, LSEQ aLayerSequence) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_PlotLayers(self, aLayerSequence)
 
    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, aColorMode):
        r"""SetColorMode(PLOT_CONTROLLER self, bool aColorMode)"""
        return _pcbnew.PLOT_CONTROLLER_SetColorMode(self, aColorMode)
 
    def GetColorMode(self):
        r"""GetColorMode(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_GetColorMode(self)
 
    def GetPlotter(self):
        r"""GetPlotter(PLOT_CONTROLLER self) -> PLOTTER"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotter(self)
 
# Register PLOT_CONTROLLER in _pcbnew:
_pcbnew.PLOT_CONTROLLER_swigregister(PLOT_CONTROLLER)
DRILL_MARKS_NO_DRILL_SHAPE = _pcbnew.DRILL_MARKS_NO_DRILL_SHAPE
 
DRILL_MARKS_SMALL_DRILL_SHAPE = _pcbnew.DRILL_MARKS_SMALL_DRILL_SHAPE
 
DRILL_MARKS_FULL_DRILL_SHAPE = _pcbnew.DRILL_MARKS_FULL_DRILL_SHAPE
 
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
 
    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):
        r"""Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER aFormatter)"""
        return _pcbnew.PCB_PLOT_PARAMS_Format(self, aFormatter)
 
    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):
        r"""IsSameAs(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_IsSameAs(self, aPcbPlotParams)
 
    def SetColorSettings(self, aSettings):
        r"""SetColorSettings(PCB_PLOT_PARAMS self, COLOR_SETTINGS * aSettings)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetColorSettings(self, aSettings)
 
    def ColorSettings(self):
        r"""ColorSettings(PCB_PLOT_PARAMS self) -> COLOR_SETTINGS *"""
        return _pcbnew.PCB_PLOT_PARAMS_ColorSettings(self)
 
    def SetTextMode(self, aVal):
        r"""SetTextMode(PCB_PLOT_PARAMS self, PLOT_TEXT_MODE aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetTextMode(self, aVal)
 
    def GetTextMode(self):
        r"""GetTextMode(PCB_PLOT_PARAMS self) -> PLOT_TEXT_MODE"""
        return _pcbnew.PCB_PLOT_PARAMS_GetTextMode(self)
 
    def SetPlotMode(self, aPlotMode):
        r"""SetPlotMode(PCB_PLOT_PARAMS self, OUTLINE_MODE aPlotMode)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotMode(self, aPlotMode)
 
    def GetPlotMode(self):
        r"""GetPlotMode(PCB_PLOT_PARAMS self) -> OUTLINE_MODE"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotMode(self)
 
    def SetPlotPadNumbers(self, aFlag):
        r"""SetPlotPadNumbers(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotPadNumbers(self, aFlag)
 
    def GetPlotPadNumbers(self):
        r"""GetPlotPadNumbers(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotPadNumbers(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_UNITS aUnit)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDXFPlotUnits(self, aUnit)
 
    def GetDXFPlotUnits(self):
        r"""GetDXFPlotUnits(PCB_PLOT_PARAMS self) -> DXF_UNITS"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDXFPlotUnits(self)
 
    def SetDrillMarksType(self, aVal):
        r"""SetDrillMarksType(PCB_PLOT_PARAMS self, DRILL_MARKS aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDrillMarksType(self, aVal)
 
    def GetDrillMarksType(self):
        r"""GetDrillMarksType(PCB_PLOT_PARAMS self) -> DRILL_MARKS"""
        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 SetSketchPadsOnFabLayers(self, aFlag):
        r"""SetSketchPadsOnFabLayers(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSketchPadsOnFabLayers(self, aFlag)
 
    def GetSketchPadsOnFabLayers(self):
        r"""GetSketchPadsOnFabLayers(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSketchPadsOnFabLayers(self)
 
    def SetSketchPadLineWidth(self, aWidth):
        r"""SetSketchPadLineWidth(PCB_PLOT_PARAMS self, int aWidth)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSketchPadLineWidth(self, aWidth)
 
    def GetSketchPadLineWidth(self):
        r"""GetSketchPadLineWidth(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSketchPadLineWidth(self)
 
    def SetHideDNPFPsOnFabLayers(self, aFlag):
        r"""SetHideDNPFPsOnFabLayers(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHideDNPFPsOnFabLayers(self, aFlag)
 
    def GetHideDNPFPsOnFabLayers(self):
        r"""GetHideDNPFPsOnFabLayers(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHideDNPFPsOnFabLayers(self)
 
    def SetSketchDNPFPsOnFabLayers(self, aFlag):
        r"""SetSketchDNPFPsOnFabLayers(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSketchDNPFPsOnFabLayers(self, aFlag)
 
    def GetSketchDNPFPsOnFabLayers(self):
        r"""GetSketchDNPFPsOnFabLayers(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSketchDNPFPsOnFabLayers(self)
 
    def SetCrossoutDNPFPsOnFabLayers(self, aFlag):
        r"""SetCrossoutDNPFPsOnFabLayers(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetCrossoutDNPFPsOnFabLayers(self, aFlag)
 
    def GetCrossoutDNPFPsOnFabLayers(self):
        r"""GetCrossoutDNPFPsOnFabLayers(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetCrossoutDNPFPsOnFabLayers(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 SetPlotFPText(self, aFlag):
        r"""SetPlotFPText(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotFPText(self, aFlag)
 
    def GetPlotFPText(self):
        r"""GetPlotFPText(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotFPText(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 GetLegacyPlotViaOnMaskLayer(self):
        r"""GetLegacyPlotViaOnMaskLayer(PCB_PLOT_PARAMS self) -> std::optional< bool >"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLegacyPlotViaOnMaskLayer(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 SetFormat(self, aFormat):
        r"""SetFormat(PCB_PLOT_PARAMS self, PLOT_FORMAT aFormat)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFormat(self, aFormat)
 
    def GetFormat(self):
        r"""GetFormat(PCB_PLOT_PARAMS self) -> PLOT_FORMAT"""
        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 SetDisableGerberMacros(self, aDisable):
        r"""SetDisableGerberMacros(PCB_PLOT_PARAMS self, bool aDisable)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDisableGerberMacros(self, aDisable)
 
    def GetDisableGerberMacros(self):
        r"""GetDisableGerberMacros(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDisableGerberMacros(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)
 
    def SetSvgPrecision(self, aPrecision):
        r"""SetSvgPrecision(PCB_PLOT_PARAMS self, unsigned int aPrecision)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSvgPrecision(self, aPrecision)
 
    def GetSvgPrecision(self):
        r"""GetSvgPrecision(PCB_PLOT_PARAMS self) -> unsigned int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSvgPrecision(self)
 
    def SetSvgFitPageToBoard(self, aSvgFitPageToBoard):
        r"""SetSvgFitPageToBoard(PCB_PLOT_PARAMS self, int aSvgFitPageToBoard)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSvgFitPageToBoard(self, aSvgFitPageToBoard)
 
    def GetSvgFitPagetoBoard(self):
        r"""GetSvgFitPagetoBoard(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSvgFitPagetoBoard(self)
 
    def SetBlackAndWhite(self, blackAndWhite):
        r"""SetBlackAndWhite(PCB_PLOT_PARAMS self, bool blackAndWhite)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetBlackAndWhite(self, blackAndWhite)
 
    def GetBlackAndWhite(self):
        r"""GetBlackAndWhite(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetBlackAndWhite(self)
 
    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 SetPlotOnAllLayersSequence(self, aSeq):
        r"""SetPlotOnAllLayersSequence(PCB_PLOT_PARAMS self, LSEQ aSeq)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotOnAllLayersSequence(self, aSeq)
 
    def GetPlotOnAllLayersSequence(self):
        r"""GetPlotOnAllLayersSequence(PCB_PLOT_PARAMS self) -> LSEQ"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotOnAllLayersSequence(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 SetDashedLineDashRatio(self, aVal):
        r"""SetDashedLineDashRatio(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDashedLineDashRatio(self, aVal)
 
    def GetDashedLineDashRatio(self):
        r"""GetDashedLineDashRatio(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDashedLineDashRatio(self)
 
    def SetDashedLineGapRatio(self, aVal):
        r"""SetDashedLineGapRatio(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDashedLineGapRatio(self, aVal)
 
    def GetDashedLineGapRatio(self):
        r"""GetDashedLineGapRatio(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDashedLineGapRatio(self)
    m_PDFFrontFPPropertyPopups = property(_pcbnew.PCB_PLOT_PARAMS_m_PDFFrontFPPropertyPopups_get, _pcbnew.PCB_PLOT_PARAMS_m_PDFFrontFPPropertyPopups_set, doc=r"""m_PDFFrontFPPropertyPopups : bool""")
    m_PDFBackFPPropertyPopups = property(_pcbnew.PCB_PLOT_PARAMS_m_PDFBackFPPropertyPopups_get, _pcbnew.PCB_PLOT_PARAMS_m_PDFBackFPPropertyPopups_set, doc=r"""m_PDFBackFPPropertyPopups : bool""")
    m_PDFMetadata = property(_pcbnew.PCB_PLOT_PARAMS_m_PDFMetadata_get, _pcbnew.PCB_PLOT_PARAMS_m_PDFMetadata_set, doc=r"""m_PDFMetadata : bool""")
    m_PDFSingle = property(_pcbnew.PCB_PLOT_PARAMS_m_PDFSingle_get, _pcbnew.PCB_PLOT_PARAMS_m_PDFSingle_set, doc=r"""m_PDFSingle : bool""")
 
        # 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)
DXF_UNITS_INCH = _pcbnew.DXF_UNITS_INCH
 
DXF_UNITS_MM = _pcbnew.DXF_UNITS_MM
 
PLOT_FORMAT_UNDEFINED = _pcbnew.PLOT_FORMAT_UNDEFINED
 
PLOT_FORMAT_FIRST_FORMAT = _pcbnew.PLOT_FORMAT_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_FORMAT_LAST_FORMAT = _pcbnew.PLOT_FORMAT_LAST_FORMAT
 
PLOT_TEXT_MODE_STROKE = _pcbnew.PLOT_TEXT_MODE_STROKE
 
PLOT_TEXT_MODE_NATIVE = _pcbnew.PLOT_TEXT_MODE_NATIVE
 
PLOT_TEXT_MODE_PHANTOM = _pcbnew.PLOT_TEXT_MODE_PHANTOM
 
PLOT_TEXT_MODE_DEFAULT = _pcbnew.PLOT_TEXT_MODE_DEFAULT
 
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) -> PLOT_FORMAT"""
        return _pcbnew.PLOTTER_GetPlotterType(self)
 
    def StartPlot(self, aPageNumber):
        r"""StartPlot(PLOTTER self, wxString aPageNumber) -> bool"""
        return _pcbnew.PLOTTER_StartPlot(self, aPageNumber)
 
    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 SetRenderSettings(self, aSettings):
        r"""SetRenderSettings(PLOTTER self, RENDER_SETTINGS * aSettings)"""
        return _pcbnew.PLOTTER_SetRenderSettings(self, aSettings)
 
    def RenderSettings(self):
        r"""RenderSettings(PLOTTER self) -> RENDER_SETTINGS *"""
        return _pcbnew.PLOTTER_RenderSettings(self)
 
    def SetPageSettings(self, aPageSettings):
        r"""SetPageSettings(PLOTTER self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.PLOTTER_SetPageSettings(self, aPageSettings)
 
    def PageSettings(self):
        r"""PageSettings(PLOTTER self) -> PAGE_INFO &"""
        return _pcbnew.PLOTTER_PageSettings(self)
 
    def SetPlotMirrored(self, aMirror):
        r"""SetPlotMirrored(PLOTTER self, bool aMirror)"""
        return _pcbnew.PLOTTER_SetPlotMirrored(self, aMirror)
 
    def GetPlotMirrored(self):
        r"""GetPlotMirrored(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_GetPlotMirrored(self)
 
    def SetCurrentLineWidth(self, width, aData=None):
        r"""SetCurrentLineWidth(PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.PLOTTER_SetCurrentLineWidth(self, width, aData)
 
    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, aLineWidth, aLineStyle):
        r"""SetDash(PLOTTER self, int aLineWidth, LINE_STYLE aLineStyle)"""
        return _pcbnew.PLOTTER_SetDash(self, aLineWidth, aLineStyle)
 
    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 SetAuthor(self, aAuthor):
        r"""SetAuthor(PLOTTER self, wxString aAuthor)"""
        return _pcbnew.PLOTTER_SetAuthor(self, aAuthor)
 
    def SetSubject(self, aSubject):
        r"""SetSubject(PLOTTER self, wxString aSubject)"""
        return _pcbnew.PLOTTER_SetSubject(self, aSubject)
 
    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, VECTOR2I 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 GetPlotterArcLowDef(self):
        r"""GetPlotterArcLowDef(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetPlotterArcLowDef(self)
 
    def GetPlotterArcHighDef(self):
        r"""GetPlotterArcHighDef(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetPlotterArcHighDef(self)
 
    def Rect(self, *args):
        r"""Rect(PLOTTER self, VECTOR2I p1, VECTOR2I p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_Rect(self, *args)
 
    def Circle(self, *args):
        r"""Circle(PLOTTER self, VECTOR2I 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, VECTOR2D const & aStart, VECTOR2D const & aMid, VECTOR2D const & aEnd, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH)
        Arc(PLOTTER self, VECTOR2D const & aCenter, EDA_ANGLE aStartAngle, EDA_ANGLE aAngle, double aRadius, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH)
        """
        return _pcbnew.PLOTTER_Arc(self, *args)
 
    def BezierCurve(self, *args):
        r"""BezierCurve(PLOTTER self, VECTOR2I aStart, VECTOR2I aControl1, VECTOR2I aControl2, VECTOR2I aEnd, int aTolerance, int aLineThickness=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_BezierCurve(self, *args)
 
    def PenTo(self, pos, plume):
        r"""PenTo(PLOTTER self, VECTOR2I pos, char plume)"""
        return _pcbnew.PLOTTER_PenTo(self, pos, plume)
 
    def MoveTo(self, pos):
        r"""MoveTo(PLOTTER self, VECTOR2I pos)"""
        return _pcbnew.PLOTTER_MoveTo(self, pos)
 
    def LineTo(self, pos):
        r"""LineTo(PLOTTER self, VECTOR2I pos)"""
        return _pcbnew.PLOTTER_LineTo(self, pos)
 
    def FinishTo(self, pos):
        r"""FinishTo(PLOTTER self, VECTOR2I 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, VECTOR_VECTOR2I 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, VECTOR2I aPos, double aScaleFactor)"""
        return _pcbnew.PLOTTER_PlotImage(self, aImage, aPos, aScaleFactor)
 
    def ThickSegment(self, start, end, width, tracemode, aData):
        r"""ThickSegment(PLOTTER self, VECTOR2I start, VECTOR2I end, int width, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickSegment(self, start, end, width, tracemode, aData)
 
    def ThickArc(self, *args):
        r"""
        ThickArc(PLOTTER self, EDA_SHAPE aArcShape, OUTLINE_MODE aTraceMode, void * aData, int aWidth)
        ThickArc(PLOTTER self, VECTOR2D const & aCentre, EDA_ANGLE aStAngle, EDA_ANGLE aAngle, double aRadius, int aWidth, OUTLINE_MODE aTraceMode, void * aData)
        """
        return _pcbnew.PLOTTER_ThickArc(self, *args)
 
    def ThickRect(self, p1, p2, width, tracemode, aData):
        r"""ThickRect(PLOTTER self, VECTOR2I p1, VECTOR2I p2, int width, OUTLINE_MODE 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, VECTOR2I pos, int diametre, int width, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickCircle(self, pos, diametre, width, tracemode, aData)
 
    def FilledCircle(self, pos, diametre, tracemode, aData):
        r"""FilledCircle(PLOTTER self, VECTOR2I pos, int diametre, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_FilledCircle(self, pos, diametre, tracemode, aData)
 
    def FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData):
        r"""FlashPadCircle(PLOTTER self, VECTOR2I aPadPos, int aDiameter, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData)
 
    def FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData):
        r"""FlashPadOval(PLOTTER self, VECTOR2I aPadPos, VECTOR2I aSize, EDA_ANGLE aPadOrient, OUTLINE_MODE 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, VECTOR2I aPadPos, VECTOR2I aSize, EDA_ANGLE aPadOrient, OUTLINE_MODE 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, VECTOR2I aPadPos, VECTOR2I aSize, int aCornerRadius, EDA_ANGLE aOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)
 
    def FlashPadCustom(self, aPadPos, aSize, aPadOrient, aPolygons, aTraceMode, aData):
        r"""FlashPadCustom(PLOTTER self, VECTOR2I aPadPos, VECTOR2I aSize, EDA_ANGLE aPadOrient, SHAPE_POLY_SET aPolygons, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPadOrient, aPolygons, aTraceMode, aData)
 
    def FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData):
        r"""FlashPadTrapez(PLOTTER self, VECTOR2I aPadPos, VECTOR2I aCorners, EDA_ANGLE aPadOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)
 
    def FlashRegularPolygon(self, aShapePos, aDiameter, aCornerCount, aOrient, aTraceMode, aData):
        r"""FlashRegularPolygon(PLOTTER self, VECTOR2I aShapePos, int aDiameter, int aCornerCount, EDA_ANGLE aOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashRegularPolygon(self, aShapePos, aDiameter, aCornerCount, aOrient, aTraceMode, aData)
 
    def Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aPenWidth, aItalic, aBold, aMultilineAllowed, aFont, aFontMetrics, aData=None):
        r"""Text(PLOTTER self, VECTOR2I aPos, COLOR4D aColor, wxString aText, EDA_ANGLE aOrient, VECTOR2I aSize, enum GR_TEXT_H_ALIGN_T aH_justify, enum GR_TEXT_V_ALIGN_T aV_justify, int aPenWidth, bool aItalic, bool aBold, bool aMultilineAllowed, KIFONT::FONT * aFont, KIFONT::METRICS const & aFontMetrics, void * aData=None)"""
        return _pcbnew.PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aPenWidth, aItalic, aBold, aMultilineAllowed, aFont, aFontMetrics, aData)
 
    def PlotText(self, *args):
        r"""PlotText(PLOTTER self, VECTOR2I aPos, COLOR4D aColor, wxString aText, TEXT_ATTRIBUTES aAttributes, KIFONT::FONT * aFont=None, KIFONT::METRICS const & aFontMetrics=KIFONT::METRICS::Default(), void * aData=None)"""
        return _pcbnew.PLOTTER_PlotText(self, *args)
 
    def HyperlinkBox(self, aBox, aDestinationURL):
        r"""HyperlinkBox(PLOTTER self, BOX2I aBox, wxString aDestinationURL)"""
        return _pcbnew.PLOTTER_HyperlinkBox(self, aBox, aDestinationURL)
 
    def HyperlinkMenu(self, aBox, aDestURLs):
        r"""HyperlinkMenu(PLOTTER self, BOX2I aBox, std::vector< wxString,std::allocator< wxString > > const & aDestURLs)"""
        return _pcbnew.PLOTTER_HyperlinkMenu(self, aBox, aDestURLs)
 
    def Bookmark(self, *args):
        r"""Bookmark(PLOTTER self, BOX2I aBox, wxString aName, wxString aGroupName=wxEmptyString)"""
        return _pcbnew.PLOTTER_Bookmark(self, *args)
    MARKER_COUNT = _pcbnew.PLOTTER_MARKER_COUNT
    
 
    def Marker(self, position, diametre, aShapeId):
        r"""Marker(PLOTTER self, VECTOR2I 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, PLOT_TEXT_MODE 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 SetSvgCoordinatesFormat(self, aPrecision):
        r"""SetSvgCoordinatesFormat(PLOTTER self, unsigned int aPrecision)"""
        return _pcbnew.PLOTTER_SetSvgCoordinatesFormat(self, aPrecision)
 
    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)
 
    def GetPlotOffsetUserUnits(self):
        r"""GetPlotOffsetUserUnits(PLOTTER self) -> VECTOR2I"""
        return _pcbnew.PLOTTER_GetPlotOffsetUserUnits(self)
 
# Register PLOTTER in _pcbnew:
_pcbnew.PLOTTER_swigregister(PLOTTER)
 
def PlotDrawingSheet(*args):
    r"""PlotDrawingSheet(PLOTTER plotter, PROJECT const * aProject, TITLE_BLOCK aTitleBlock, PAGE_INFO const & aPageInfo, MAP_STRING_STRING aProperties, wxString aSheetNumber, int aSheetCount, wxString aSheetName, wxString aSheetPath, wxString aFilename, COLOR4D aColor=UNSPECIFIED, bool aIsFirstPage=True)"""
    return _pcbnew.PlotDrawingSheet(*args)
 
def GetDefaultPlotExtension(aFormat):
    r"""GetDefaultPlotExtension(PLOT_FORMAT aFormat) -> wxString"""
    return _pcbnew.GetDefaultPlotExtension(aFormat)
class D356_RECORD(object):
    r"""Proxy of C++ D356_RECORD class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    smd = property(_pcbnew.D356_RECORD_smd_get, _pcbnew.D356_RECORD_smd_set, doc=r"""smd : bool""")
    hole = property(_pcbnew.D356_RECORD_hole_get, _pcbnew.D356_RECORD_hole_set, doc=r"""hole : bool""")
    netname = property(_pcbnew.D356_RECORD_netname_get, _pcbnew.D356_RECORD_netname_set, doc=r"""netname : wxString""")
    refdes = property(_pcbnew.D356_RECORD_refdes_get, _pcbnew.D356_RECORD_refdes_set, doc=r"""refdes : wxString""")
    pin = property(_pcbnew.D356_RECORD_pin_get, _pcbnew.D356_RECORD_pin_set, doc=r"""pin : wxString""")
    midpoint = property(_pcbnew.D356_RECORD_midpoint_get, _pcbnew.D356_RECORD_midpoint_set, doc=r"""midpoint : bool""")
    drill = property(_pcbnew.D356_RECORD_drill_get, _pcbnew.D356_RECORD_drill_set, doc=r"""drill : int""")
    mechanical = property(_pcbnew.D356_RECORD_mechanical_get, _pcbnew.D356_RECORD_mechanical_set, doc=r"""mechanical : bool""")
    access = property(_pcbnew.D356_RECORD_access_get, _pcbnew.D356_RECORD_access_set, doc=r"""access : int""")
    soldermask = property(_pcbnew.D356_RECORD_soldermask_get, _pcbnew.D356_RECORD_soldermask_set, doc=r"""soldermask : int""")
    x_location = property(_pcbnew.D356_RECORD_x_location_get, _pcbnew.D356_RECORD_x_location_set, doc=r"""x_location : int""")
    y_location = property(_pcbnew.D356_RECORD_y_location_get, _pcbnew.D356_RECORD_y_location_set, doc=r"""y_location : int""")
    x_size = property(_pcbnew.D356_RECORD_x_size_get, _pcbnew.D356_RECORD_x_size_set, doc=r"""x_size : int""")
    y_size = property(_pcbnew.D356_RECORD_y_size_get, _pcbnew.D356_RECORD_y_size_set, doc=r"""y_size : int""")
    rotation = property(_pcbnew.D356_RECORD_rotation_get, _pcbnew.D356_RECORD_rotation_set, doc=r"""rotation : int""")
 
    def __init__(self):
        r"""__init__(D356_RECORD self) -> D356_RECORD"""
        _pcbnew.D356_RECORD_swiginit(self, _pcbnew.new_D356_RECORD())
    __swig_destroy__ = _pcbnew.delete_D356_RECORD
 
# Register D356_RECORD in _pcbnew:
_pcbnew.D356_RECORD_swigregister(D356_RECORD)
class IPC356D_WRITER(object):
    r"""Proxy of C++ IPC356D_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__(IPC356D_WRITER self, BOARD aPcb) -> IPC356D_WRITER"""
        _pcbnew.IPC356D_WRITER_swiginit(self, _pcbnew.new_IPC356D_WRITER(aPcb))
    __swig_destroy__ = _pcbnew.delete_IPC356D_WRITER
 
    def Write(self, aFilename):
        r"""Write(IPC356D_WRITER self, wxString aFilename) -> bool"""
        return _pcbnew.IPC356D_WRITER_Write(self, aFilename)
 
# Register IPC356D_WRITER in _pcbnew:
_pcbnew.IPC356D_WRITER_swigregister(IPC356D_WRITER)
class PLACE_FILE_EXPORTER(object):
    r"""Proxy of C++ PLACE_FILE_EXPORTER 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, aUnitsMM, aOnlySMD, aExcludeAllTH, aExcludeDNP, aTopSide, aBottomSide, aFormatCSV, aUseAuxOrigin, aNegateBottomX):
        r"""__init__(PLACE_FILE_EXPORTER self, BOARD aBoard, bool aUnitsMM, bool aOnlySMD, bool aExcludeAllTH, bool aExcludeDNP, bool aTopSide, bool aBottomSide, bool aFormatCSV, bool aUseAuxOrigin, bool aNegateBottomX) -> PLACE_FILE_EXPORTER"""
        _pcbnew.PLACE_FILE_EXPORTER_swiginit(self, _pcbnew.new_PLACE_FILE_EXPORTER(aBoard, aUnitsMM, aOnlySMD, aExcludeAllTH, aExcludeDNP, aTopSide, aBottomSide, aFormatCSV, aUseAuxOrigin, aNegateBottomX))
 
    def GenPositionData(self):
        r"""GenPositionData(PLACE_FILE_EXPORTER self) -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GenPositionData(self)
 
    def GenReportData(self):
        r"""GenReportData(PLACE_FILE_EXPORTER self) -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GenReportData(self)
 
    def GetFootprintCount(self):
        r"""GetFootprintCount(PLACE_FILE_EXPORTER self) -> int"""
        return _pcbnew.PLACE_FILE_EXPORTER_GetFootprintCount(self)
 
    @staticmethod
    def GetFrontSideName():
        r"""GetFrontSideName() -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GetFrontSideName()
 
    @staticmethod
    def GetBackSideName():
        r"""GetBackSideName() -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GetBackSideName()
 
    @staticmethod
    def DecorateFilename(aBaseName, aFront, aBack):
        r"""DecorateFilename(wxString aBaseName, bool aFront, bool aBack) -> wxString"""
        return _pcbnew.PLACE_FILE_EXPORTER_DecorateFilename(aBaseName, aFront, aBack)
    __swig_destroy__ = _pcbnew.delete_PLACE_FILE_EXPORTER
 
# Register PLACE_FILE_EXPORTER in _pcbnew:
_pcbnew.PLACE_FILE_EXPORTER_swigregister(PLACE_FILE_EXPORTER)
class EXPORTER_VRML(object):
    r"""Proxy of C++ EXPORTER_VRML 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__(EXPORTER_VRML self, BOARD aBoard) -> EXPORTER_VRML"""
        _pcbnew.EXPORTER_VRML_swiginit(self, _pcbnew.new_EXPORTER_VRML(aBoard))
    __swig_destroy__ = _pcbnew.delete_EXPORTER_VRML
 
    def ExportVRML_File(self, aProject, aMessages, aFullFileName, aMMtoWRMLunit, aIncludeUnspecified, aIncludeDNP, aExport3DFiles, aUseRelativePaths, a3D_Subdir, aXRef, aYRef):
        r"""ExportVRML_File(EXPORTER_VRML self, PROJECT * aProject, wxString aMessages, wxString aFullFileName, double aMMtoWRMLunit, bool aIncludeUnspecified, bool aIncludeDNP, bool aExport3DFiles, bool aUseRelativePaths, wxString a3D_Subdir, double aXRef, double aYRef) -> bool"""
        return _pcbnew.EXPORTER_VRML_ExportVRML_File(self, aProject, aMessages, aFullFileName, aMMtoWRMLunit, aIncludeUnspecified, aIncludeDNP, aExport3DFiles, aUseRelativePaths, a3D_Subdir, aXRef, aYRef)
 
# Register EXPORTER_VRML in _pcbnew:
_pcbnew.EXPORTER_VRML_swigregister(EXPORTER_VRML)
USE_ATTRIB_FOR_HOLES = _pcbnew.USE_ATTRIB_FOR_HOLES
 
HOLE_ATTRIBUTE_HOLE_UNKNOWN = _pcbnew.HOLE_ATTRIBUTE_HOLE_UNKNOWN
 
HOLE_ATTRIBUTE_HOLE_VIA_THROUGH = _pcbnew.HOLE_ATTRIBUTE_HOLE_VIA_THROUGH
 
HOLE_ATTRIBUTE_HOLE_VIA_BURIED = _pcbnew.HOLE_ATTRIBUTE_HOLE_VIA_BURIED
 
HOLE_ATTRIBUTE_HOLE_PAD = _pcbnew.HOLE_ATTRIBUTE_HOLE_PAD
 
HOLE_ATTRIBUTE_HOLE_MECHANICAL = _pcbnew.HOLE_ATTRIBUTE_HOLE_MECHANICAL
 
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""")
    m_HoleAttribute = property(_pcbnew.DRILL_TOOL_m_HoleAttribute_get, _pcbnew.DRILL_TOOL_m_HoleAttribute_set, doc=r"""m_HoleAttribute : HOLE_ATTRIBUTE""")
 
    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
 
    def __init__(self):
        r"""__init__(HOLE_INFO self) -> HOLE_INFO"""
        _pcbnew.HOLE_INFO_swiginit(self, _pcbnew.new_HOLE_INFO())
    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 : VECTOR2I""")
    m_Hole_Orient = property(_pcbnew.HOLE_INFO_m_Hole_Orient_get, _pcbnew.HOLE_INFO_m_Hole_Orient_set, doc=r"""m_Hole_Orient : EDA_ANGLE""")
    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 : VECTOR2I""")
    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""")
    m_HoleAttribute = property(_pcbnew.HOLE_INFO_m_HoleAttribute_get, _pcbnew.HOLE_INFO_m_HoleAttribute_set, doc=r"""m_HoleAttribute : HOLE_ATTRIBUTE""")
    __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
 
    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)
    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""")
    __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
    
    PTH_FILE = _pcbnew.GENDRILL_WRITER_BASE_PTH_FILE
    
    NPTH_FILE = _pcbnew.GENDRILL_WRITER_BASE_NPTH_FILE
    
    MIXED_FILE = _pcbnew.GENDRILL_WRITER_BASE_MIXED_FILE
    
    __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) -> VECTOR2I"""
        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, PLOT_FORMAT 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) -> bool"""
        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)
 
    def GetDrillFileExt(self):
        r"""GetDrillFileExt(GENDRILL_WRITER_BASE self) -> wxString"""
        return _pcbnew.GENDRILL_WRITER_BASE_GetDrillFileExt(self)
 
# 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) -> VECTOR2I"""
        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, VECTOR2I 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) -> bool"""
        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, VECTOR2I 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) -> bool"""
        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_LOAD_FILE = _pcbnew.ID_LOAD_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_FILE = _pcbnew.ID_FILE
 
ID_FILE1 = _pcbnew.ID_FILE1
 
ID_FILEMAX = _pcbnew.ID_FILEMAX
 
ID_FILE_LIST_EMPTY = _pcbnew.ID_FILE_LIST_EMPTY
 
ID_FILE_LIST_CLEAR = _pcbnew.ID_FILE_LIST_CLEAR
 
ID_PREFERENCES_RESET_PANEL = _pcbnew.ID_PREFERENCES_RESET_PANEL
 
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_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_LANGUAGE_CHOICE = _pcbnew.ID_LANGUAGE_CHOICE
 
ID_LANGUAGE_DANISH = _pcbnew.ID_LANGUAGE_DANISH
 
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_HEBREW = _pcbnew.ID_LANGUAGE_HEBREW
 
ID_LANGUAGE_SPANISH = _pcbnew.ID_LANGUAGE_SPANISH
 
ID_LANGUAGE_SPANISH_MEXICAN = _pcbnew.ID_LANGUAGE_SPANISH_MEXICAN
 
ID_LANGUAGE_GERMAN = _pcbnew.ID_LANGUAGE_GERMAN
 
ID_LANGUAGE_GREEK = _pcbnew.ID_LANGUAGE_GREEK
 
ID_LANGUAGE_NORWEGIAN = _pcbnew.ID_LANGUAGE_NORWEGIAN
 
ID_LANGUAGE_RUSSIAN = _pcbnew.ID_LANGUAGE_RUSSIAN
 
ID_LANGUAGE_PORTUGUESE = _pcbnew.ID_LANGUAGE_PORTUGUESE
 
ID_LANGUAGE_PORTUGUESE_BRAZILIAN = _pcbnew.ID_LANGUAGE_PORTUGUESE_BRAZILIAN
 
ID_LANGUAGE_TURKISH = _pcbnew.ID_LANGUAGE_TURKISH
 
ID_LANGUAGE_INDONESIAN = _pcbnew.ID_LANGUAGE_INDONESIAN
 
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_LATVIAN = _pcbnew.ID_LANGUAGE_LATVIAN
 
ID_LANGUAGE_LITHUANIAN = _pcbnew.ID_LANGUAGE_LITHUANIAN
 
ID_LANGUAGE_VIETNAMESE = _pcbnew.ID_LANGUAGE_VIETNAMESE
 
ID_LANGUAGE_SERBIAN = _pcbnew.ID_LANGUAGE_SERBIAN
 
ID_LANGUAGE_THAI = _pcbnew.ID_LANGUAGE_THAI
 
ID_LANGUAGE_SWEDISH = _pcbnew.ID_LANGUAGE_SWEDISH
 
ID_LANGUAGE_UKRANIAN = _pcbnew.ID_LANGUAGE_UKRANIAN
 
ID_LANGUAGE_CHOICE_END = _pcbnew.ID_LANGUAGE_CHOICE_END
 
ID_ON_ZOOM_SELECT = _pcbnew.ID_ON_ZOOM_SELECT
 
ID_ON_GRID_SELECT = _pcbnew.ID_ON_GRID_SELECT
 
ID_POPUP_ZOOM_LEVEL_START = _pcbnew.ID_POPUP_ZOOM_LEVEL_START
 
ID_POPUP_ZOOM_LEVEL_END = _pcbnew.ID_POPUP_ZOOM_LEVEL_END
 
ID_POPUP_GRID_START = _pcbnew.ID_POPUP_GRID_START
 
ID_POPUP_GRID_END = _pcbnew.ID_POPUP_GRID_END
 
ID_EDA_SOCKET_EVENT_SERV = _pcbnew.ID_EDA_SOCKET_EVENT_SERV
 
ID_EDA_SOCKET_EVENT = _pcbnew.ID_EDA_SOCKET_EVENT
 
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_POPUP_MENU_START = _pcbnew.ID_POPUP_MENU_START
 
ID_POPUP_MENU_END = _pcbnew.ID_POPUP_MENU_END
 
ID_END_LIST = _pcbnew.ID_END_LIST
 
 
def GetBoard():
    r"""GetBoard() -> BOARD"""
    return _pcbnew.GetBoard()
 
def LoadBoard(*args):
    r"""
    LoadBoard(wxString aFileName, PCB_IO_MGR::PCB_FILE_T aFormat) -> BOARD
    LoadBoard(wxString aFileName) -> BOARD
    """
    return _pcbnew.LoadBoard(*args)
 
def NewBoard(aFileName):
    r"""NewBoard(wxString aFileName) -> BOARD"""
    return _pcbnew.NewBoard(aFileName)
 
def GetSettingsManager():
    r"""GetSettingsManager() -> SETTINGS_MANAGER"""
    return _pcbnew.GetSettingsManager()
 
def CreateEmptyBoard():
    r"""CreateEmptyBoard() -> BOARD"""
    return _pcbnew.CreateEmptyBoard()
 
def SaveBoard(aFileName, aBoard, aSkipSettings=False):
    r"""SaveBoard(wxString aFileName, BOARD aBoard, bool aSkipSettings=False) -> bool"""
    return _pcbnew.SaveBoard(aFileName, aBoard, aSkipSettings)
 
def GetFootprintLibraries():
    r"""GetFootprintLibraries() -> wxArrayString"""
    return _pcbnew.GetFootprintLibraries()
 
def GetFootprints(aNickName):
    r"""GetFootprints(wxString aNickName) -> wxArrayString"""
    return _pcbnew.GetFootprints(aNickName)
 
def ExportSpecctraDSN(*args):
    r"""
    ExportSpecctraDSN(wxString aFullFilename) -> bool
    ExportSpecctraDSN(BOARD aBoard, wxString aFullFilename) -> bool
    """
    return _pcbnew.ExportSpecctraDSN(*args)
 
def ExportVRML(aFullFileName, aMMtoWRMLunit, aIncludeUnspecified, aIncludeDNP, aExport3DFiles, aUseRelativePaths, a3D_Subdir, aXRef, aYRef):
    r"""ExportVRML(wxString aFullFileName, double aMMtoWRMLunit, bool aIncludeUnspecified, bool aIncludeDNP, bool aExport3DFiles, bool aUseRelativePaths, wxString a3D_Subdir, double aXRef, double aYRef) -> bool"""
    return _pcbnew.ExportVRML(aFullFileName, aMMtoWRMLunit, aIncludeUnspecified, aIncludeDNP, aExport3DFiles, aUseRelativePaths, a3D_Subdir, aXRef, aYRef)
 
def ImportSpecctraSES(*args):
    r"""
    ImportSpecctraSES(wxString aFullFilename) -> bool
    ImportSpecctraSES(BOARD aBoard, wxString aFullFilename) -> bool
    """
    return _pcbnew.ImportSpecctraSES(*args)
 
def ExportFootprintsToLibrary(*args):
    r"""ExportFootprintsToLibrary(bool aStoreInNewLib, wxString aLibName=wxEmptyString, wxString aLibPath=None) -> bool"""
    return _pcbnew.ExportFootprintsToLibrary(*args)
 
def Refresh():
    r"""Refresh()"""
    return _pcbnew.Refresh()
 
def UpdateUserInterface():
    r"""UpdateUserInterface()"""
    return _pcbnew.UpdateUserInterface()
 
def GetUserUnits():
    r"""GetUserUnits() -> int"""
    return _pcbnew.GetUserUnits()
 
def GetCurrentSelection():
    r"""GetCurrentSelection() -> DRAWINGS"""
    return _pcbnew.GetCurrentSelection()
 
def FocusOnItem(aItem, aLayer=UNDEFINED_LAYER):
    r"""FocusOnItem(BOARD_ITEM aItem, PCB_LAYER_ID aLayer=UNDEFINED_LAYER)"""
    return _pcbnew.FocusOnItem(aItem, aLayer)
 
def IsActionRunning():
    r"""IsActionRunning() -> bool"""
    return _pcbnew.IsActionRunning()
 
def WriteDRCReport(aBoard, aFileName, aUnits, aReportAllTrackErrors):
    r"""WriteDRCReport(BOARD aBoard, wxString aFileName, EDA_UNITS aUnits, bool aReportAllTrackErrors) -> bool"""
    return _pcbnew.WriteDRCReport(aBoard, aFileName, aUnits, aReportAllTrackErrors)
 
def GetLanguage():
    r"""GetLanguage() -> wxString"""
    return _pcbnew.GetLanguage()
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, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.base_seqVect___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(base_seqVect self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, base_seqVect v)
        __setitem__(base_seqVect self, SWIGPY_SLICEOBJECT * 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)
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, *args):
        r"""
        __init__(LSEQ self) -> LSEQ
        __init__(LSEQ self, std::initializer_list< PCB_LAYER_ID > aLayers) -> LSEQ
        """
        _pcbnew.LSEQ_swiginit(self, _pcbnew.new_LSEQ(*args))
 
    def TestLayers(self, aRhs, aLhs):
        r"""TestLayers(LSEQ self, PCB_LAYER_ID aRhs, PCB_LAYER_ID aLhs) -> int"""
        return _pcbnew.LSEQ_TestLayers(self, aRhs, aLhs)
    __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, std::initializer_list< PCB_LAYER_ID > aList) -> LSET
        __init__(LSET self, base_seqVect aList) -> LSET
        __init__(LSET self, LSEQ aSeq) -> LSET
        __init__(LSET self, LAYER_RANGE const & aRange) -> LSET
        """
        _pcbnew.LSET_swiginit(self, _pcbnew.new_LSET(*args))
 
    def Contains(self, aLayer):
        r"""Contains(LSET self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.LSET_Contains(self, aLayer)
 
    @staticmethod
    def Name(aLayerId):
        r"""Name(PCB_LAYER_ID aLayerId) -> wxString"""
        return _pcbnew.LSET_Name(aLayerId)
 
    @staticmethod
    def NameToLayer(aName):
        r"""NameToLayer(wxString aName) -> int"""
        return _pcbnew.LSET_NameToLayer(aName)
 
    @staticmethod
    def IsBetween(aStart, aEnd, aLayer):
        r"""IsBetween(PCB_LAYER_ID aStart, PCB_LAYER_ID aEnd, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.LSET_IsBetween(aStart, aEnd, aLayer)
 
    @staticmethod
    def InternalCuMask():
        r"""InternalCuMask() -> LSET"""
        return _pcbnew.LSET_InternalCuMask()
 
    @staticmethod
    def FrontAssembly():
        r"""FrontAssembly() -> LSET"""
        return _pcbnew.LSET_FrontAssembly()
 
    @staticmethod
    def BackAssembly():
        r"""BackAssembly() -> LSET"""
        return _pcbnew.LSET_BackAssembly()
 
    @staticmethod
    def AllCuMask(*args):
        r"""
        AllCuMask(int aCuLayerCount) -> LSET
        AllCuMask() -> 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 SideSpecificMask():
        r"""SideSpecificMask() -> LSET"""
        return _pcbnew.LSET_SideSpecificMask()
 
    @staticmethod
    def UserMask():
        r"""UserMask() -> LSET"""
        return _pcbnew.LSET_UserMask()
 
    @staticmethod
    def PhysicalLayersMask():
        r"""PhysicalLayersMask() -> LSET"""
        return _pcbnew.LSET_PhysicalLayersMask()
 
    @staticmethod
    def UserDefinedLayersMask(aUserDefinedLayerCount=45):
        r"""UserDefinedLayersMask(int aUserDefinedLayerCount=45) -> LSET"""
        return _pcbnew.LSET_UserDefinedLayersMask(aUserDefinedLayerCount)
 
    @staticmethod
    def ForbiddenFootprintLayers():
        r"""ForbiddenFootprintLayers() -> LSET"""
        return _pcbnew.LSET_ForbiddenFootprintLayers()
 
    def CuStack(self):
        r"""CuStack(LSET self) -> LSEQ"""
        return _pcbnew.LSET_CuStack(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, LSEQ aSequence) -> LSEQ
        Seq(LSET self) -> LSEQ
        """
        return _pcbnew.LSET_Seq(self, *args)
 
    def SeqStackupTop2Bottom(self, aSelectedLayer=UNDEFINED_LAYER):
        r"""SeqStackupTop2Bottom(LSET self, PCB_LAYER_ID aSelectedLayer=UNDEFINED_LAYER) -> LSEQ"""
        return _pcbnew.LSET_SeqStackupTop2Bottom(self, aSelectedLayer)
 
    def SeqStackupForPlotting(self):
        r"""SeqStackupForPlotting(LSET self) -> LSEQ"""
        return _pcbnew.LSET_SeqStackupForPlotting(self)
 
    def RunOnLayers(self, aFunction):
        r"""RunOnLayers(LSET self, std::function< void (PCB_LAYER_ID) > const & aFunction)"""
        return _pcbnew.LSET_RunOnLayers(self, aFunction)
 
    def ExtractLayer(self):
        r"""ExtractLayer(LSET self) -> PCB_LAYER_ID"""
        return _pcbnew.LSET_ExtractLayer(self)
 
    def FlipStandardLayers(self, aCopperLayersCount=0):
        r"""FlipStandardLayers(LSET self, int aCopperLayersCount=0) -> LSET"""
        return _pcbnew.LSET_FlipStandardLayers(self, aCopperLayersCount)
 
    @staticmethod
    def LayerCount(aStart, aEnd, aCopperLayerCount):
        r"""LayerCount(PCB_LAYER_ID aStart, PCB_LAYER_ID aEnd, int aCopperLayerCount) -> int"""
        return _pcbnew.LSET_LayerCount(aStart, aEnd, aCopperLayerCount)
 
    def ClearCopperLayers(self):
        r"""ClearCopperLayers(LSET self) -> LSET"""
        return _pcbnew.LSET_ClearCopperLayers(self)
 
    def ClearNonCopperLayers(self):
        r"""ClearNonCopperLayers(LSET self) -> LSET"""
        return _pcbnew.LSET_ClearNonCopperLayers(self)
 
    def ClearUserDefinedLayers(self):
        r"""ClearUserDefinedLayers(LSET self) -> LSET"""
        return _pcbnew.LSET_ClearUserDefinedLayers(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 FmtHex(self):
        r"""FmtHex(LSET self) -> string"""
        return _pcbnew.LSET_FmtHex(self)
 
    def FmtBin(self):
        r"""FmtBin(LSET self) -> string"""
        return _pcbnew.LSET_FmtBin(self)
 
    def ParseHex(self, aString):
        r"""ParseHex(LSET self, string aString) -> int"""
        return _pcbnew.LSET_ParseHex(self, aString)
 
    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)
ZLO_NONE = _pcbnew.ZLO_NONE
 
ZLO_FORCE_FLASHED = _pcbnew.ZLO_FORCE_FLASHED
 
ZLO_FORCE_NO_ZONE_CONNECTION = _pcbnew.ZLO_FORCE_NO_ZONE_CONNECTION
 
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
    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM
 
    def CopyFrom(self, aOther):
        r"""CopyFrom(BOARD_ITEM self, BOARD_ITEM aOther)"""
        return _pcbnew.BOARD_ITEM_CopyFrom(self, aOther)
 
    def SetParentGroup(self, aGroup):
        r"""SetParentGroup(BOARD_ITEM self, PCB_GROUP aGroup)"""
        return _pcbnew.BOARD_ITEM_SetParentGroup(self, aGroup)
 
    def GetParentGroup(self):
        r"""GetParentGroup(BOARD_ITEM self) -> PCB_GROUP"""
        return _pcbnew.BOARD_ITEM_GetParentGroup(self)
 
    def GetX(self):
        r"""GetX(BOARD_ITEM self) -> int"""
        return _pcbnew.BOARD_ITEM_GetX(self)
 
    def GetY(self):
        r"""GetY(BOARD_ITEM self) -> int"""
        return _pcbnew.BOARD_ITEM_GetY(self)
 
    def GetCenter(self):
        r"""GetCenter(BOARD_ITEM self) -> VECTOR2I"""
        return _pcbnew.BOARD_ITEM_GetCenter(self)
 
    def SetX(self, aX):
        r"""SetX(BOARD_ITEM self, int aX)"""
        return _pcbnew.BOARD_ITEM_SetX(self, aX)
 
    def SetY(self, aY):
        r"""SetY(BOARD_ITEM self, int aY)"""
        return _pcbnew.BOARD_ITEM_SetY(self, aY)
 
    def IsConnected(self):
        r"""IsConnected(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsConnected(self)
 
    def Similarity(self, aItem):
        r"""Similarity(BOARD_ITEM self, BOARD_ITEM aItem) -> double"""
        return _pcbnew.BOARD_ITEM_Similarity(self, aItem)
 
    def __eq__(self, aItem):
        r"""__eq__(BOARD_ITEM self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_ITEM___eq__(self, aItem)
 
    def IsOnCopperLayer(self):
        r"""IsOnCopperLayer(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsOnCopperLayer(self)
 
    def HasHole(self):
        r"""HasHole(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_HasHole(self)
 
    def HasDrilledHole(self):
        r"""HasDrilledHole(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_HasDrilledHole(self)
 
    def IsTented(self, aLayer):
        r"""IsTented(BOARD_ITEM self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_ITEM_IsTented(self, aLayer)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(BOARD_ITEM self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.BOARD_ITEM_GetEffectiveShape(self, *args)
 
    def GetEffectiveHoleShape(self):
        r"""GetEffectiveHoleShape(BOARD_ITEM self) -> std::shared_ptr< SHAPE_SEGMENT >"""
        return _pcbnew.BOARD_ITEM_GetEffectiveHoleShape(self)
 
    def RunOnChildren(self, aFunction):
        r"""RunOnChildren(BOARD_ITEM self, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.BOARD_ITEM_RunOnChildren(self, aFunction)
 
    def RunOnDescendants(self, aFunction, aDepth=0):
        r"""RunOnDescendants(BOARD_ITEM self, std::function< void (BOARD_ITEM *) > const & aFunction, int aDepth=0)"""
        return _pcbnew.BOARD_ITEM_RunOnDescendants(self, aFunction, aDepth)
 
    def GetParent(self):
        r"""GetParent(BOARD_ITEM self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.BOARD_ITEM_GetParent(self)
 
    def GetParentFootprint(self):
        r"""GetParentFootprint(BOARD_ITEM self) -> FOOTPRINT"""
        return _pcbnew.BOARD_ITEM_GetParentFootprint(self)
 
    def GetFPRelativePosition(self):
        r"""GetFPRelativePosition(BOARD_ITEM self) -> VECTOR2I"""
        return _pcbnew.BOARD_ITEM_GetFPRelativePosition(self)
 
    def SetFPRelativePosition(self, aPos):
        r"""SetFPRelativePosition(BOARD_ITEM self, VECTOR2I aPos)"""
        return _pcbnew.BOARD_ITEM_SetFPRelativePosition(self, aPos)
 
    def HasLineStroke(self):
        r"""HasLineStroke(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_HasLineStroke(self)
 
    def GetStroke(self):
        r"""GetStroke(BOARD_ITEM self) -> STROKE_PARAMS"""
        return _pcbnew.BOARD_ITEM_GetStroke(self)
 
    def SetStroke(self, aStroke):
        r"""SetStroke(BOARD_ITEM self, STROKE_PARAMS const & aStroke)"""
        return _pcbnew.BOARD_ITEM_SetStroke(self, aStroke)
 
    def GetFontMetrics(self):
        r"""GetFontMetrics(BOARD_ITEM self) -> KIFONT::METRICS const &"""
        return _pcbnew.BOARD_ITEM_GetFontMetrics(self)
 
    def GetLayer(self):
        r"""GetLayer(BOARD_ITEM self) -> PCB_LAYER_ID"""
        return _pcbnew.BOARD_ITEM_GetLayer(self)
 
    def BoardLayerCount(self):
        r"""BoardLayerCount(BOARD_ITEM self) -> int"""
        return _pcbnew.BOARD_ITEM_BoardLayerCount(self)
 
    def BoardCopperLayerCount(self):
        r"""BoardCopperLayerCount(BOARD_ITEM self) -> int"""
        return _pcbnew.BOARD_ITEM_BoardCopperLayerCount(self)
 
    def BoardLayerSet(self):
        r"""BoardLayerSet(BOARD_ITEM self) -> LSET"""
        return _pcbnew.BOARD_ITEM_BoardLayerSet(self)
 
    def GetLayerSet(self):
        r"""GetLayerSet(BOARD_ITEM self) -> LSET"""
        return _pcbnew.BOARD_ITEM_GetLayerSet(self)
 
    def SetLayerSet(self, aLayers):
        r"""SetLayerSet(BOARD_ITEM self, LSET aLayers)"""
        return _pcbnew.BOARD_ITEM_SetLayerSet(self, aLayers)
 
    def IsSideSpecific(self):
        r"""IsSideSpecific(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsSideSpecific(self)
 
    def SetLayer(self, aLayer):
        r"""SetLayer(BOARD_ITEM self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.BOARD_ITEM_SetLayer(self, aLayer)
 
    def Duplicate(self):
        r"""Duplicate(BOARD_ITEM self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_Duplicate(self)
 
    def SwapItemData(self, aImage):
        r"""SwapItemData(BOARD_ITEM self, BOARD_ITEM aImage)"""
        return _pcbnew.BOARD_ITEM_SwapItemData(self, aImage)
 
    def IsOnLayer(self, aLayer):
        r"""IsOnLayer(BOARD_ITEM self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_ITEM_IsOnLayer(self, aLayer)
 
    def IsKnockout(self):
        r"""IsKnockout(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsKnockout(self)
 
    def SetIsKnockout(self, aKnockout):
        r"""SetIsKnockout(BOARD_ITEM self, bool aKnockout)"""
        return _pcbnew.BOARD_ITEM_SetIsKnockout(self, aKnockout)
 
    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 StyleFromSettings(self, settings):
        r"""StyleFromSettings(BOARD_ITEM self, BOARD_DESIGN_SETTINGS settings)"""
        return _pcbnew.BOARD_ITEM_StyleFromSettings(self, settings)
 
    def DeleteStructure(self):
        r"""DeleteStructure(BOARD_ITEM self)"""
        return _pcbnew.BOARD_ITEM_DeleteStructure(self)
 
    def Move(self, aMoveVector):
        r"""Move(BOARD_ITEM self, VECTOR2I aMoveVector)"""
        return _pcbnew.BOARD_ITEM_Move(self, aMoveVector)
 
    def Rotate(self, aRotCentre, aAngle):
        r"""Rotate(BOARD_ITEM self, VECTOR2I aRotCentre, EDA_ANGLE aAngle)"""
        return _pcbnew.BOARD_ITEM_Rotate(self, aRotCentre, aAngle)
 
    def Flip(self, aCentre, aFlipDirection):
        r"""Flip(BOARD_ITEM self, VECTOR2I aCentre, FLIP_DIRECTION aFlipDirection)"""
        return _pcbnew.BOARD_ITEM_Flip(self, aCentre, aFlipDirection)
 
    def Mirror(self, aCentre, aFlipDirection):
        r"""Mirror(BOARD_ITEM self, VECTOR2I aCentre, FLIP_DIRECTION aFlipDirection)"""
        return _pcbnew.BOARD_ITEM_Mirror(self, aCentre, aFlipDirection)
 
    def Normalize(self):
        r"""Normalize(BOARD_ITEM self)"""
        return _pcbnew.BOARD_ITEM_Normalize(self)
 
    def NormalizeForCompare(self):
        r"""NormalizeForCompare(BOARD_ITEM self)"""
        return _pcbnew.BOARD_ITEM_NormalizeForCompare(self)
 
    def GetBoard(self, *args):
        r"""
        GetBoard(BOARD_ITEM self) -> BOARD
        GetBoard(BOARD_ITEM self) -> BOARD
        """
        return _pcbnew.BOARD_ITEM_GetBoard(self, *args)
 
    def GetParentAsString(self):
        r"""GetParentAsString(BOARD_ITEM self) -> wxString"""
        return _pcbnew.BOARD_ITEM_GetParentAsString(self)
 
    def GetLayerName(self):
        r"""GetLayerName(BOARD_ITEM self) -> wxString"""
        return _pcbnew.BOARD_ITEM_GetLayerName(self)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(BOARD_ITEM self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.BOARD_ITEM_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth)
 
    def LayerMaskDescribe(self):
        r"""LayerMaskDescribe(BOARD_ITEM self) -> wxString"""
        return _pcbnew.BOARD_ITEM_LayerMaskDescribe(self)
    DRC = _pcbnew.BOARD_ITEM_DRC
    
    INSTANCE_TO_INSTANCE = _pcbnew.BOARD_ITEM_INSTANCE_TO_INSTANCE
    
 
    def Cast(self):
 
        ct = self.GetClass()
 
        if ct=="PCB_TEXT":
            return Cast_to_PCB_TEXT(self)
        if ct=="PCB_TEXTBOX":
            return Cast_to_PCB_TEXTBOX(self)
        elif ct=="BOARD":
            return Cast_to_BOARD(self)
        elif ct=="PCB_DIM_ALIGNED":
            return Cast_to_PCB_DIM_ALIGNED(self)
        elif ct=="PCB_DIM_LEADER":
            return Cast_to_PCB_DIM_LEADER(self)
        elif ct=="PCB_DIM_CENTER":
            return Cast_to_PCB_DIM_CENTER(self)
        elif ct=="PCB_DIM_RADIAL":
            return Cast_to_PCB_DIM_RADIAL(self)
        elif ct=="PCB_DIM_ORTHOGONAL":
            return Cast_to_PCB_DIM_ORTHOGONAL(self)
        elif ct=="PCB_SHAPE":
            return Cast_to_PCB_SHAPE(self)
        elif ct=="FOOTPRINT":
            return Cast_to_FOOTPRINT(self)
        elif ct=="PCB_GROUP":
            return Cast_to_PCB_GROUP(self)
        elif ct=="PAD":
            return Cast_to_PAD(self)
        elif ct=="PCB_VIA":
            return Cast_to_PCB_VIA(self)
        elif ct=="PCB_TRACK":
            return Cast_to_PCB_TRACK(self)
        elif ct=="PCB_ARC":
            return Cast_to_PCB_ARC(self)
        elif ct=="PCB_TARGET":
            return Cast_to_PCB_TARGET(self)
        elif ct=="PCB_TABLE":
            return Cast_to_PCB_TABLE(self)
        elif ct=="PCB_REFERENCE_IMAGE":
            return Cast_to_PCB_REFERENCE_IMAGE(self)
        elif ct=="ZONE":
            return Cast_to_ZONE(self)
        else:
            raise TypeError("Unsupported drawing class: %s" % ct)
 
    """
    Needed to cast BOARD_ITEM::Duplicate() to the suitable type
    """
    def Duplicate(self):
        ct = self.GetClass()
        if ct=="BOARD":
            return None
        else:
            return Cast_to_BOARD_ITEM( _pcbnew.BOARD_ITEM_Duplicate(self) ).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)
 
 
# Register BOARD_ITEM in _pcbnew:
_pcbnew.BOARD_ITEM_swigregister(BOARD_ITEM)
class DELETED_BOARD_ITEM(BOARD_ITEM):
    r"""Proxy of C++ DELETED_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 __init__(self):
        r"""__init__(DELETED_BOARD_ITEM self) -> DELETED_BOARD_ITEM"""
        _pcbnew.DELETED_BOARD_ITEM_swiginit(self, _pcbnew.new_DELETED_BOARD_ITEM())
 
    def GetClass(self):
        r"""GetClass(DELETED_BOARD_ITEM self) -> wxString"""
        return _pcbnew.DELETED_BOARD_ITEM_GetClass(self)
 
    @staticmethod
    def GetInstance():
        r"""GetInstance() -> DELETED_BOARD_ITEM"""
        return _pcbnew.DELETED_BOARD_ITEM_GetInstance()
 
    def __eq__(self, *args):
        r"""
        __eq__(DELETED_BOARD_ITEM self, BOARD_ITEM aBoardItem) -> bool
        __eq__(DELETED_BOARD_ITEM self, DELETED_BOARD_ITEM aOther) -> bool
        """
        return _pcbnew.DELETED_BOARD_ITEM___eq__(self, *args)
    __swig_destroy__ = _pcbnew.delete_DELETED_BOARD_ITEM
 
# Register DELETED_BOARD_ITEM in _pcbnew:
_pcbnew.DELETED_BOARD_ITEM_swigregister(DELETED_BOARD_ITEM)
IS_CHANGED = _pcbnew.IS_CHANGED
 
IS_LINKED = _pcbnew.IS_LINKED
 
IN_EDIT = _pcbnew.IN_EDIT
 
IS_MOVING = _pcbnew.IS_MOVING
 
IS_NEW = _pcbnew.IS_NEW
 
IS_BROKEN = _pcbnew.IS_BROKEN
 
IS_DELETED = _pcbnew.IS_DELETED
 
STARTPOINT = _pcbnew.STARTPOINT
 
ENDPOINT = _pcbnew.ENDPOINT
 
SELECTED = _pcbnew.SELECTED
 
SELECTED_BY_DRAG = _pcbnew.SELECTED_BY_DRAG
 
STRUCT_DELETED = _pcbnew.STRUCT_DELETED
 
CANDIDATE = _pcbnew.CANDIDATE
 
SKIP_STRUCT = _pcbnew.SKIP_STRUCT
 
IS_PASTED = _pcbnew.IS_PASTED
 
IS_SHOWN_AS_BITMAP = _pcbnew.IS_SHOWN_AS_BITMAP
 
COURTYARD_CONFLICT = _pcbnew.COURTYARD_CONFLICT
 
MALFORMED_F_COURTYARD = _pcbnew.MALFORMED_F_COURTYARD
 
MALFORMED_B_COURTYARD = _pcbnew.MALFORMED_B_COURTYARD
 
MALFORMED_COURTYARDS = _pcbnew.MALFORMED_COURTYARDS
 
ROUTER_TRANSIENT = _pcbnew.ROUTER_TRANSIENT
 
HOLE_PROXY = _pcbnew.HOLE_PROXY
 
SHOW_ELEC_TYPE = _pcbnew.SHOW_ELEC_TYPE
 
BRIGHTENED = _pcbnew.BRIGHTENED
 
UR_TRANSIENT = _pcbnew.UR_TRANSIENT
 
IS_DANGLING = _pcbnew.IS_DANGLING
 
ENTERED = _pcbnew.ENTERED
 
class UNITS_PROVIDER(object):
    r"""Proxy of C++ UNITS_PROVIDER 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, aIuScale, aUnits):
        r"""__init__(UNITS_PROVIDER self, EDA_IU_SCALE aIuScale, EDA_UNITS aUnits) -> UNITS_PROVIDER"""
        _pcbnew.UNITS_PROVIDER_swiginit(self, _pcbnew.new_UNITS_PROVIDER(aIuScale, aUnits))
    __swig_destroy__ = _pcbnew.delete_UNITS_PROVIDER
 
    def GetUserUnits(self):
        r"""GetUserUnits(UNITS_PROVIDER self) -> EDA_UNITS"""
        return _pcbnew.UNITS_PROVIDER_GetUserUnits(self)
 
    def SetUserUnits(self, aUnits):
        r"""SetUserUnits(UNITS_PROVIDER self, EDA_UNITS aUnits)"""
        return _pcbnew.UNITS_PROVIDER_SetUserUnits(self, aUnits)
 
    def GetUnitPair(self, aPrimaryUnit, aSecondaryUnits):
        r"""GetUnitPair(UNITS_PROVIDER self, EDA_UNITS & aPrimaryUnit, EDA_UNITS & aSecondaryUnits)"""
        return _pcbnew.UNITS_PROVIDER_GetUnitPair(self, aPrimaryUnit, aSecondaryUnits)
 
    def GetIuScale(self):
        r"""GetIuScale(UNITS_PROVIDER self) -> EDA_IU_SCALE"""
        return _pcbnew.UNITS_PROVIDER_GetIuScale(self)
 
    def GetOriginTransforms(self):
        r"""GetOriginTransforms(UNITS_PROVIDER self) -> ORIGIN_TRANSFORMS &"""
        return _pcbnew.UNITS_PROVIDER_GetOriginTransforms(self)
 
    def StringFromOptionalValue(self, *args):
        r"""StringFromOptionalValue(UNITS_PROVIDER self, std::optional< int > aValue, bool aAddUnitLabel=False, EDA_DATA_TYPE aType=DISTANCE) -> wxString"""
        return _pcbnew.UNITS_PROVIDER_StringFromOptionalValue(self, *args)
 
    def StringFromValue(self, *args):
        r"""
        StringFromValue(UNITS_PROVIDER self, double aValue, bool aAddUnitLabel=False, EDA_DATA_TYPE aType=DISTANCE) -> wxString
        StringFromValue(UNITS_PROVIDER self, EDA_ANGLE aValue, bool aAddUnitLabel=False) -> wxString
        """
        return _pcbnew.UNITS_PROVIDER_StringFromValue(self, *args)
 
    def MessageTextFromValue(self, *args):
        r"""
        MessageTextFromValue(UNITS_PROVIDER self, double aValue, bool aAddUnitLabel=True, EDA_DATA_TYPE aType=DISTANCE) -> wxString
        MessageTextFromValue(UNITS_PROVIDER self, EDA_ANGLE aValue, bool aAddUnitLabel=True) -> wxString
        """
        return _pcbnew.UNITS_PROVIDER_MessageTextFromValue(self, *args)
 
    def MessageTextFromMinOptMax(self, aValue):
        r"""MessageTextFromMinOptMax(UNITS_PROVIDER self, MINOPTMAX< int > const & aValue) -> wxString"""
        return _pcbnew.UNITS_PROVIDER_MessageTextFromMinOptMax(self, aValue)
 
    def ValueFromString(self, *args):
        r"""ValueFromString(UNITS_PROVIDER self, wxString aTextValue, EDA_DATA_TYPE aType=DISTANCE) -> int"""
        return _pcbnew.UNITS_PROVIDER_ValueFromString(self, *args)
 
    def OptionalValueFromString(self, *args):
        r"""OptionalValueFromString(UNITS_PROVIDER self, wxString aTextValue, EDA_DATA_TYPE aType=DISTANCE) -> std::optional< int >"""
        return _pcbnew.UNITS_PROVIDER_OptionalValueFromString(self, *args)
 
    def AngleValueFromString(self, aTextValue):
        r"""AngleValueFromString(UNITS_PROVIDER self, wxString aTextValue) -> EDA_ANGLE"""
        return _pcbnew.UNITS_PROVIDER_AngleValueFromString(self, aTextValue)
    NullUiString = _pcbnew.UNITS_PROVIDER_NullUiString
    
 
# Register UNITS_PROVIDER in _pcbnew:
_pcbnew.UNITS_PROVIDER_swigregister(UNITS_PROVIDER)
 
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_PCB_TEXT(arg1):
    r"""Cast_to_PCB_TEXT(BOARD_ITEM arg1) -> PCB_TEXT"""
    return _pcbnew.Cast_to_PCB_TEXT(arg1)
 
def Cast_to_PCB_TEXTBOX(arg1):
    r"""Cast_to_PCB_TEXTBOX(BOARD_ITEM arg1) -> PCB_TEXTBOX"""
    return _pcbnew.Cast_to_PCB_TEXTBOX(arg1)
 
def Cast_to_PCB_DIM_ALIGNED(arg1):
    r"""Cast_to_PCB_DIM_ALIGNED(BOARD_ITEM arg1) -> PCB_DIM_ALIGNED"""
    return _pcbnew.Cast_to_PCB_DIM_ALIGNED(arg1)
 
def Cast_to_PCB_DIM_ORTHOGONAL(arg1):
    r"""Cast_to_PCB_DIM_ORTHOGONAL(BOARD_ITEM arg1) -> PCB_DIM_ORTHOGONAL"""
    return _pcbnew.Cast_to_PCB_DIM_ORTHOGONAL(arg1)
 
def Cast_to_PCB_DIM_LEADER(arg1):
    r"""Cast_to_PCB_DIM_LEADER(BOARD_ITEM arg1) -> PCB_DIM_LEADER"""
    return _pcbnew.Cast_to_PCB_DIM_LEADER(arg1)
 
def Cast_to_PCB_DIM_CENTER(arg1):
    r"""Cast_to_PCB_DIM_CENTER(BOARD_ITEM arg1) -> PCB_DIM_CENTER"""
    return _pcbnew.Cast_to_PCB_DIM_CENTER(arg1)
 
def Cast_to_PCB_DIM_RADIAL(arg1):
    r"""Cast_to_PCB_DIM_RADIAL(BOARD_ITEM arg1) -> PCB_DIM_RADIAL"""
    return _pcbnew.Cast_to_PCB_DIM_RADIAL(arg1)
 
def Cast_to_FOOTPRINT(arg1):
    r"""Cast_to_FOOTPRINT(BOARD_ITEM arg1) -> FOOTPRINT"""
    return _pcbnew.Cast_to_FOOTPRINT(arg1)
 
def Cast_to_PCB_GROUP(arg1):
    r"""Cast_to_PCB_GROUP(BOARD_ITEM arg1) -> PCB_GROUP"""
    return _pcbnew.Cast_to_PCB_GROUP(arg1)
 
def Cast_to_PCB_SHAPE(arg1):
    r"""Cast_to_PCB_SHAPE(BOARD_ITEM arg1) -> PCB_SHAPE"""
    return _pcbnew.Cast_to_PCB_SHAPE(arg1)
 
def Cast_to_PCB_MARKER(arg1):
    r"""Cast_to_PCB_MARKER(BOARD_ITEM arg1) -> PCB_MARKER"""
    return _pcbnew.Cast_to_PCB_MARKER(arg1)
 
def Cast_to_BOARD(arg1):
    r"""Cast_to_BOARD(BOARD_ITEM arg1) -> BOARD"""
    return _pcbnew.Cast_to_BOARD(arg1)
 
def Cast_to_PAD(arg1):
    r"""Cast_to_PAD(BOARD_ITEM arg1) -> PAD"""
    return _pcbnew.Cast_to_PAD(arg1)
 
def Cast_to_PCB_TRACK(arg1):
    r"""Cast_to_PCB_TRACK(BOARD_ITEM arg1) -> PCB_TRACK"""
    return _pcbnew.Cast_to_PCB_TRACK(arg1)
 
def Cast_to_PCB_VIA(arg1):
    r"""Cast_to_PCB_VIA(BOARD_ITEM arg1) -> PCB_VIA"""
    return _pcbnew.Cast_to_PCB_VIA(arg1)
 
def Cast_to_PCB_ARC(arg1):
    r"""Cast_to_PCB_ARC(BOARD_ITEM arg1) -> PCB_ARC"""
    return _pcbnew.Cast_to_PCB_ARC(arg1)
 
def Cast_to_ZONE(arg1):
    r"""Cast_to_ZONE(BOARD_ITEM arg1) -> ZONE"""
    return _pcbnew.Cast_to_ZONE(arg1)
 
def Cast_to_PCB_TARGET(arg1):
    r"""Cast_to_PCB_TARGET(BOARD_ITEM arg1) -> PCB_TARGET"""
    return _pcbnew.Cast_to_PCB_TARGET(arg1)
 
def Cast_to_PCB_TABLE(arg1):
    r"""Cast_to_PCB_TABLE(BOARD_ITEM arg1) -> PCB_TABLE"""
    return _pcbnew.Cast_to_PCB_TABLE(arg1)
 
def Cast_to_PCB_REFERENCE_IMAGE(arg1):
    r"""Cast_to_PCB_REFERENCE_IMAGE(BOARD_ITEM arg1) -> PCB_REFERENCE_IMAGE"""
    return _pcbnew.Cast_to_PCB_REFERENCE_IMAGE(arg1)
ADD_MODE_INSERT = _pcbnew.ADD_MODE_INSERT
 
ADD_MODE_APPEND = _pcbnew.ADD_MODE_APPEND
 
ADD_MODE_BULK_APPEND = _pcbnew.ADD_MODE_BULK_APPEND
 
ADD_MODE_BULK_INSERT = _pcbnew.ADD_MODE_BULK_INSERT
 
REMOVE_MODE_NORMAL = _pcbnew.REMOVE_MODE_NORMAL
 
REMOVE_MODE_BULK = _pcbnew.REMOVE_MODE_BULK
 
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
 
    def AddNative(self, *args):
        r"""AddNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT, bool aSkipConnectivity=False)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_AddNative(self, *args)
 
    def RemoveNative(self, *args):
        r"""RemoveNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_RemoveNative(self, *args)
 
    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, BOARD_ADD_MODE aMode=BOARD_ADD_MODE::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
 
    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM_CONTAINER
 
# 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 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 UnpackNet(self, aProto):
        r"""UnpackNet(BOARD_CONNECTED_ITEM self, kiapi::board::types::Net const & aProto)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_UnpackNet(self, aProto)
 
    def PackNet(self, aProto):
        r"""PackNet(BOARD_CONNECTED_ITEM self, kiapi::board::types::Net * aProto)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_PackNet(self, aProto)
 
    def GetNetCode(self):
        r"""GetNetCode(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetCode(self)
 
    def SetNetCode(self, *args):
        r"""
        SetNetCode(BOARD_CONNECTED_ITEM self, int aNetCode, bool aNoAssert) -> bool
        SetNetCode(BOARD_CONNECTED_ITEM self, int aNetCode)
        """
        return _pcbnew.BOARD_CONNECTED_ITEM_SetNetCode(self, *args)
 
    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 GetDisplayNetname(self):
        r"""GetDisplayNetname(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetDisplayNetname(self)
 
    def GetOwnClearance(self, aLayer, aSource=None):
        r"""GetOwnClearance(BOARD_CONNECTED_ITEM self, PCB_LAYER_ID aLayer, wxString aSource=None) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetOwnClearance(self, aLayer, aSource)
 
    def GetClearanceOverrides(self, aSource):
        r"""GetClearanceOverrides(BOARD_CONNECTED_ITEM self, wxString aSource) -> std::optional< int >"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetClearanceOverrides(self, aSource)
 
    def GetLocalClearance(self, *args):
        r"""
        GetLocalClearance(BOARD_CONNECTED_ITEM self) -> std::optional< int >
        GetLocalClearance(BOARD_CONNECTED_ITEM self, wxString aSource) -> std::optional< int >
        """
        return _pcbnew.BOARD_CONNECTED_ITEM_GetLocalClearance(self, *args)
 
    def GetEffectiveNetClass(self):
        r"""GetEffectiveNetClass(BOARD_CONNECTED_ITEM self) -> NETCLASS"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetEffectiveNetClass(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)
 
    def GetTeardropParams(self, *args):
        r"""
        GetTeardropParams(BOARD_CONNECTED_ITEM self) -> TEARDROP_PARAMETERS
        GetTeardropParams(BOARD_CONNECTED_ITEM self) -> TEARDROP_PARAMETERS const &
        """
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropParams(self, *args)
 
    def SetTeardropsEnabled(self, aEnable):
        r"""SetTeardropsEnabled(BOARD_CONNECTED_ITEM self, bool aEnable)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropsEnabled(self, aEnable)
 
    def GetTeardropsEnabled(self):
        r"""GetTeardropsEnabled(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropsEnabled(self)
 
    def SetTeardropBestLengthRatio(self, aRatio):
        r"""SetTeardropBestLengthRatio(BOARD_CONNECTED_ITEM self, double aRatio)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropBestLengthRatio(self, aRatio)
 
    def GetTeardropBestLengthRatio(self):
        r"""GetTeardropBestLengthRatio(BOARD_CONNECTED_ITEM self) -> double"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropBestLengthRatio(self)
 
    def SetTeardropMaxLength(self, aMaxLength):
        r"""SetTeardropMaxLength(BOARD_CONNECTED_ITEM self, int aMaxLength)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropMaxLength(self, aMaxLength)
 
    def GetTeardropMaxLength(self):
        r"""GetTeardropMaxLength(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropMaxLength(self)
 
    def SetTeardropBestWidthRatio(self, aRatio):
        r"""SetTeardropBestWidthRatio(BOARD_CONNECTED_ITEM self, double aRatio)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropBestWidthRatio(self, aRatio)
 
    def GetTeardropBestWidthRatio(self):
        r"""GetTeardropBestWidthRatio(BOARD_CONNECTED_ITEM self) -> double"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropBestWidthRatio(self)
 
    def SetTeardropMaxWidth(self, aMaxWidth):
        r"""SetTeardropMaxWidth(BOARD_CONNECTED_ITEM self, int aMaxWidth)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropMaxWidth(self, aMaxWidth)
 
    def GetTeardropMaxWidth(self):
        r"""GetTeardropMaxWidth(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropMaxWidth(self)
 
    def SetTeardropCurved(self, aCurve):
        r"""SetTeardropCurved(BOARD_CONNECTED_ITEM self, bool aCurve)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropCurved(self, aCurve)
 
    def GetTeardropCurved(self):
        r"""GetTeardropCurved(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropCurved(self)
 
    def SetTeardropPreferZoneConnections(self, aPrefer):
        r"""SetTeardropPreferZoneConnections(BOARD_CONNECTED_ITEM self, bool aPrefer)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropPreferZoneConnections(self, aPrefer)
 
    def GetTeardropPreferZoneConnections(self):
        r"""GetTeardropPreferZoneConnections(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropPreferZoneConnections(self)
 
    def SetTeardropAllowSpanTwoTracks(self, aAllow):
        r"""SetTeardropAllowSpanTwoTracks(BOARD_CONNECTED_ITEM self, bool aAllow)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropAllowSpanTwoTracks(self, aAllow)
 
    def GetTeardropAllowSpanTwoTracks(self):
        r"""GetTeardropAllowSpanTwoTracks(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropAllowSpanTwoTracks(self)
 
    def SetTeardropMaxTrackWidth(self, aRatio):
        r"""SetTeardropMaxTrackWidth(BOARD_CONNECTED_ITEM self, double aRatio)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetTeardropMaxTrackWidth(self, aRatio)
 
    def GetTeardropMaxTrackWidth(self):
        r"""GetTeardropMaxTrackWidth(BOARD_CONNECTED_ITEM self) -> double"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetTeardropMaxTrackWidth(self)
    __swig_destroy__ = _pcbnew.delete_BOARD_CONNECTED_ITEM
 
# Register BOARD_CONNECTED_ITEM in _pcbnew:
_pcbnew.BOARD_CONNECTED_ITEM_swigregister(BOARD_CONNECTED_ITEM)
class netclasses_map(object):
    r"""Proxy of C++ std::map< wxString,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 iterator(self):
        r"""iterator(netclasses_map self) -> SwigPyIterator"""
        return _pcbnew.netclasses_map_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(netclasses_map self) -> bool"""
        return _pcbnew.netclasses_map___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(netclasses_map self) -> bool"""
        return _pcbnew.netclasses_map___bool__(self)
 
    def __len__(self):
        r"""__len__(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.netclasses_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__(netclasses_map self, wxString key) -> std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const &"""
        return _pcbnew.netclasses_map___getitem__(self, key)
 
    def __delitem__(self, key):
        r"""__delitem__(netclasses_map self, wxString key)"""
        return _pcbnew.netclasses_map___delitem__(self, key)
 
    def has_key(self, key):
        r"""has_key(netclasses_map self, wxString key) -> bool"""
        return _pcbnew.netclasses_map_has_key(self, key)
 
    def keys(self):
        r"""keys(netclasses_map self) -> PyObject *"""
        return _pcbnew.netclasses_map_keys(self)
 
    def values(self):
        r"""values(netclasses_map self) -> PyObject *"""
        return _pcbnew.netclasses_map_values(self)
 
    def items(self):
        r"""items(netclasses_map self) -> PyObject *"""
        return _pcbnew.netclasses_map_items(self)
 
    def __contains__(self, key):
        r"""__contains__(netclasses_map self, wxString key) -> bool"""
        return _pcbnew.netclasses_map___contains__(self, key)
 
    def key_iterator(self):
        r"""key_iterator(netclasses_map self) -> SwigPyIterator"""
        return _pcbnew.netclasses_map_key_iterator(self)
 
    def value_iterator(self):
        r"""value_iterator(netclasses_map self) -> SwigPyIterator"""
        return _pcbnew.netclasses_map_value_iterator(self)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(netclasses_map self, wxString key)
        __setitem__(netclasses_map self, wxString key, std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const & x)
        """
        return _pcbnew.netclasses_map___setitem__(self, *args)
 
    def asdict(self):
        r"""asdict(netclasses_map self) -> PyObject *"""
        return _pcbnew.netclasses_map_asdict(self)
 
    def __init__(self, *args):
        r"""
        __init__(netclasses_map self, std::less< wxString > const & other) -> netclasses_map
        __init__(netclasses_map self) -> netclasses_map
        __init__(netclasses_map self, netclasses_map other) -> netclasses_map
        """
        _pcbnew.netclasses_map_swiginit(self, _pcbnew.new_netclasses_map(*args))
 
    def empty(self):
        r"""empty(netclasses_map self) -> bool"""
        return _pcbnew.netclasses_map_empty(self)
 
    def size(self):
        r"""size(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.netclasses_map_size(self)
 
    def swap(self, v):
        r"""swap(netclasses_map self, netclasses_map v)"""
        return _pcbnew.netclasses_map_swap(self, v)
 
    def begin(self):
        r"""begin(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.netclasses_map_begin(self)
 
    def end(self):
        r"""end(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.netclasses_map_end(self)
 
    def rbegin(self):
        r"""rbegin(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.netclasses_map_rbegin(self)
 
    def rend(self):
        r"""rend(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.netclasses_map_rend(self)
 
    def clear(self):
        r"""clear(netclasses_map self)"""
        return _pcbnew.netclasses_map_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(netclasses_map self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::allocator_type"""
        return _pcbnew.netclasses_map_get_allocator(self)
 
    def count(self, x):
        r"""count(netclasses_map self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.netclasses_map_count(self, x)
 
    def erase(self, *args):
        r"""
        erase(netclasses_map self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type
        erase(netclasses_map self, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator position)
        erase(netclasses_map self, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator first, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator last)
        """
        return _pcbnew.netclasses_map_erase(self, *args)
 
    def find(self, x):
        r"""find(netclasses_map self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.netclasses_map_find(self, x)
 
    def lower_bound(self, x):
        r"""lower_bound(netclasses_map self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.netclasses_map_lower_bound(self, x)
 
    def upper_bound(self, x):
        r"""upper_bound(netclasses_map self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.netclasses_map_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_netclasses_map
 
# Register netclasses_map in _pcbnew:
_pcbnew.netclasses_map_swigregister(netclasses_map)
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_DIMENSION_ARROW_LENGTH = _pcbnew.DEFAULT_DIMENSION_ARROW_LENGTH
 
DEFAULT_DIMENSION_EXTENSION_OFFSET = _pcbnew.DEFAULT_DIMENSION_EXTENSION_OFFSET
 
DEFAULT_BOARD_THICKNESS_MM = _pcbnew.DEFAULT_BOARD_THICKNESS_MM
 
DEFAULT_PCB_EDGE_THICKNESS = _pcbnew.DEFAULT_PCB_EDGE_THICKNESS
 
DEFAULT_SOLDERMASK_EXPANSION = _pcbnew.DEFAULT_SOLDERMASK_EXPANSION
 
DEFAULT_SOLDERMASK_TO_COPPER_CLEARANCE = _pcbnew.DEFAULT_SOLDERMASK_TO_COPPER_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_MEANDER_SPACING = _pcbnew.DEFAULT_MEANDER_SPACING
 
DEFAULT_DP_MEANDER_SPACING = _pcbnew.DEFAULT_DP_MEANDER_SPACING
 
DEFAULT_MINCLEARANCE = _pcbnew.DEFAULT_MINCLEARANCE
 
DEFAULT_MINCONNECTION = _pcbnew.DEFAULT_MINCONNECTION
 
DEFAULT_TRACKMINWIDTH = _pcbnew.DEFAULT_TRACKMINWIDTH
 
DEFAULT_VIASMINSIZE = _pcbnew.DEFAULT_VIASMINSIZE
 
DEFAULT_MINTHROUGHDRILL = _pcbnew.DEFAULT_MINTHROUGHDRILL
 
DEFAULT_MICROVIASMINSIZE = _pcbnew.DEFAULT_MICROVIASMINSIZE
 
DEFAULT_MICROVIASMINDRILL = _pcbnew.DEFAULT_MICROVIASMINDRILL
 
DEFAULT_HOLETOHOLEMIN = _pcbnew.DEFAULT_HOLETOHOLEMIN
 
DEFAULT_HOLECLEARANCE = _pcbnew.DEFAULT_HOLECLEARANCE
 
DEFAULT_COPPEREDGECLEARANCE = _pcbnew.DEFAULT_COPPEREDGECLEARANCE
 
LEGACY_COPPEREDGECLEARANCE = _pcbnew.LEGACY_COPPEREDGECLEARANCE
 
DEFAULT_SILKCLEARANCE = _pcbnew.DEFAULT_SILKCLEARANCE
 
DEFAULT_MINGROOVEWIDTH = _pcbnew.DEFAULT_MINGROOVEWIDTH
 
DEFAULT_MINRESOLVEDSPOKES = _pcbnew.DEFAULT_MINRESOLVEDSPOKES
 
MINIMUM_ERROR_SIZE_MM = _pcbnew.MINIMUM_ERROR_SIZE_MM
 
MAXIMUM_ERROR_SIZE_MM = _pcbnew.MAXIMUM_ERROR_SIZE_MM
 
MINIMUM_LINE_WIDTH_MM = _pcbnew.MINIMUM_LINE_WIDTH_MM
 
MAXIMUM_LINE_WIDTH_MM = _pcbnew.MAXIMUM_LINE_WIDTH_MM
 
DEFAULT_PAD_WIDTH_MM = _pcbnew.DEFAULT_PAD_WIDTH_MM
 
DEFAULT_PAD_HEIGTH_MM = _pcbnew.DEFAULT_PAD_HEIGTH_MM
 
DEFAULT_PAD_DRILL_DIAMETER_MM = _pcbnew.DEFAULT_PAD_DRILL_DIAMETER_MM
 
DEFAULT_PAD_RR_RADIUS_RATIO = _pcbnew.DEFAULT_PAD_RR_RADIUS_RATIO
 
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 __ne__(self, aOther):
        r"""__ne__(VIA_DIMENSION self, VIA_DIMENSION aOther) -> bool"""
        return _pcbnew.VIA_DIMENSION___ne__(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 __ne__(self, aOther):
        r"""__ne__(DIFF_PAIR_DIMENSION self, DIFF_PAIR_DIMENSION aOther) -> bool"""
        return _pcbnew.DIFF_PAIR_DIMENSION___ne__(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_FAB = _pcbnew.LAYER_CLASS_FAB
 
LAYER_CLASS_OTHERS = _pcbnew.LAYER_CLASS_OTHERS
 
LAYER_CLASS_COUNT = _pcbnew.LAYER_CLASS_COUNT
 
class TEXT_ITEM_INFO(object):
    r"""Proxy of C++ TEXT_ITEM_INFO class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Text = property(_pcbnew.TEXT_ITEM_INFO_m_Text_get, _pcbnew.TEXT_ITEM_INFO_m_Text_set, doc=r"""m_Text : wxString""")
    m_Visible = property(_pcbnew.TEXT_ITEM_INFO_m_Visible_get, _pcbnew.TEXT_ITEM_INFO_m_Visible_set, doc=r"""m_Visible : bool""")
    m_Layer = property(_pcbnew.TEXT_ITEM_INFO_m_Layer_get, _pcbnew.TEXT_ITEM_INFO_m_Layer_set, doc=r"""m_Layer : PCB_LAYER_ID""")
 
    def __init__(self, aText, aVisible, aLayer):
        r"""__init__(TEXT_ITEM_INFO self, wxString aText, bool aVisible, PCB_LAYER_ID aLayer) -> TEXT_ITEM_INFO"""
        _pcbnew.TEXT_ITEM_INFO_swiginit(self, _pcbnew.new_TEXT_ITEM_INFO(aText, aVisible, aLayer))
 
    def __eq__(self, aOther):
        r"""__eq__(TEXT_ITEM_INFO self, TEXT_ITEM_INFO aOther) -> bool"""
        return _pcbnew.TEXT_ITEM_INFO___eq__(self, aOther)
    __swig_destroy__ = _pcbnew.delete_TEXT_ITEM_INFO
 
# Register TEXT_ITEM_INFO in _pcbnew:
_pcbnew.TEXT_ITEM_INFO_swigregister(TEXT_ITEM_INFO)
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
    __swig_destroy__ = _pcbnew.delete_BOARD_DESIGN_SETTINGS
 
    def __eq__(self, aOther):
        r"""__eq__(BOARD_DESIGN_SETTINGS self, BOARD_DESIGN_SETTINGS aOther) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS___eq__(self, aOther)
 
    def __ne__(self, aOther):
        r"""__ne__(BOARD_DESIGN_SETTINGS self, BOARD_DESIGN_SETTINGS aOther) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS___ne__(self, aOther)
 
    def __init__(self, *args):
        r"""
        __init__(BOARD_DESIGN_SETTINGS self, JSON_SETTINGS * aParent, string aPath) -> BOARD_DESIGN_SETTINGS
        __init__(BOARD_DESIGN_SETTINGS self, BOARD_DESIGN_SETTINGS aOther) -> BOARD_DESIGN_SETTINGS
        """
        _pcbnew.BOARD_DESIGN_SETTINGS_swiginit(self, _pcbnew.new_BOARD_DESIGN_SETTINGS(*args))
 
    def LoadFromFile(self, *args):
        r"""LoadFromFile(BOARD_DESIGN_SETTINGS self, wxString aDirectory="") -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_LoadFromFile(self, *args)
 
    def GetStackupDescriptor(self, *args):
        r"""
        GetStackupDescriptor(BOARD_DESIGN_SETTINGS self) -> BOARD_STACKUP
        GetStackupDescriptor(BOARD_DESIGN_SETTINGS self) -> BOARD_STACKUP const &
        """
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetStackupDescriptor(self, *args)
 
    def GetTeadropParamsList(self):
        r"""GetTeadropParamsList(BOARD_DESIGN_SETTINGS self) -> TEARDROP_PARAMETERS_LIST *"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTeadropParamsList(self)
 
    def GetSeverity(self, aDRCErrorCode):
        r"""GetSeverity(BOARD_DESIGN_SETTINGS self, int aDRCErrorCode) -> SEVERITY"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetSeverity(self, aDRCErrorCode)
 
    def Ignore(self, aDRCErrorCode):
        r"""Ignore(BOARD_DESIGN_SETTINGS self, int aDRCErrorCode) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_Ignore(self, aDRCErrorCode)
 
    def GetDefaultZoneSettings(self):
        r"""GetDefaultZoneSettings(BOARD_DESIGN_SETTINGS self) -> ZONE_SETTINGS"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDefaultZoneSettings(self)
 
    def SetDefaultZoneSettings(self, aSettings):
        r"""SetDefaultZoneSettings(BOARD_DESIGN_SETTINGS self, ZONE_SETTINGS aSettings)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetDefaultZoneSettings(self, aSettings)
 
    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 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 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 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 GetUserDefinedLayerCount(self):
        r"""GetUserDefinedLayerCount(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetUserDefinedLayerCount(self)
 
    def SetUserDefinedLayerCount(self, aNewLayerCount):
        r"""SetUserDefinedLayerCount(BOARD_DESIGN_SETTINGS self, int aNewLayerCount)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetUserDefinedLayerCount(self, aNewLayerCount)
 
    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 GetDRCEpsilon(self):
        r"""GetDRCEpsilon(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDRCEpsilon(self)
 
    def GetHolePlatingThickness(self):
        r"""GetHolePlatingThickness(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetHolePlatingThickness(self)
 
    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) -> VECTOR2I"""
        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)
 
    def SetAuxOrigin(self, aOrigin):
        r"""SetAuxOrigin(BOARD_DESIGN_SETTINGS self, VECTOR2I aOrigin)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetAuxOrigin(self, aOrigin)
 
    def GetAuxOrigin(self):
        r"""GetAuxOrigin(BOARD_DESIGN_SETTINGS self) -> VECTOR2I"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetAuxOrigin(self)
 
    def SetGridOrigin(self, aOrigin):
        r"""SetGridOrigin(BOARD_DESIGN_SETTINGS self, VECTOR2I aOrigin)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetGridOrigin(self, aOrigin)
 
    def GetGridOrigin(self):
        r"""GetGridOrigin(BOARD_DESIGN_SETTINGS self) -> VECTOR2I"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetGridOrigin(self)
 
    def SetDefaultMasterPad(self):
        r"""SetDefaultMasterPad(BOARD_DESIGN_SETTINGS self)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetDefaultMasterPad(self)
    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_TeardropParamsList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TeardropParamsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TeardropParamsList_set, doc=r"""m_TeardropParamsList : TEARDROP_PARAMETERS_LIST""")
    m_SingleTrackMeanderSettings = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SingleTrackMeanderSettings_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SingleTrackMeanderSettings_set, doc=r"""m_SingleTrackMeanderSettings : PNS::MEANDER_SETTINGS""")
    m_DiffPairMeanderSettings = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairMeanderSettings_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairMeanderSettings_set, doc=r"""m_DiffPairMeanderSettings : PNS::MEANDER_SETTINGS""")
    m_SkewMeanderSettings = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SkewMeanderSettings_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SkewMeanderSettings_set, doc=r"""m_SkewMeanderSettings : PNS::MEANDER_SETTINGS""")
    m_CurrentViaType = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_set, doc=r"""m_CurrentViaType : VIATYPE""")
    m_UseConnectedTrackWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_set, doc=r"""m_UseConnectedTrackWidth : bool""")
    m_TempOverrideTrackWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TempOverrideTrackWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TempOverrideTrackWidth_set, doc=r"""m_TempOverrideTrackWidth : bool""")
    m_MinClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinClearance_set, doc=r"""m_MinClearance : int""")
    m_MinGrooveWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinGrooveWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinGrooveWidth_set, doc=r"""m_MinGrooveWidth : int""")
    m_MinConn = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinConn_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinConn_set, doc=r"""m_MinConn : int""")
    m_TrackMinWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_set, doc=r"""m_TrackMinWidth : int""")
    m_ViasMinAnnularWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinAnnularWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinAnnularWidth_set, doc=r"""m_ViasMinAnnularWidth : int""")
    m_ViasMinSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_set, doc=r"""m_ViasMinSize : int""")
    m_MinThroughDrill = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinThroughDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinThroughDrill_set, doc=r"""m_MinThroughDrill : 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_CopperEdgeClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_CopperEdgeClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_CopperEdgeClearance_set, doc=r"""m_CopperEdgeClearance : int""")
    m_HoleClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HoleClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleClearance_set, doc=r"""m_HoleClearance : int""")
    m_HoleToHoleMin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_set, doc=r"""m_HoleToHoleMin : int""")
    m_SilkClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SilkClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SilkClearance_set, doc=r"""m_SilkClearance : int""")
    m_MinResolvedSpokes = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinResolvedSpokes_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinResolvedSpokes_set, doc=r"""m_MinResolvedSpokes : int""")
    m_MinSilkTextHeight = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinSilkTextHeight_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinSilkTextHeight_set, doc=r"""m_MinSilkTextHeight : int""")
    m_MinSilkTextThickness = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinSilkTextThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinSilkTextThickness_set, doc=r"""m_MinSilkTextThickness : int""")
    m_DRCSeverities = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DRCSeverities_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DRCSeverities_set, doc=r"""m_DRCSeverities : std::map<(int,SEVERITY,std::less<(int)>,std::allocator<(std::pair<(q(const).int,SEVERITY)>)>)>""")
    m_DrcExclusions = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DrcExclusions_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DrcExclusions_set, doc=r"""m_DrcExclusions : std::set<(wxString,std::less<(wxString)>,std::allocator<(wxString)>)>""")
    m_DrcExclusionComments = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DrcExclusionComments_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DrcExclusionComments_set, doc=r"""m_DrcExclusionComments : std::map<(wxString,wxString,std::less<(wxString)>,std::allocator<(std::pair<(q(const).wxString,wxString)>)>)>""")
    m_ZoneKeepExternalFillets = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ZoneKeepExternalFillets_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ZoneKeepExternalFillets_set, doc=r"""m_ZoneKeepExternalFillets : bool""")
    m_MaxError = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MaxError_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MaxError_set, doc=r"""m_MaxError : int""")
    m_SolderMaskExpansion = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskExpansion_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskExpansion_set, doc=r"""m_SolderMaskExpansion : int""")
    m_SolderMaskMinWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_set, doc=r"""m_SolderMaskMinWidth : int""")
    m_SolderMaskToCopperClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskToCopperClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskToCopperClearance_set, doc=r"""m_SolderMaskToCopperClearance : 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_AllowSoldermaskBridgesInFPs = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_AllowSoldermaskBridgesInFPs_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_AllowSoldermaskBridgesInFPs_set, doc=r"""m_AllowSoldermaskBridgesInFPs : bool""")
    m_TentViasFront = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TentViasFront_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TentViasFront_set, doc=r"""m_TentViasFront : bool""")
    m_TentViasBack = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TentViasBack_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TentViasBack_set, doc=r"""m_TentViasBack : bool""")
    m_NetSettings = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_NetSettings_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_NetSettings_set, doc=r"""m_NetSettings : std::shared_ptr<(NET_SETTINGS)>""")
    m_DefaultFPTextItems = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DefaultFPTextItems_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DefaultFPTextItems_set, doc=r"""m_DefaultFPTextItems : std::vector<(TEXT_ITEM_INFO,std::allocator<(TEXT_ITEM_INFO)>)>""")
    m_UserLayerNames = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UserLayerNames_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UserLayerNames_set, doc=r"""m_UserLayerNames : std::map<(std::string,wxString,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,wxString)>)>)>""")
    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).VECTOR2I""")
    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_DimensionUnitsMode = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsMode_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsMode_set, doc=r"""m_DimensionUnitsMode : DIM_UNITS_MODE""")
    m_DimensionPrecision = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionPrecision_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionPrecision_set, doc=r"""m_DimensionPrecision : DIM_PRECISION""")
    m_DimensionUnitsFormat = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsFormat_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsFormat_set, doc=r"""m_DimensionUnitsFormat : DIM_UNITS_FORMAT""")
    m_DimensionSuppressZeroes = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionSuppressZeroes_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionSuppressZeroes_set, doc=r"""m_DimensionSuppressZeroes : bool""")
    m_DimensionTextPosition = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionTextPosition_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionTextPosition_set, doc=r"""m_DimensionTextPosition : DIM_TEXT_POSITION""")
    m_DimensionKeepTextAligned = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionKeepTextAligned_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionKeepTextAligned_set, doc=r"""m_DimensionKeepTextAligned : bool""")
    m_DimensionArrowLength = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionArrowLength_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionArrowLength_set, doc=r"""m_DimensionArrowLength : int""")
    m_DimensionExtensionOffset = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionExtensionOffset_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionExtensionOffset_set, doc=r"""m_DimensionExtensionOffset : int""")
    m_StyleFPFields = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_StyleFPFields_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_StyleFPFields_set, doc=r"""m_StyleFPFields : bool""")
    m_StyleFPText = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_StyleFPText_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_StyleFPText_set, doc=r"""m_StyleFPText : bool""")
    m_StyleFPShapes = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_StyleFPShapes_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_StyleFPShapes_set, doc=r"""m_StyleFPShapes : bool""")
    m_HasStackup = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HasStackup_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HasStackup_set, doc=r"""m_HasStackup : bool""")
    m_UseHeightForLengthCalcs = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UseHeightForLengthCalcs_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UseHeightForLengthCalcs_set, doc=r"""m_UseHeightForLengthCalcs : bool""")
 
    def CloneFrom(self, aOther):
        r"""CloneFrom(BOARD_DESIGN_SETTINGS self, BOARD_DESIGN_SETTINGS aOther)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_CloneFrom(self, aOther)
 
# Register BOARD_DESIGN_SETTINGS in _pcbnew:
_pcbnew.BOARD_DESIGN_SETTINGS_swigregister(BOARD_DESIGN_SETTINGS)
class NET_SETTINGS(object):
    r"""Proxy of C++ NET_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, aParent, aPath):
        r"""__init__(NET_SETTINGS self, JSON_SETTINGS * aParent, string aPath) -> NET_SETTINGS"""
        _pcbnew.NET_SETTINGS_swiginit(self, _pcbnew.new_NET_SETTINGS(aParent, aPath))
    __swig_destroy__ = _pcbnew.delete_NET_SETTINGS
 
    def __eq__(self, aOther):
        r"""__eq__(NET_SETTINGS self, NET_SETTINGS aOther) -> bool"""
        return _pcbnew.NET_SETTINGS___eq__(self, aOther)
 
    def __ne__(self, aOther):
        r"""__ne__(NET_SETTINGS self, NET_SETTINGS aOther) -> bool"""
        return _pcbnew.NET_SETTINGS___ne__(self, aOther)
 
    def SetDefaultNetclass(self, netclass):
        r"""SetDefaultNetclass(NET_SETTINGS self, std::shared_ptr< NETCLASS > netclass)"""
        return _pcbnew.NET_SETTINGS_SetDefaultNetclass(self, netclass)
 
    def GetDefaultNetclass(self):
        r"""GetDefaultNetclass(NET_SETTINGS self) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.NET_SETTINGS_GetDefaultNetclass(self)
 
    def HasNetclass(self, netclassName):
        r"""HasNetclass(NET_SETTINGS self, wxString netclassName) -> bool"""
        return _pcbnew.NET_SETTINGS_HasNetclass(self, netclassName)
 
    def SetNetclass(self, netclassName, netclass):
        r"""SetNetclass(NET_SETTINGS self, wxString netclassName, std::shared_ptr< NETCLASS > & netclass)"""
        return _pcbnew.NET_SETTINGS_SetNetclass(self, netclassName, netclass)
 
    def SetNetclasses(self, netclasses):
        r"""SetNetclasses(NET_SETTINGS self, netclasses_map netclasses)"""
        return _pcbnew.NET_SETTINGS_SetNetclasses(self, netclasses)
 
    def GetNetclasses(self):
        r"""GetNetclasses(NET_SETTINGS self) -> netclasses_map"""
        return _pcbnew.NET_SETTINGS_GetNetclasses(self)
 
    def GetCompositeNetclasses(self):
        r"""GetCompositeNetclasses(NET_SETTINGS self) -> netclasses_map"""
        return _pcbnew.NET_SETTINGS_GetCompositeNetclasses(self)
 
    def ClearNetclasses(self):
        r"""ClearNetclasses(NET_SETTINGS self)"""
        return _pcbnew.NET_SETTINGS_ClearNetclasses(self)
 
    def GetNetclassLabelAssignments(self):
        r"""GetNetclassLabelAssignments(NET_SETTINGS self) -> std::map< wxString,std::set< wxString,std::less< wxString >,std::allocator< wxString > >,std::less< wxString >,std::allocator< std::pair< wxString const,std::set< wxString,std::less< wxString >,std::allocator< wxString > > > > > const &"""
        return _pcbnew.NET_SETTINGS_GetNetclassLabelAssignments(self)
 
    def ClearNetclassLabelAssignments(self):
        r"""ClearNetclassLabelAssignments(NET_SETTINGS self)"""
        return _pcbnew.NET_SETTINGS_ClearNetclassLabelAssignments(self)
 
    def ClearNetclassLabelAssignment(self, netName):
        r"""ClearNetclassLabelAssignment(NET_SETTINGS self, wxString netName)"""
        return _pcbnew.NET_SETTINGS_ClearNetclassLabelAssignment(self, netName)
 
    def SetNetclassLabelAssignment(self, netName, netclasses):
        r"""SetNetclassLabelAssignment(NET_SETTINGS self, wxString netName, STRINGSET netclasses)"""
        return _pcbnew.NET_SETTINGS_SetNetclassLabelAssignment(self, netName, netclasses)
 
    def AppendNetclassLabelAssignment(self, netName, netclasses):
        r"""AppendNetclassLabelAssignment(NET_SETTINGS self, wxString netName, STRINGSET netclasses)"""
        return _pcbnew.NET_SETTINGS_AppendNetclassLabelAssignment(self, netName, netclasses)
 
    def HasNetclassLabelAssignment(self, netName):
        r"""HasNetclassLabelAssignment(NET_SETTINGS self, wxString netName) -> bool"""
        return _pcbnew.NET_SETTINGS_HasNetclassLabelAssignment(self, netName)
 
    def SetNetclassPatternAssignment(self, pattern, netclass):
        r"""SetNetclassPatternAssignment(NET_SETTINGS self, wxString pattern, wxString netclass)"""
        return _pcbnew.NET_SETTINGS_SetNetclassPatternAssignment(self, pattern, netclass)
 
    def SetNetclassPatternAssignments(self, netclassPatterns):
        r"""SetNetclassPatternAssignments(NET_SETTINGS self, std::vector< std::pair< std::unique_ptr< EDA_COMBINED_MATCHER >,wxString >,std::allocator< std::pair< std::unique_ptr< EDA_COMBINED_MATCHER >,wxString > > > && netclassPatterns)"""
        return _pcbnew.NET_SETTINGS_SetNetclassPatternAssignments(self, netclassPatterns)
 
    def GetNetclassPatternAssignments(self):
        r"""GetNetclassPatternAssignments(NET_SETTINGS self) -> std::vector< std::pair< std::unique_ptr< EDA_COMBINED_MATCHER >,wxString >,std::allocator< std::pair< std::unique_ptr< EDA_COMBINED_MATCHER >,wxString > > > &"""
        return _pcbnew.NET_SETTINGS_GetNetclassPatternAssignments(self)
 
    def ClearNetclassPatternAssignments(self):
        r"""ClearNetclassPatternAssignments(NET_SETTINGS self)"""
        return _pcbnew.NET_SETTINGS_ClearNetclassPatternAssignments(self)
 
    def ClearCacheForNet(self, netName):
        r"""ClearCacheForNet(NET_SETTINGS self, wxString netName)"""
        return _pcbnew.NET_SETTINGS_ClearCacheForNet(self, netName)
 
    def ClearAllCaches(self):
        r"""ClearAllCaches(NET_SETTINGS self)"""
        return _pcbnew.NET_SETTINGS_ClearAllCaches(self)
 
    def SetNetColorAssignment(self, netName, color):
        r"""SetNetColorAssignment(NET_SETTINGS self, wxString netName, COLOR4D color)"""
        return _pcbnew.NET_SETTINGS_SetNetColorAssignment(self, netName, color)
 
    def GetNetColorAssignments(self):
        r"""GetNetColorAssignments(NET_SETTINGS self) -> std::map< wxString,KIGFX::COLOR4D,std::less< wxString >,std::allocator< std::pair< wxString const,KIGFX::COLOR4D > > > const &"""
        return _pcbnew.NET_SETTINGS_GetNetColorAssignments(self)
 
    def ClearNetColorAssignments(self):
        r"""ClearNetColorAssignments(NET_SETTINGS self)"""
        return _pcbnew.NET_SETTINGS_ClearNetColorAssignments(self)
 
    def HasEffectiveNetClass(self, aNetName):
        r"""HasEffectiveNetClass(NET_SETTINGS self, wxString aNetName) -> bool"""
        return _pcbnew.NET_SETTINGS_HasEffectiveNetClass(self, aNetName)
 
    def GetCachedEffectiveNetClass(self, aNetName):
        r"""GetCachedEffectiveNetClass(NET_SETTINGS self, wxString aNetName) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.NET_SETTINGS_GetCachedEffectiveNetClass(self, aNetName)
 
    def GetEffectiveNetClass(self, aNetName):
        r"""GetEffectiveNetClass(NET_SETTINGS self, wxString aNetName) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.NET_SETTINGS_GetEffectiveNetClass(self, aNetName)
 
    def RecomputeEffectiveNetclasses(self):
        r"""RecomputeEffectiveNetclasses(NET_SETTINGS self)"""
        return _pcbnew.NET_SETTINGS_RecomputeEffectiveNetclasses(self)
 
    def GetNetClassByName(self, aNetName):
        r"""GetNetClassByName(NET_SETTINGS self, wxString aNetName) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.NET_SETTINGS_GetNetClassByName(self, aNetName)
 
    @staticmethod
    def ParseBusVector(aBus, aName, aMemberList):
        r"""ParseBusVector(wxString aBus, wxString aName, std::vector< wxString,std::allocator< wxString > > * aMemberList) -> bool"""
        return _pcbnew.NET_SETTINGS_ParseBusVector(aBus, aName, aMemberList)
 
    @staticmethod
    def ParseBusGroup(aGroup, name, aMemberList):
        r"""ParseBusGroup(wxString aGroup, wxString name, std::vector< wxString,std::allocator< wxString > > * aMemberList) -> bool"""
        return _pcbnew.NET_SETTINGS_ParseBusGroup(aGroup, name, aMemberList)
 
    @staticmethod
    def ForEachBusMember(aBusPattern, aFunction):
        r"""ForEachBusMember(wxString aBusPattern, std::function< void (wxString const &) > const & aFunction)"""
        return _pcbnew.NET_SETTINGS_ForEachBusMember(aBusPattern, aFunction)
 
# Register NET_SETTINGS in _pcbnew:
_pcbnew.NET_SETTINGS_swigregister(NET_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 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)
PROPAGATE_MODE_SKIP_CONFLICTS = _pcbnew.PROPAGATE_MODE_SKIP_CONFLICTS
 
PROPAGATE_MODE_RESOLVE_CONFLICTS = _pcbnew.PROPAGATE_MODE_RESOLVE_CONFLICTS
 
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::shared_ptr< CONNECTIVITY_DATA > aGlobalConnectivity, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aLocalItems, bool aSkipRatsnestUpdate=False) -> CONNECTIVITY_DATA
        """
        _pcbnew.CONNECTIVITY_DATA_swiginit(self, _pcbnew.new_CONNECTIVITY_DATA(*args))
 
    def Build(self, *args):
        r"""
        Build(CONNECTIVITY_DATA self, BOARD aBoard, PROGRESS_REPORTER * aReporter=None) -> bool
        Build(CONNECTIVITY_DATA self, std::shared_ptr< CONNECTIVITY_DATA > & aGlobalConnectivity, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aLocalItems)
        """
        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 Move(self, aDelta):
        r"""Move(CONNECTIVITY_DATA self, VECTOR2I aDelta)"""
        return _pcbnew.CONNECTIVITY_DATA_Move(self, aDelta)
 
    def ClearRatsnest(self):
        r"""ClearRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_ClearRatsnest(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, aCommit=None):
        r"""PropagateNets(CONNECTIVITY_DATA self, BOARD_COMMIT * aCommit=None)"""
        return _pcbnew.CONNECTIVITY_DATA_PropagateNets(self, aCommit)
 
    def FillIsolatedIslandsMap(self, aMap, aConnectivityAlreadyRebuilt=False):
        r"""FillIsolatedIslandsMap(CONNECTIVITY_DATA self, std::map< ZONE *,std::map< PCB_LAYER_ID,ISOLATED_ISLANDS,std::less< PCB_LAYER_ID >,std::allocator< std::pair< PCB_LAYER_ID const,ISOLATED_ISLANDS > > >,std::less< ZONE * >,std::allocator< std::pair< ZONE *const,std::map< PCB_LAYER_ID,ISOLATED_ISLANDS,std::less< PCB_LAYER_ID >,std::allocator< std::pair< PCB_LAYER_ID const,ISOLATED_ISLANDS > > > > > > & aMap, bool aConnectivityAlreadyRebuilt=False)"""
        return _pcbnew.CONNECTIVITY_DATA_FillIsolatedIslandsMap(self, aMap, aConnectivityAlreadyRebuilt)
 
    def RecalculateRatsnest(self, aCommit=None):
        r"""RecalculateRatsnest(CONNECTIVITY_DATA self, BOARD_COMMIT * aCommit=None)"""
        return _pcbnew.CONNECTIVITY_DATA_RecalculateRatsnest(self, aCommit)
 
    def GetUnconnectedCount(self, aVisibileOnly):
        r"""GetUnconnectedCount(CONNECTIVITY_DATA self, bool aVisibileOnly) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedCount(self, aVisibileOnly)
 
    def IsConnectedOnLayer(self, *args):
        r"""IsConnectedOnLayer(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, int aLayer, std::initializer_list< KICAD_T > const & aTypes={}) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_IsConnectedOnLayer(self, *args)
 
    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_VEC"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedTracks(self, aItem)
 
    def GetConnectedPads(self, *args):
        r"""
        GetConnectedPads(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem) -> PADS_VEC
        GetConnectedPads(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, std::set< PAD *,std::less< PAD * >,std::allocator< PAD * > > * pads)
        """
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedPads(self, *args)
 
    def GetConnectedPadsAndVias(self, aItem, pads, vias):
        r"""GetConnectedPadsAndVias(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, PADS_VEC pads, std::vector< PCB_VIA *,std::allocator< PCB_VIA * > > * vias)"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedPadsAndVias(self, aItem, pads, vias)
 
    def GetConnectedItemsAtAnchor(self, aItem, aAnchor, aTypes, aMaxError=0):
        r"""GetConnectedItemsAtAnchor(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, VECTOR2I aAnchor, std::vector< KICAD_T,std::allocator< KICAD_T > > const & aTypes, int const & aMaxError=0) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedItemsAtAnchor(self, aItem, aAnchor, aTypes, aMaxError)
 
    def RunOnUnconnectedEdges(self, aFunc):
        r"""RunOnUnconnectedEdges(CONNECTIVITY_DATA self, std::function< bool (CN_EDGE &) > aFunc)"""
        return _pcbnew.CONNECTIVITY_DATA_RunOnUnconnectedEdges(self, aFunc)
 
    def TestTrackEndpointDangling(self, aTrack, aIgnoreTracksInPads, aPos=None):
        r"""TestTrackEndpointDangling(CONNECTIVITY_DATA self, PCB_TRACK aTrack, bool aIgnoreTracksInPads, VECTOR2I aPos=None) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_TestTrackEndpointDangling(self, aTrack, aIgnoreTracksInPads, aPos)
 
    def ClearLocalRatsnest(self):
        r"""ClearLocalRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_ClearLocalRatsnest(self)
 
    def HideLocalRatsnest(self):
        r"""HideLocalRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_HideLocalRatsnest(self)
 
    def ComputeLocalRatsnest(self, *args):
        r"""ComputeLocalRatsnest(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems, CONNECTIVITY_DATA aDynamicData, VECTOR2I aInternalOffset={ 0, 0 })"""
        return _pcbnew.CONNECTIVITY_DATA_ComputeLocalRatsnest(self, *args)
 
    def GetLocalRatsnest(self):
        r"""GetLocalRatsnest(CONNECTIVITY_DATA self) -> std::vector< RN_DYNAMIC_LINE,std::allocator< RN_DYNAMIC_LINE > > const &"""
        return _pcbnew.CONNECTIVITY_DATA_GetLocalRatsnest(self)
 
    def GetConnectedItems(self, aItem, aTypes, aIgnoreNetcodes=False):
        r"""GetConnectedItems(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, std::vector< KICAD_T,std::allocator< KICAD_T > > const & aTypes, bool aIgnoreNetcodes=False) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedItems(self, aItem, aTypes, aIgnoreNetcodes)
 
    def GetNetItems(self, aNetCode, aTypes):
        r"""GetNetItems(CONNECTIVITY_DATA self, int aNetCode, std::vector< KICAD_T,std::allocator< KICAD_T > > const & aTypes) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetItems(self, aNetCode, aTypes)
 
    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) -> KISPINLOCK &"""
        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 RemoveInvalidRefs(self):
        r"""RemoveInvalidRefs(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_RemoveInvalidRefs(self)
 
    def SetProgressReporter(self, aReporter):
        r"""SetProgressReporter(CONNECTIVITY_DATA self, PROGRESS_REPORTER * aReporter)"""
        return _pcbnew.CONNECTIVITY_DATA_SetProgressReporter(self, aReporter)
 
    def GetNetSettings(self):
        r"""GetNetSettings(CONNECTIVITY_DATA self) -> NET_SETTINGS"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetSettings(self)
 
    def HasNetNameForNetCode(self, nc):
        r"""HasNetNameForNetCode(CONNECTIVITY_DATA self, int nc) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_HasNetNameForNetCode(self, nc)
 
    def GetNetNameForNetCode(self, nc):
        r"""GetNetNameForNetCode(CONNECTIVITY_DATA self, int nc) -> wxString"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetNameForNetCode(self, nc)
 
    def RefreshNetcodeMap(self, aBoard):
        r"""RefreshNetcodeMap(CONNECTIVITY_DATA self, BOARD aBoard)"""
        return _pcbnew.CONNECTIVITY_DATA_RefreshNetcodeMap(self, aBoard)
 
    def GetFromToCache(self):
        r"""GetFromToCache(CONNECTIVITY_DATA self) -> std::shared_ptr< FROM_TO_CACHE >"""
        return _pcbnew.CONNECTIVITY_DATA_GetFromToCache(self)
 
# Register CONNECTIVITY_DATA in _pcbnew:
_pcbnew.CONNECTIVITY_DATA_swigregister(CONNECTIVITY_DATA)
class MARKERS(object):
    r"""Proxy of C++ std::vector< PCB_MARKER * > 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< PCB_MARKER * >::size_type"""
        return _pcbnew.MARKERS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j) -> MARKERS"""
        return _pcbnew.MARKERS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j)
        __setslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j, MARKERS v)
        """
        return _pcbnew.MARKERS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j)"""
        return _pcbnew.MARKERS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i)
        __delitem__(MARKERS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.MARKERS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(MARKERS self, SWIGPY_SLICEOBJECT * slice) -> MARKERS
        __getitem__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i) -> PCB_MARKER
        """
        return _pcbnew.MARKERS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(MARKERS self, SWIGPY_SLICEOBJECT * slice, MARKERS v)
        __setitem__(MARKERS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, PCB_MARKER x)
        """
        return _pcbnew.MARKERS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(MARKERS self) -> PCB_MARKER"""
        return _pcbnew.MARKERS_pop(self)
 
    def append(self, x):
        r"""append(MARKERS self, PCB_MARKER 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< PCB_MARKER * >::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< PCB_MARKER * >::iterator"""
        return _pcbnew.MARKERS_begin(self)
 
    def end(self):
        r"""end(MARKERS self) -> std::vector< PCB_MARKER * >::iterator"""
        return _pcbnew.MARKERS_end(self)
 
    def rbegin(self):
        r"""rbegin(MARKERS self) -> std::vector< PCB_MARKER * >::reverse_iterator"""
        return _pcbnew.MARKERS_rbegin(self)
 
    def rend(self):
        r"""rend(MARKERS self) -> std::vector< PCB_MARKER * >::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< PCB_MARKER * >::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< PCB_MARKER * >::iterator pos) -> std::vector< PCB_MARKER * >::iterator
        erase(MARKERS self, std::vector< PCB_MARKER * >::iterator first, std::vector< PCB_MARKER * >::iterator last) -> std::vector< PCB_MARKER * >::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< PCB_MARKER * >::size_type size) -> MARKERS
        __init__(MARKERS self, std::vector< PCB_MARKER * >::size_type size, PCB_MARKER value) -> MARKERS
        """
        _pcbnew.MARKERS_swiginit(self, _pcbnew.new_MARKERS(*args))
 
    def push_back(self, x):
        r"""push_back(MARKERS self, PCB_MARKER x)"""
        return _pcbnew.MARKERS_push_back(self, x)
 
    def front(self):
        r"""front(MARKERS self) -> PCB_MARKER"""
        return _pcbnew.MARKERS_front(self)
 
    def back(self):
        r"""back(MARKERS self) -> PCB_MARKER"""
        return _pcbnew.MARKERS_back(self)
 
    def assign(self, n, x):
        r"""assign(MARKERS self, std::vector< PCB_MARKER * >::size_type n, PCB_MARKER x)"""
        return _pcbnew.MARKERS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(MARKERS self, std::vector< PCB_MARKER * >::size_type new_size)
        resize(MARKERS self, std::vector< PCB_MARKER * >::size_type new_size, PCB_MARKER x)
        """
        return _pcbnew.MARKERS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(MARKERS self, std::vector< PCB_MARKER * >::iterator pos, PCB_MARKER x) -> std::vector< PCB_MARKER * >::iterator
        insert(MARKERS self, std::vector< PCB_MARKER * >::iterator pos, std::vector< PCB_MARKER * >::size_type n, PCB_MARKER x)
        """
        return _pcbnew.MARKERS_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(MARKERS self, std::vector< PCB_MARKER * >::size_type n)"""
        return _pcbnew.MARKERS_reserve(self, n)
 
    def capacity(self):
        r"""capacity(MARKERS self) -> std::vector< PCB_MARKER * >::size_type"""
        return _pcbnew.MARKERS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_MARKERS
 
# Register MARKERS in _pcbnew:
_pcbnew.MARKERS_swigregister(MARKERS)
class ZONES(object):
    r"""Proxy of C++ std::vector< ZONE * > 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(ZONES self) -> SwigPyIterator"""
        return _pcbnew.ZONES_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(ZONES self) -> bool"""
        return _pcbnew.ZONES___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(ZONES self) -> bool"""
        return _pcbnew.ZONES___bool__(self)
 
    def __len__(self):
        r"""__len__(ZONES self) -> std::vector< ZONE * >::size_type"""
        return _pcbnew.ZONES___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j) -> ZONES"""
        return _pcbnew.ZONES___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j)
        __setslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j, ZONES v)
        """
        return _pcbnew.ZONES___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j)"""
        return _pcbnew.ZONES___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(ZONES self, std::vector< ZONE * >::difference_type i)
        __delitem__(ZONES self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.ZONES___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(ZONES self, SWIGPY_SLICEOBJECT * slice) -> ZONES
        __getitem__(ZONES self, std::vector< ZONE * >::difference_type i) -> ZONE
        """
        return _pcbnew.ZONES___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(ZONES self, SWIGPY_SLICEOBJECT * slice, ZONES v)
        __setitem__(ZONES self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(ZONES self, std::vector< ZONE * >::difference_type i, ZONE x)
        """
        return _pcbnew.ZONES___setitem__(self, *args)
 
    def pop(self):
        r"""pop(ZONES self) -> ZONE"""
        return _pcbnew.ZONES_pop(self)
 
    def append(self, x):
        r"""append(ZONES self, ZONE x)"""
        return _pcbnew.ZONES_append(self, x)
 
    def empty(self):
        r"""empty(ZONES self) -> bool"""
        return _pcbnew.ZONES_empty(self)
 
    def size(self):
        r"""size(ZONES self) -> std::vector< ZONE * >::size_type"""
        return _pcbnew.ZONES_size(self)
 
    def swap(self, v):
        r"""swap(ZONES self, ZONES v)"""
        return _pcbnew.ZONES_swap(self, v)
 
    def begin(self):
        r"""begin(ZONES self) -> std::vector< ZONE * >::iterator"""
        return _pcbnew.ZONES_begin(self)
 
    def end(self):
        r"""end(ZONES self) -> std::vector< ZONE * >::iterator"""
        return _pcbnew.ZONES_end(self)
 
    def rbegin(self):
        r"""rbegin(ZONES self) -> std::vector< ZONE * >::reverse_iterator"""
        return _pcbnew.ZONES_rbegin(self)
 
    def rend(self):
        r"""rend(ZONES self) -> std::vector< ZONE * >::reverse_iterator"""
        return _pcbnew.ZONES_rend(self)
 
    def clear(self):
        r"""clear(ZONES self)"""
        return _pcbnew.ZONES_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(ZONES self) -> std::vector< ZONE * >::allocator_type"""
        return _pcbnew.ZONES_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(ZONES self)"""
        return _pcbnew.ZONES_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(ZONES self, std::vector< ZONE * >::iterator pos) -> std::vector< ZONE * >::iterator
        erase(ZONES self, std::vector< ZONE * >::iterator first, std::vector< ZONE * >::iterator last) -> std::vector< ZONE * >::iterator
        """
        return _pcbnew.ZONES_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(ZONES self) -> ZONES
        __init__(ZONES self, ZONES other) -> ZONES
        __init__(ZONES self, std::vector< ZONE * >::size_type size) -> ZONES
        __init__(ZONES self, std::vector< ZONE * >::size_type size, ZONE value) -> ZONES
        """
        _pcbnew.ZONES_swiginit(self, _pcbnew.new_ZONES(*args))
 
    def push_back(self, x):
        r"""push_back(ZONES self, ZONE x)"""
        return _pcbnew.ZONES_push_back(self, x)
 
    def front(self):
        r"""front(ZONES self) -> ZONE"""
        return _pcbnew.ZONES_front(self)
 
    def back(self):
        r"""back(ZONES self) -> ZONE"""
        return _pcbnew.ZONES_back(self)
 
    def assign(self, n, x):
        r"""assign(ZONES self, std::vector< ZONE * >::size_type n, ZONE x)"""
        return _pcbnew.ZONES_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(ZONES self, std::vector< ZONE * >::size_type new_size)
        resize(ZONES self, std::vector< ZONE * >::size_type new_size, ZONE x)
        """
        return _pcbnew.ZONES_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(ZONES self, std::vector< ZONE * >::iterator pos, ZONE x) -> std::vector< ZONE * >::iterator
        insert(ZONES self, std::vector< ZONE * >::iterator pos, std::vector< ZONE * >::size_type n, ZONE x)
        """
        return _pcbnew.ZONES_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(ZONES self, std::vector< ZONE * >::size_type n)"""
        return _pcbnew.ZONES_reserve(self, n)
 
    def capacity(self):
        r"""capacity(ZONES self) -> std::vector< ZONE * >::size_type"""
        return _pcbnew.ZONES_capacity(self)
    __swig_destroy__ = _pcbnew.delete_ZONES
 
# Register ZONES in _pcbnew:
_pcbnew.ZONES_swigregister(ZONES)
class TRACKS(object):
    r"""Proxy of C++ std::deque< PCB_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::deque< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j) -> TRACKS"""
        return _pcbnew.TRACKS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j)
        __setslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j, TRACKS v)
        """
        return _pcbnew.TRACKS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j)"""
        return _pcbnew.TRACKS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i)
        __delitem__(TRACKS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.TRACKS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(TRACKS self, SWIGPY_SLICEOBJECT * slice) -> TRACKS
        __getitem__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i) -> PCB_TRACK
        """
        return _pcbnew.TRACKS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(TRACKS self, SWIGPY_SLICEOBJECT * slice, TRACKS v)
        __setitem__(TRACKS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, PCB_TRACK x)
        """
        return _pcbnew.TRACKS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(TRACKS self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_pop(self)
 
    def append(self, x):
        r"""append(TRACKS self, PCB_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::deque< PCB_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::deque< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_begin(self)
 
    def end(self):
        r"""end(TRACKS self) -> std::deque< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_end(self)
 
    def rbegin(self):
        r"""rbegin(TRACKS self) -> std::deque< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rbegin(self)
 
    def rend(self):
        r"""rend(TRACKS self) -> std::deque< PCB_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::deque< PCB_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::deque< PCB_TRACK * >::iterator pos) -> std::deque< PCB_TRACK * >::iterator
        erase(TRACKS self, std::deque< PCB_TRACK * >::iterator first, std::deque< PCB_TRACK * >::iterator last) -> std::deque< PCB_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::deque< PCB_TRACK * >::size_type size) -> TRACKS
        __init__(TRACKS self, std::deque< PCB_TRACK * >::size_type size, PCB_TRACK value) -> TRACKS
        """
        _pcbnew.TRACKS_swiginit(self, _pcbnew.new_TRACKS(*args))
 
    def push_back(self, x):
        r"""push_back(TRACKS self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_push_back(self, x)
 
    def front(self):
        r"""front(TRACKS self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_front(self)
 
    def back(self):
        r"""back(TRACKS self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_back(self)
 
    def assign(self, n, x):
        r"""assign(TRACKS self, std::deque< PCB_TRACK * >::size_type n, PCB_TRACK x)"""
        return _pcbnew.TRACKS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(TRACKS self, std::deque< PCB_TRACK * >::size_type new_size)
        resize(TRACKS self, std::deque< PCB_TRACK * >::size_type new_size, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(TRACKS self, std::deque< PCB_TRACK * >::iterator pos, PCB_TRACK x) -> std::deque< PCB_TRACK * >::iterator
        insert(TRACKS self, std::deque< PCB_TRACK * >::iterator pos, std::deque< PCB_TRACK * >::size_type n, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(TRACKS self)"""
        return _pcbnew.TRACKS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(TRACKS self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_push_front(self, x)
 
    def __iter__(self):
        it = self.iterator()
        try:
            while True:
                item = it.next()  # throws StopIteration when iterator reached the end.
                yield item.Cast()
        except StopIteration:
            return
 
    __swig_destroy__ = _pcbnew.delete_TRACKS
 
# Register TRACKS in _pcbnew:
_pcbnew.TRACKS_swigregister(TRACKS)
class FOOTPRINTS(object):
    r"""Proxy of C++ std::deque< FOOTPRINT * > 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(FOOTPRINTS self) -> SwigPyIterator"""
        return _pcbnew.FOOTPRINTS_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(FOOTPRINTS self) -> bool"""
        return _pcbnew.FOOTPRINTS___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(FOOTPRINTS self) -> bool"""
        return _pcbnew.FOOTPRINTS___bool__(self)
 
    def __len__(self):
        r"""__len__(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::size_type"""
        return _pcbnew.FOOTPRINTS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j) -> FOOTPRINTS"""
        return _pcbnew.FOOTPRINTS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j)
        __setslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j, FOOTPRINTS v)
        """
        return _pcbnew.FOOTPRINTS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j)"""
        return _pcbnew.FOOTPRINTS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i)
        __delitem__(FOOTPRINTS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.FOOTPRINTS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(FOOTPRINTS self, SWIGPY_SLICEOBJECT * slice) -> FOOTPRINTS
        __getitem__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i) -> FOOTPRINT
        """
        return _pcbnew.FOOTPRINTS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(FOOTPRINTS self, SWIGPY_SLICEOBJECT * slice, FOOTPRINTS v)
        __setitem__(FOOTPRINTS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, FOOTPRINT x)
        """
        return _pcbnew.FOOTPRINTS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(FOOTPRINTS self) -> FOOTPRINT"""
        return _pcbnew.FOOTPRINTS_pop(self)
 
    def append(self, x):
        r"""append(FOOTPRINTS self, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_append(self, x)
 
    def empty(self):
        r"""empty(FOOTPRINTS self) -> bool"""
        return _pcbnew.FOOTPRINTS_empty(self)
 
    def size(self):
        r"""size(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::size_type"""
        return _pcbnew.FOOTPRINTS_size(self)
 
    def swap(self, v):
        r"""swap(FOOTPRINTS self, FOOTPRINTS v)"""
        return _pcbnew.FOOTPRINTS_swap(self, v)
 
    def begin(self):
        r"""begin(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::iterator"""
        return _pcbnew.FOOTPRINTS_begin(self)
 
    def end(self):
        r"""end(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::iterator"""
        return _pcbnew.FOOTPRINTS_end(self)
 
    def rbegin(self):
        r"""rbegin(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::reverse_iterator"""
        return _pcbnew.FOOTPRINTS_rbegin(self)
 
    def rend(self):
        r"""rend(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::reverse_iterator"""
        return _pcbnew.FOOTPRINTS_rend(self)
 
    def clear(self):
        r"""clear(FOOTPRINTS self)"""
        return _pcbnew.FOOTPRINTS_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::allocator_type"""
        return _pcbnew.FOOTPRINTS_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(FOOTPRINTS self)"""
        return _pcbnew.FOOTPRINTS_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator pos) -> std::deque< FOOTPRINT * >::iterator
        erase(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator first, std::deque< FOOTPRINT * >::iterator last) -> std::deque< FOOTPRINT * >::iterator
        """
        return _pcbnew.FOOTPRINTS_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(FOOTPRINTS self) -> FOOTPRINTS
        __init__(FOOTPRINTS self, FOOTPRINTS other) -> FOOTPRINTS
        __init__(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type size) -> FOOTPRINTS
        __init__(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type size, FOOTPRINT value) -> FOOTPRINTS
        """
        _pcbnew.FOOTPRINTS_swiginit(self, _pcbnew.new_FOOTPRINTS(*args))
 
    def push_back(self, x):
        r"""push_back(FOOTPRINTS self, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_push_back(self, x)
 
    def front(self):
        r"""front(FOOTPRINTS self) -> FOOTPRINT"""
        return _pcbnew.FOOTPRINTS_front(self)
 
    def back(self):
        r"""back(FOOTPRINTS self) -> FOOTPRINT"""
        return _pcbnew.FOOTPRINTS_back(self)
 
    def assign(self, n, x):
        r"""assign(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type n, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type new_size)
        resize(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type new_size, FOOTPRINT x)
        """
        return _pcbnew.FOOTPRINTS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator pos, FOOTPRINT x) -> std::deque< FOOTPRINT * >::iterator
        insert(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator pos, std::deque< FOOTPRINT * >::size_type n, FOOTPRINT x)
        """
        return _pcbnew.FOOTPRINTS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(FOOTPRINTS self)"""
        return _pcbnew.FOOTPRINTS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(FOOTPRINTS self, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_FOOTPRINTS
 
# Register FOOTPRINTS in _pcbnew:
_pcbnew.FOOTPRINTS_swigregister(FOOTPRINTS)
class GROUPS(object):
    r"""Proxy of C++ std::deque< PCB_GROUP * > 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(GROUPS self) -> SwigPyIterator"""
        return _pcbnew.GROUPS_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(GROUPS self) -> bool"""
        return _pcbnew.GROUPS___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(GROUPS self) -> bool"""
        return _pcbnew.GROUPS___bool__(self)
 
    def __len__(self):
        r"""__len__(GROUPS self) -> std::deque< PCB_GROUP * >::size_type"""
        return _pcbnew.GROUPS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j) -> GROUPS"""
        return _pcbnew.GROUPS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j)
        __setslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j, GROUPS v)
        """
        return _pcbnew.GROUPS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j)"""
        return _pcbnew.GROUPS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i)
        __delitem__(GROUPS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.GROUPS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(GROUPS self, SWIGPY_SLICEOBJECT * slice) -> GROUPS
        __getitem__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i) -> PCB_GROUP
        """
        return _pcbnew.GROUPS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(GROUPS self, SWIGPY_SLICEOBJECT * slice, GROUPS v)
        __setitem__(GROUPS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, PCB_GROUP x)
        """
        return _pcbnew.GROUPS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(GROUPS self) -> PCB_GROUP"""
        return _pcbnew.GROUPS_pop(self)
 
    def append(self, x):
        r"""append(GROUPS self, PCB_GROUP x)"""
        return _pcbnew.GROUPS_append(self, x)
 
    def empty(self):
        r"""empty(GROUPS self) -> bool"""
        return _pcbnew.GROUPS_empty(self)
 
    def size(self):
        r"""size(GROUPS self) -> std::deque< PCB_GROUP * >::size_type"""
        return _pcbnew.GROUPS_size(self)
 
    def swap(self, v):
        r"""swap(GROUPS self, GROUPS v)"""
        return _pcbnew.GROUPS_swap(self, v)
 
    def begin(self):
        r"""begin(GROUPS self) -> std::deque< PCB_GROUP * >::iterator"""
        return _pcbnew.GROUPS_begin(self)
 
    def end(self):
        r"""end(GROUPS self) -> std::deque< PCB_GROUP * >::iterator"""
        return _pcbnew.GROUPS_end(self)
 
    def rbegin(self):
        r"""rbegin(GROUPS self) -> std::deque< PCB_GROUP * >::reverse_iterator"""
        return _pcbnew.GROUPS_rbegin(self)
 
    def rend(self):
        r"""rend(GROUPS self) -> std::deque< PCB_GROUP * >::reverse_iterator"""
        return _pcbnew.GROUPS_rend(self)
 
    def clear(self):
        r"""clear(GROUPS self)"""
        return _pcbnew.GROUPS_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(GROUPS self) -> std::deque< PCB_GROUP * >::allocator_type"""
        return _pcbnew.GROUPS_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(GROUPS self)"""
        return _pcbnew.GROUPS_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(GROUPS self, std::deque< PCB_GROUP * >::iterator pos) -> std::deque< PCB_GROUP * >::iterator
        erase(GROUPS self, std::deque< PCB_GROUP * >::iterator first, std::deque< PCB_GROUP * >::iterator last) -> std::deque< PCB_GROUP * >::iterator
        """
        return _pcbnew.GROUPS_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(GROUPS self) -> GROUPS
        __init__(GROUPS self, GROUPS other) -> GROUPS
        __init__(GROUPS self, std::deque< PCB_GROUP * >::size_type size) -> GROUPS
        __init__(GROUPS self, std::deque< PCB_GROUP * >::size_type size, PCB_GROUP value) -> GROUPS
        """
        _pcbnew.GROUPS_swiginit(self, _pcbnew.new_GROUPS(*args))
 
    def push_back(self, x):
        r"""push_back(GROUPS self, PCB_GROUP x)"""
        return _pcbnew.GROUPS_push_back(self, x)
 
    def front(self):
        r"""front(GROUPS self) -> PCB_GROUP"""
        return _pcbnew.GROUPS_front(self)
 
    def back(self):
        r"""back(GROUPS self) -> PCB_GROUP"""
        return _pcbnew.GROUPS_back(self)
 
    def assign(self, n, x):
        r"""assign(GROUPS self, std::deque< PCB_GROUP * >::size_type n, PCB_GROUP x)"""
        return _pcbnew.GROUPS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(GROUPS self, std::deque< PCB_GROUP * >::size_type new_size)
        resize(GROUPS self, std::deque< PCB_GROUP * >::size_type new_size, PCB_GROUP x)
        """
        return _pcbnew.GROUPS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(GROUPS self, std::deque< PCB_GROUP * >::iterator pos, PCB_GROUP x) -> std::deque< PCB_GROUP * >::iterator
        insert(GROUPS self, std::deque< PCB_GROUP * >::iterator pos, std::deque< PCB_GROUP * >::size_type n, PCB_GROUP x)
        """
        return _pcbnew.GROUPS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(GROUPS self)"""
        return _pcbnew.GROUPS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(GROUPS self, PCB_GROUP x)"""
        return _pcbnew.GROUPS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_GROUPS
 
# Register GROUPS in _pcbnew:
_pcbnew.GROUPS_swigregister(GROUPS)
class GENERATORS(object):
    r"""Proxy of C++ std::deque< PCB_GENERATOR * > 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(GENERATORS self) -> SwigPyIterator"""
        return _pcbnew.GENERATORS_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(GENERATORS self) -> bool"""
        return _pcbnew.GENERATORS___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(GENERATORS self) -> bool"""
        return _pcbnew.GENERATORS___bool__(self)
 
    def __len__(self):
        r"""__len__(GENERATORS self) -> std::deque< PCB_GENERATOR * >::size_type"""
        return _pcbnew.GENERATORS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i, std::deque< PCB_GENERATOR * >::difference_type j) -> GENERATORS"""
        return _pcbnew.GENERATORS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i, std::deque< PCB_GENERATOR * >::difference_type j)
        __setslice__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i, std::deque< PCB_GENERATOR * >::difference_type j, GENERATORS v)
        """
        return _pcbnew.GENERATORS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i, std::deque< PCB_GENERATOR * >::difference_type j)"""
        return _pcbnew.GENERATORS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i)
        __delitem__(GENERATORS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.GENERATORS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(GENERATORS self, SWIGPY_SLICEOBJECT * slice) -> GENERATORS
        __getitem__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i) -> std::deque< PCB_GENERATOR * >::value_type
        """
        return _pcbnew.GENERATORS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(GENERATORS self, SWIGPY_SLICEOBJECT * slice, GENERATORS v)
        __setitem__(GENERATORS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(GENERATORS self, std::deque< PCB_GENERATOR * >::difference_type i, std::deque< PCB_GENERATOR * >::value_type x)
        """
        return _pcbnew.GENERATORS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(GENERATORS self) -> std::deque< PCB_GENERATOR * >::value_type"""
        return _pcbnew.GENERATORS_pop(self)
 
    def append(self, x):
        r"""append(GENERATORS self, std::deque< PCB_GENERATOR * >::value_type x)"""
        return _pcbnew.GENERATORS_append(self, x)
 
    def empty(self):
        r"""empty(GENERATORS self) -> bool"""
        return _pcbnew.GENERATORS_empty(self)
 
    def size(self):
        r"""size(GENERATORS self) -> std::deque< PCB_GENERATOR * >::size_type"""
        return _pcbnew.GENERATORS_size(self)
 
    def swap(self, v):
        r"""swap(GENERATORS self, GENERATORS v)"""
        return _pcbnew.GENERATORS_swap(self, v)
 
    def begin(self):
        r"""begin(GENERATORS self) -> std::deque< PCB_GENERATOR * >::iterator"""
        return _pcbnew.GENERATORS_begin(self)
 
    def end(self):
        r"""end(GENERATORS self) -> std::deque< PCB_GENERATOR * >::iterator"""
        return _pcbnew.GENERATORS_end(self)
 
    def rbegin(self):
        r"""rbegin(GENERATORS self) -> std::deque< PCB_GENERATOR * >::reverse_iterator"""
        return _pcbnew.GENERATORS_rbegin(self)
 
    def rend(self):
        r"""rend(GENERATORS self) -> std::deque< PCB_GENERATOR * >::reverse_iterator"""
        return _pcbnew.GENERATORS_rend(self)
 
    def clear(self):
        r"""clear(GENERATORS self)"""
        return _pcbnew.GENERATORS_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(GENERATORS self) -> std::deque< PCB_GENERATOR * >::allocator_type"""
        return _pcbnew.GENERATORS_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(GENERATORS self)"""
        return _pcbnew.GENERATORS_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(GENERATORS self, std::deque< PCB_GENERATOR * >::iterator pos) -> std::deque< PCB_GENERATOR * >::iterator
        erase(GENERATORS self, std::deque< PCB_GENERATOR * >::iterator first, std::deque< PCB_GENERATOR * >::iterator last) -> std::deque< PCB_GENERATOR * >::iterator
        """
        return _pcbnew.GENERATORS_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(GENERATORS self) -> GENERATORS
        __init__(GENERATORS self, GENERATORS other) -> GENERATORS
        __init__(GENERATORS self, std::deque< PCB_GENERATOR * >::size_type size) -> GENERATORS
        __init__(GENERATORS self, std::deque< PCB_GENERATOR * >::size_type size, std::deque< PCB_GENERATOR * >::value_type value) -> GENERATORS
        """
        _pcbnew.GENERATORS_swiginit(self, _pcbnew.new_GENERATORS(*args))
 
    def push_back(self, x):
        r"""push_back(GENERATORS self, std::deque< PCB_GENERATOR * >::value_type x)"""
        return _pcbnew.GENERATORS_push_back(self, x)
 
    def front(self):
        r"""front(GENERATORS self) -> std::deque< PCB_GENERATOR * >::value_type"""
        return _pcbnew.GENERATORS_front(self)
 
    def back(self):
        r"""back(GENERATORS self) -> std::deque< PCB_GENERATOR * >::value_type"""
        return _pcbnew.GENERATORS_back(self)
 
    def assign(self, n, x):
        r"""assign(GENERATORS self, std::deque< PCB_GENERATOR * >::size_type n, std::deque< PCB_GENERATOR * >::value_type x)"""
        return _pcbnew.GENERATORS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(GENERATORS self, std::deque< PCB_GENERATOR * >::size_type new_size)
        resize(GENERATORS self, std::deque< PCB_GENERATOR * >::size_type new_size, std::deque< PCB_GENERATOR * >::value_type x)
        """
        return _pcbnew.GENERATORS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(GENERATORS self, std::deque< PCB_GENERATOR * >::iterator pos, std::deque< PCB_GENERATOR * >::value_type x) -> std::deque< PCB_GENERATOR * >::iterator
        insert(GENERATORS self, std::deque< PCB_GENERATOR * >::iterator pos, std::deque< PCB_GENERATOR * >::size_type n, std::deque< PCB_GENERATOR * >::value_type x)
        """
        return _pcbnew.GENERATORS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(GENERATORS self)"""
        return _pcbnew.GENERATORS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(GENERATORS self, std::deque< PCB_GENERATOR * >::value_type x)"""
        return _pcbnew.GENERATORS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_GENERATORS
 
# Register GENERATORS in _pcbnew:
_pcbnew.GENERATORS_swigregister(GENERATORS)
class DRAWINGS(object):
    r"""Proxy of C++ std::deque< 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 iterator(self):
        r"""iterator(DRAWINGS self) -> SwigPyIterator"""
        return _pcbnew.DRAWINGS_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(DRAWINGS self) -> bool"""
        return _pcbnew.DRAWINGS___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(DRAWINGS self) -> bool"""
        return _pcbnew.DRAWINGS___bool__(self)
 
    def __len__(self):
        r"""__len__(DRAWINGS self) -> std::deque< BOARD_ITEM * >::size_type"""
        return _pcbnew.DRAWINGS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j) -> DRAWINGS"""
        return _pcbnew.DRAWINGS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j)
        __setslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j, DRAWINGS v)
        """
        return _pcbnew.DRAWINGS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j)"""
        return _pcbnew.DRAWINGS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i)
        __delitem__(DRAWINGS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.DRAWINGS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(DRAWINGS self, SWIGPY_SLICEOBJECT * slice) -> DRAWINGS
        __getitem__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i) -> BOARD_ITEM
        """
        return _pcbnew.DRAWINGS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(DRAWINGS self, SWIGPY_SLICEOBJECT * slice, DRAWINGS v)
        __setitem__(DRAWINGS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, BOARD_ITEM x)
        """
        return _pcbnew.DRAWINGS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(DRAWINGS self) -> BOARD_ITEM"""
        return _pcbnew.DRAWINGS_pop(self)
 
    def append(self, x):
        r"""append(DRAWINGS self, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_append(self, x)
 
    def empty(self):
        r"""empty(DRAWINGS self) -> bool"""
        return _pcbnew.DRAWINGS_empty(self)
 
    def size(self):
        r"""size(DRAWINGS self) -> std::deque< BOARD_ITEM * >::size_type"""
        return _pcbnew.DRAWINGS_size(self)
 
    def swap(self, v):
        r"""swap(DRAWINGS self, DRAWINGS v)"""
        return _pcbnew.DRAWINGS_swap(self, v)
 
    def begin(self):
        r"""begin(DRAWINGS self) -> std::deque< BOARD_ITEM * >::iterator"""
        return _pcbnew.DRAWINGS_begin(self)
 
    def end(self):
        r"""end(DRAWINGS self) -> std::deque< BOARD_ITEM * >::iterator"""
        return _pcbnew.DRAWINGS_end(self)
 
    def rbegin(self):
        r"""rbegin(DRAWINGS self) -> std::deque< BOARD_ITEM * >::reverse_iterator"""
        return _pcbnew.DRAWINGS_rbegin(self)
 
    def rend(self):
        r"""rend(DRAWINGS self) -> std::deque< BOARD_ITEM * >::reverse_iterator"""
        return _pcbnew.DRAWINGS_rend(self)
 
    def clear(self):
        r"""clear(DRAWINGS self)"""
        return _pcbnew.DRAWINGS_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(DRAWINGS self) -> std::deque< BOARD_ITEM * >::allocator_type"""
        return _pcbnew.DRAWINGS_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(DRAWINGS self)"""
        return _pcbnew.DRAWINGS_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator pos) -> std::deque< BOARD_ITEM * >::iterator
        erase(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator first, std::deque< BOARD_ITEM * >::iterator last) -> std::deque< BOARD_ITEM * >::iterator
        """
        return _pcbnew.DRAWINGS_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(DRAWINGS self) -> DRAWINGS
        __init__(DRAWINGS self, DRAWINGS other) -> DRAWINGS
        __init__(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type size) -> DRAWINGS
        __init__(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type size, BOARD_ITEM value) -> DRAWINGS
        """
        _pcbnew.DRAWINGS_swiginit(self, _pcbnew.new_DRAWINGS(*args))
 
    def push_back(self, x):
        r"""push_back(DRAWINGS self, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_push_back(self, x)
 
    def front(self):
        r"""front(DRAWINGS self) -> BOARD_ITEM"""
        return _pcbnew.DRAWINGS_front(self)
 
    def back(self):
        r"""back(DRAWINGS self) -> BOARD_ITEM"""
        return _pcbnew.DRAWINGS_back(self)
 
    def assign(self, n, x):
        r"""assign(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type n, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type new_size)
        resize(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type new_size, BOARD_ITEM x)
        """
        return _pcbnew.DRAWINGS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator pos, BOARD_ITEM x) -> std::deque< BOARD_ITEM * >::iterator
        insert(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator pos, std::deque< BOARD_ITEM * >::size_type n, BOARD_ITEM x)
        """
        return _pcbnew.DRAWINGS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(DRAWINGS self)"""
        return _pcbnew.DRAWINGS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(DRAWINGS self, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_push_front(self, x)
 
    def __iter__(self):
        it = self.iterator()
        try:
            while True:
                item = it.next()  # throws StopIteration when iterator reached the end.
                yield item.Cast()
        except StopIteration:
            return
 
    __swig_destroy__ = _pcbnew.delete_DRAWINGS
 
# Register DRAWINGS in _pcbnew:
_pcbnew.DRAWINGS_swigregister(DRAWINGS)
class PADS(object):
    r"""Proxy of C++ std::deque< 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(PADS self) -> SwigPyIterator"""
        return _pcbnew.PADS_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(PADS self) -> bool"""
        return _pcbnew.PADS___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(PADS self) -> bool"""
        return _pcbnew.PADS___bool__(self)
 
    def __len__(self):
        r"""__len__(PADS self) -> std::deque< PAD * >::size_type"""
        return _pcbnew.PADS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j) -> PADS"""
        return _pcbnew.PADS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j)
        __setslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j, PADS v)
        """
        return _pcbnew.PADS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j)"""
        return _pcbnew.PADS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(PADS self, std::deque< PAD * >::difference_type i)
        __delitem__(PADS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.PADS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(PADS self, SWIGPY_SLICEOBJECT * slice) -> PADS
        __getitem__(PADS self, std::deque< PAD * >::difference_type i) -> PAD
        """
        return _pcbnew.PADS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(PADS self, SWIGPY_SLICEOBJECT * slice, PADS v)
        __setitem__(PADS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(PADS self, std::deque< PAD * >::difference_type i, PAD x)
        """
        return _pcbnew.PADS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(PADS self) -> PAD"""
        return _pcbnew.PADS_pop(self)
 
    def append(self, x):
        r"""append(PADS self, PAD x)"""
        return _pcbnew.PADS_append(self, x)
 
    def empty(self):
        r"""empty(PADS self) -> bool"""
        return _pcbnew.PADS_empty(self)
 
    def size(self):
        r"""size(PADS self) -> std::deque< PAD * >::size_type"""
        return _pcbnew.PADS_size(self)
 
    def swap(self, v):
        r"""swap(PADS self, PADS v)"""
        return _pcbnew.PADS_swap(self, v)
 
    def begin(self):
        r"""begin(PADS self) -> std::deque< PAD * >::iterator"""
        return _pcbnew.PADS_begin(self)
 
    def end(self):
        r"""end(PADS self) -> std::deque< PAD * >::iterator"""
        return _pcbnew.PADS_end(self)
 
    def rbegin(self):
        r"""rbegin(PADS self) -> std::deque< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_rbegin(self)
 
    def rend(self):
        r"""rend(PADS self) -> std::deque< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_rend(self)
 
    def clear(self):
        r"""clear(PADS self)"""
        return _pcbnew.PADS_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(PADS self) -> std::deque< PAD * >::allocator_type"""
        return _pcbnew.PADS_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(PADS self)"""
        return _pcbnew.PADS_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(PADS self, std::deque< PAD * >::iterator pos) -> std::deque< PAD * >::iterator
        erase(PADS self, std::deque< PAD * >::iterator first, std::deque< PAD * >::iterator last) -> std::deque< PAD * >::iterator
        """
        return _pcbnew.PADS_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(PADS self) -> PADS
        __init__(PADS self, PADS other) -> PADS
        __init__(PADS self, std::deque< PAD * >::size_type size) -> PADS
        __init__(PADS self, std::deque< PAD * >::size_type size, PAD value) -> PADS
        """
        _pcbnew.PADS_swiginit(self, _pcbnew.new_PADS(*args))
 
    def push_back(self, x):
        r"""push_back(PADS self, PAD x)"""
        return _pcbnew.PADS_push_back(self, x)
 
    def front(self):
        r"""front(PADS self) -> PAD"""
        return _pcbnew.PADS_front(self)
 
    def back(self):
        r"""back(PADS self) -> PAD"""
        return _pcbnew.PADS_back(self)
 
    def assign(self, n, x):
        r"""assign(PADS self, std::deque< PAD * >::size_type n, PAD x)"""
        return _pcbnew.PADS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(PADS self, std::deque< PAD * >::size_type new_size)
        resize(PADS self, std::deque< PAD * >::size_type new_size, PAD x)
        """
        return _pcbnew.PADS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(PADS self, std::deque< PAD * >::iterator pos, PAD x) -> std::deque< PAD * >::iterator
        insert(PADS self, std::deque< PAD * >::iterator pos, std::deque< PAD * >::size_type n, PAD x)
        """
        return _pcbnew.PADS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(PADS self)"""
        return _pcbnew.PADS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(PADS self, PAD x)"""
        return _pcbnew.PADS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_PADS
 
# Register PADS in _pcbnew:
_pcbnew.PADS_swigregister(PADS)
class PCB_FIELDS(object):
    r"""Proxy of C++ std::deque< PCB_FIELD * > 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(PCB_FIELDS self) -> SwigPyIterator"""
        return _pcbnew.PCB_FIELDS_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(PCB_FIELDS self) -> bool"""
        return _pcbnew.PCB_FIELDS___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(PCB_FIELDS self) -> bool"""
        return _pcbnew.PCB_FIELDS___bool__(self)
 
    def __len__(self):
        r"""__len__(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::size_type"""
        return _pcbnew.PCB_FIELDS___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i, std::deque< PCB_FIELD * >::difference_type j) -> PCB_FIELDS"""
        return _pcbnew.PCB_FIELDS___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i, std::deque< PCB_FIELD * >::difference_type j)
        __setslice__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i, std::deque< PCB_FIELD * >::difference_type j, PCB_FIELDS v)
        """
        return _pcbnew.PCB_FIELDS___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i, std::deque< PCB_FIELD * >::difference_type j)"""
        return _pcbnew.PCB_FIELDS___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i)
        __delitem__(PCB_FIELDS self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.PCB_FIELDS___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(PCB_FIELDS self, SWIGPY_SLICEOBJECT * slice) -> PCB_FIELDS
        __getitem__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i) -> PCB_FIELD
        """
        return _pcbnew.PCB_FIELDS___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(PCB_FIELDS self, SWIGPY_SLICEOBJECT * slice, PCB_FIELDS v)
        __setitem__(PCB_FIELDS self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(PCB_FIELDS self, std::deque< PCB_FIELD * >::difference_type i, PCB_FIELD x)
        """
        return _pcbnew.PCB_FIELDS___setitem__(self, *args)
 
    def pop(self):
        r"""pop(PCB_FIELDS self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELDS_pop(self)
 
    def append(self, x):
        r"""append(PCB_FIELDS self, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELDS_append(self, x)
 
    def empty(self):
        r"""empty(PCB_FIELDS self) -> bool"""
        return _pcbnew.PCB_FIELDS_empty(self)
 
    def size(self):
        r"""size(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::size_type"""
        return _pcbnew.PCB_FIELDS_size(self)
 
    def swap(self, v):
        r"""swap(PCB_FIELDS self, PCB_FIELDS v)"""
        return _pcbnew.PCB_FIELDS_swap(self, v)
 
    def begin(self):
        r"""begin(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::iterator"""
        return _pcbnew.PCB_FIELDS_begin(self)
 
    def end(self):
        r"""end(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::iterator"""
        return _pcbnew.PCB_FIELDS_end(self)
 
    def rbegin(self):
        r"""rbegin(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::reverse_iterator"""
        return _pcbnew.PCB_FIELDS_rbegin(self)
 
    def rend(self):
        r"""rend(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::reverse_iterator"""
        return _pcbnew.PCB_FIELDS_rend(self)
 
    def clear(self):
        r"""clear(PCB_FIELDS self)"""
        return _pcbnew.PCB_FIELDS_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(PCB_FIELDS self) -> std::deque< PCB_FIELD * >::allocator_type"""
        return _pcbnew.PCB_FIELDS_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(PCB_FIELDS self)"""
        return _pcbnew.PCB_FIELDS_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(PCB_FIELDS self, std::deque< PCB_FIELD * >::iterator pos) -> std::deque< PCB_FIELD * >::iterator
        erase(PCB_FIELDS self, std::deque< PCB_FIELD * >::iterator first, std::deque< PCB_FIELD * >::iterator last) -> std::deque< PCB_FIELD * >::iterator
        """
        return _pcbnew.PCB_FIELDS_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(PCB_FIELDS self) -> PCB_FIELDS
        __init__(PCB_FIELDS self, PCB_FIELDS other) -> PCB_FIELDS
        __init__(PCB_FIELDS self, std::deque< PCB_FIELD * >::size_type size) -> PCB_FIELDS
        __init__(PCB_FIELDS self, std::deque< PCB_FIELD * >::size_type size, PCB_FIELD value) -> PCB_FIELDS
        """
        _pcbnew.PCB_FIELDS_swiginit(self, _pcbnew.new_PCB_FIELDS(*args))
 
    def push_back(self, x):
        r"""push_back(PCB_FIELDS self, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELDS_push_back(self, x)
 
    def front(self):
        r"""front(PCB_FIELDS self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELDS_front(self)
 
    def back(self):
        r"""back(PCB_FIELDS self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELDS_back(self)
 
    def assign(self, n, x):
        r"""assign(PCB_FIELDS self, std::deque< PCB_FIELD * >::size_type n, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELDS_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(PCB_FIELDS self, std::deque< PCB_FIELD * >::size_type new_size)
        resize(PCB_FIELDS self, std::deque< PCB_FIELD * >::size_type new_size, PCB_FIELD x)
        """
        return _pcbnew.PCB_FIELDS_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(PCB_FIELDS self, std::deque< PCB_FIELD * >::iterator pos, PCB_FIELD x) -> std::deque< PCB_FIELD * >::iterator
        insert(PCB_FIELDS self, std::deque< PCB_FIELD * >::iterator pos, std::deque< PCB_FIELD * >::size_type n, PCB_FIELD x)
        """
        return _pcbnew.PCB_FIELDS_insert(self, *args)
 
    def pop_front(self):
        r"""pop_front(PCB_FIELDS self)"""
        return _pcbnew.PCB_FIELDS_pop_front(self)
 
    def push_front(self, x):
        r"""push_front(PCB_FIELDS self, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELDS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_PCB_FIELDS
 
# Register PCB_FIELDS in _pcbnew:
_pcbnew.PCB_FIELDS_swigregister(PCB_FIELDS)
class PCB_FIELD_VEC(object):
    r"""Proxy of C++ std::vector< PCB_FIELD * > 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(PCB_FIELD_VEC self) -> SwigPyIterator"""
        return _pcbnew.PCB_FIELD_VEC_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(PCB_FIELD_VEC self) -> bool"""
        return _pcbnew.PCB_FIELD_VEC___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(PCB_FIELD_VEC self) -> bool"""
        return _pcbnew.PCB_FIELD_VEC___bool__(self)
 
    def __len__(self):
        r"""__len__(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::size_type"""
        return _pcbnew.PCB_FIELD_VEC___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i, std::vector< PCB_FIELD * >::difference_type j) -> PCB_FIELD_VEC"""
        return _pcbnew.PCB_FIELD_VEC___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i, std::vector< PCB_FIELD * >::difference_type j)
        __setslice__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i, std::vector< PCB_FIELD * >::difference_type j, PCB_FIELD_VEC v)
        """
        return _pcbnew.PCB_FIELD_VEC___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i, std::vector< PCB_FIELD * >::difference_type j)"""
        return _pcbnew.PCB_FIELD_VEC___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i)
        __delitem__(PCB_FIELD_VEC self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.PCB_FIELD_VEC___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(PCB_FIELD_VEC self, SWIGPY_SLICEOBJECT * slice) -> PCB_FIELD_VEC
        __getitem__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i) -> PCB_FIELD
        """
        return _pcbnew.PCB_FIELD_VEC___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(PCB_FIELD_VEC self, SWIGPY_SLICEOBJECT * slice, PCB_FIELD_VEC v)
        __setitem__(PCB_FIELD_VEC self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::difference_type i, PCB_FIELD x)
        """
        return _pcbnew.PCB_FIELD_VEC___setitem__(self, *args)
 
    def pop(self):
        r"""pop(PCB_FIELD_VEC self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELD_VEC_pop(self)
 
    def append(self, x):
        r"""append(PCB_FIELD_VEC self, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELD_VEC_append(self, x)
 
    def empty(self):
        r"""empty(PCB_FIELD_VEC self) -> bool"""
        return _pcbnew.PCB_FIELD_VEC_empty(self)
 
    def size(self):
        r"""size(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::size_type"""
        return _pcbnew.PCB_FIELD_VEC_size(self)
 
    def swap(self, v):
        r"""swap(PCB_FIELD_VEC self, PCB_FIELD_VEC v)"""
        return _pcbnew.PCB_FIELD_VEC_swap(self, v)
 
    def begin(self):
        r"""begin(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::iterator"""
        return _pcbnew.PCB_FIELD_VEC_begin(self)
 
    def end(self):
        r"""end(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::iterator"""
        return _pcbnew.PCB_FIELD_VEC_end(self)
 
    def rbegin(self):
        r"""rbegin(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::reverse_iterator"""
        return _pcbnew.PCB_FIELD_VEC_rbegin(self)
 
    def rend(self):
        r"""rend(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::reverse_iterator"""
        return _pcbnew.PCB_FIELD_VEC_rend(self)
 
    def clear(self):
        r"""clear(PCB_FIELD_VEC self)"""
        return _pcbnew.PCB_FIELD_VEC_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::allocator_type"""
        return _pcbnew.PCB_FIELD_VEC_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(PCB_FIELD_VEC self)"""
        return _pcbnew.PCB_FIELD_VEC_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::iterator pos) -> std::vector< PCB_FIELD * >::iterator
        erase(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::iterator first, std::vector< PCB_FIELD * >::iterator last) -> std::vector< PCB_FIELD * >::iterator
        """
        return _pcbnew.PCB_FIELD_VEC_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(PCB_FIELD_VEC self) -> PCB_FIELD_VEC
        __init__(PCB_FIELD_VEC self, PCB_FIELD_VEC other) -> PCB_FIELD_VEC
        __init__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::size_type size) -> PCB_FIELD_VEC
        __init__(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::size_type size, PCB_FIELD value) -> PCB_FIELD_VEC
        """
        _pcbnew.PCB_FIELD_VEC_swiginit(self, _pcbnew.new_PCB_FIELD_VEC(*args))
 
    def push_back(self, x):
        r"""push_back(PCB_FIELD_VEC self, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELD_VEC_push_back(self, x)
 
    def front(self):
        r"""front(PCB_FIELD_VEC self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELD_VEC_front(self)
 
    def back(self):
        r"""back(PCB_FIELD_VEC self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELD_VEC_back(self)
 
    def assign(self, n, x):
        r"""assign(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::size_type n, PCB_FIELD x)"""
        return _pcbnew.PCB_FIELD_VEC_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::size_type new_size)
        resize(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::size_type new_size, PCB_FIELD x)
        """
        return _pcbnew.PCB_FIELD_VEC_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::iterator pos, PCB_FIELD x) -> std::vector< PCB_FIELD * >::iterator
        insert(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::iterator pos, std::vector< PCB_FIELD * >::size_type n, PCB_FIELD x)
        """
        return _pcbnew.PCB_FIELD_VEC_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(PCB_FIELD_VEC self, std::vector< PCB_FIELD * >::size_type n)"""
        return _pcbnew.PCB_FIELD_VEC_reserve(self, n)
 
    def capacity(self):
        r"""capacity(PCB_FIELD_VEC self) -> std::vector< PCB_FIELD * >::size_type"""
        return _pcbnew.PCB_FIELD_VEC_capacity(self)
    __swig_destroy__ = _pcbnew.delete_PCB_FIELD_VEC
 
# Register PCB_FIELD_VEC in _pcbnew:
_pcbnew.PCB_FIELD_VEC_swigregister(PCB_FIELD_VEC)
PAD_SHAPE_CIRCLE = _pcbnew.PAD_SHAPE_CIRCLE
 
PAD_SHAPE_RECTANGLE = _pcbnew.PAD_SHAPE_RECTANGLE
 
PAD_SHAPE_OVAL = _pcbnew.PAD_SHAPE_OVAL
 
PAD_SHAPE_TRAPEZOID = _pcbnew.PAD_SHAPE_TRAPEZOID
 
PAD_SHAPE_ROUNDRECT = _pcbnew.PAD_SHAPE_ROUNDRECT
 
PAD_SHAPE_CHAMFERED_RECT = _pcbnew.PAD_SHAPE_CHAMFERED_RECT
 
PAD_SHAPE_CUSTOM = _pcbnew.PAD_SHAPE_CUSTOM
 
PAD_DRILL_SHAPE_UNDEFINED = _pcbnew.PAD_DRILL_SHAPE_UNDEFINED
 
PAD_DRILL_SHAPE_CIRCLE = _pcbnew.PAD_DRILL_SHAPE_CIRCLE
 
PAD_DRILL_SHAPE_OBLONG = _pcbnew.PAD_DRILL_SHAPE_OBLONG
 
PAD_ATTRIB_PTH = _pcbnew.PAD_ATTRIB_PTH
 
PAD_ATTRIB_SMD = _pcbnew.PAD_ATTRIB_SMD
 
PAD_ATTRIB_CONN = _pcbnew.PAD_ATTRIB_CONN
 
PAD_ATTRIB_NPTH = _pcbnew.PAD_ATTRIB_NPTH
 
PAD_PROP_NONE = _pcbnew.PAD_PROP_NONE
 
PAD_PROP_BGA = _pcbnew.PAD_PROP_BGA
 
PAD_PROP_FIDUCIAL_GLBL = _pcbnew.PAD_PROP_FIDUCIAL_GLBL
 
PAD_PROP_FIDUCIAL_LOCAL = _pcbnew.PAD_PROP_FIDUCIAL_LOCAL
 
PAD_PROP_TESTPOINT = _pcbnew.PAD_PROP_TESTPOINT
 
PAD_PROP_HEATSINK = _pcbnew.PAD_PROP_HEATSINK
 
PAD_PROP_CASTELLATED = _pcbnew.PAD_PROP_CASTELLATED
 
PAD_PROP_MECHANICAL = _pcbnew.PAD_PROP_MECHANICAL
 
class PADSTACK(object):
    r"""Proxy of C++ PADSTACK class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TYPE_NORMAL = _pcbnew.PADSTACK_TYPE_NORMAL
    
    TYPE_VIA = _pcbnew.PADSTACK_TYPE_VIA
    
    TYPE_MOUNTING = _pcbnew.PADSTACK_TYPE_MOUNTING
    
    MODE_NORMAL = _pcbnew.PADSTACK_MODE_NORMAL
    
    MODE_FRONT_INNER_BACK = _pcbnew.PADSTACK_MODE_FRONT_INNER_BACK
    
    MODE_CUSTOM = _pcbnew.PADSTACK_MODE_CUSTOM
    
    ALL_LAYERS = _pcbnew.PADSTACK_ALL_LAYERS
    
    INNER_LAYERS = _pcbnew.PADSTACK_INNER_LAYERS
    
    UNCONNECTED_LAYER_MODE_KEEP_ALL = _pcbnew.PADSTACK_UNCONNECTED_LAYER_MODE_KEEP_ALL
    
    UNCONNECTED_LAYER_MODE_REMOVE_ALL = _pcbnew.PADSTACK_UNCONNECTED_LAYER_MODE_REMOVE_ALL
    
    UNCONNECTED_LAYER_MODE_REMOVE_EXCEPT_START_AND_END = _pcbnew.PADSTACK_UNCONNECTED_LAYER_MODE_REMOVE_EXCEPT_START_AND_END
    
    CUSTOM_SHAPE_ZONE_MODE_OUTLINE = _pcbnew.PADSTACK_CUSTOM_SHAPE_ZONE_MODE_OUTLINE
    
    CUSTOM_SHAPE_ZONE_MODE_CONVEXHULL = _pcbnew.PADSTACK_CUSTOM_SHAPE_ZONE_MODE_CONVEXHULL
    
    __swig_destroy__ = _pcbnew.delete_PADSTACK
 
    def __init__(self, *args):
        r"""
        __init__(PADSTACK self, BOARD_ITEM aParent) -> PADSTACK
        __init__(PADSTACK self, PADSTACK aOther) -> PADSTACK
        """
        _pcbnew.PADSTACK_swiginit(self, _pcbnew.new_PADSTACK(*args))
 
    def __eq__(self, aOther):
        r"""__eq__(PADSTACK self, PADSTACK aOther) -> bool"""
        return _pcbnew.PADSTACK___eq__(self, aOther)
 
    def __ne__(self, aOther):
        r"""__ne__(PADSTACK self, PADSTACK aOther) -> bool"""
        return _pcbnew.PADSTACK___ne__(self, aOther)
 
    def Serialize(self, aContainer):
        r"""Serialize(PADSTACK self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PADSTACK_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PADSTACK self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PADSTACK_Deserialize(self, aContainer)
 
    @staticmethod
    def Compare(aPadstackRef, aPadstackCmp):
        r"""Compare(PADSTACK aPadstackRef, PADSTACK aPadstackCmp) -> int"""
        return _pcbnew.PADSTACK_Compare(aPadstackRef, aPadstackCmp)
 
    def Similarity(self, aOther):
        r"""Similarity(PADSTACK self, PADSTACK aOther) -> double"""
        return _pcbnew.PADSTACK_Similarity(self, aOther)
 
    def LayerSet(self, *args):
        r"""
        LayerSet(PADSTACK self) -> LSET
        LayerSet(PADSTACK self) -> LSET
        """
        return _pcbnew.PADSTACK_LayerSet(self, *args)
 
    def SetLayerSet(self, aSet):
        r"""SetLayerSet(PADSTACK self, LSET aSet)"""
        return _pcbnew.PADSTACK_SetLayerSet(self, aSet)
 
    def FlipLayers(self, aCopperLayerCount):
        r"""FlipLayers(PADSTACK self, int aCopperLayerCount)"""
        return _pcbnew.PADSTACK_FlipLayers(self, aCopperLayerCount)
 
    def StartLayer(self):
        r"""StartLayer(PADSTACK self) -> PCB_LAYER_ID"""
        return _pcbnew.PADSTACK_StartLayer(self)
 
    def EndLayer(self):
        r"""EndLayer(PADSTACK self) -> PCB_LAYER_ID"""
        return _pcbnew.PADSTACK_EndLayer(self)
 
    def Mode(self):
        r"""Mode(PADSTACK self) -> PADSTACK::MODE"""
        return _pcbnew.PADSTACK_Mode(self)
 
    def SetMode(self, aMode):
        r"""SetMode(PADSTACK self, PADSTACK::MODE aMode)"""
        return _pcbnew.PADSTACK_SetMode(self, aMode)
 
    def Name(self):
        r"""Name(PADSTACK self) -> wxString"""
        return _pcbnew.PADSTACK_Name(self)
 
    def GetOrientation(self):
        r"""GetOrientation(PADSTACK self) -> EDA_ANGLE"""
        return _pcbnew.PADSTACK_GetOrientation(self)
 
    def SetOrientation(self, aAngle):
        r"""SetOrientation(PADSTACK self, EDA_ANGLE aAngle)"""
        return _pcbnew.PADSTACK_SetOrientation(self, aAngle)
 
    def Drill(self, *args):
        r"""
        Drill(PADSTACK self) -> PADSTACK::DRILL_PROPS
        Drill(PADSTACK self) -> PADSTACK::DRILL_PROPS const &
        """
        return _pcbnew.PADSTACK_Drill(self, *args)
 
    def SecondaryDrill(self, *args):
        r"""
        SecondaryDrill(PADSTACK self) -> PADSTACK::DRILL_PROPS
        SecondaryDrill(PADSTACK self) -> PADSTACK::DRILL_PROPS const &
        """
        return _pcbnew.PADSTACK_SecondaryDrill(self, *args)
 
    def UnconnectedLayerMode(self):
        r"""UnconnectedLayerMode(PADSTACK self) -> PADSTACK::UNCONNECTED_LAYER_MODE"""
        return _pcbnew.PADSTACK_UnconnectedLayerMode(self)
 
    def SetUnconnectedLayerMode(self, aMode):
        r"""SetUnconnectedLayerMode(PADSTACK self, PADSTACK::UNCONNECTED_LAYER_MODE aMode)"""
        return _pcbnew.PADSTACK_SetUnconnectedLayerMode(self, aMode)
 
    def CopperLayer(self, *args):
        r"""
        CopperLayer(PADSTACK self, PCB_LAYER_ID aLayer) -> PADSTACK::COPPER_LAYER_PROPS
        CopperLayer(PADSTACK self, PCB_LAYER_ID aLayer) -> PADSTACK::COPPER_LAYER_PROPS const &
        """
        return _pcbnew.PADSTACK_CopperLayer(self, *args)
 
    def FrontOuterLayers(self, *args):
        r"""
        FrontOuterLayers(PADSTACK self) -> PADSTACK::MASK_LAYER_PROPS
        FrontOuterLayers(PADSTACK self) -> PADSTACK::MASK_LAYER_PROPS const &
        """
        return _pcbnew.PADSTACK_FrontOuterLayers(self, *args)
 
    def BackOuterLayers(self, *args):
        r"""
        BackOuterLayers(PADSTACK self) -> PADSTACK::MASK_LAYER_PROPS
        BackOuterLayers(PADSTACK self) -> PADSTACK::MASK_LAYER_PROPS const &
        """
        return _pcbnew.PADSTACK_BackOuterLayers(self, *args)
 
    def IsTented(self, aSide):
        r"""IsTented(PADSTACK self, PCB_LAYER_ID aSide) -> std::optional< bool >"""
        return _pcbnew.PADSTACK_IsTented(self, aSide)
 
    def CustomShapeInZoneMode(self):
        r"""CustomShapeInZoneMode(PADSTACK self) -> PADSTACK::CUSTOM_SHAPE_ZONE_MODE"""
        return _pcbnew.PADSTACK_CustomShapeInZoneMode(self)
 
    def SetCustomShapeInZoneMode(self, aM):
        r"""SetCustomShapeInZoneMode(PADSTACK self, PADSTACK::CUSTOM_SHAPE_ZONE_MODE aM)"""
        return _pcbnew.PADSTACK_SetCustomShapeInZoneMode(self, aM)
 
    def ForEachUniqueLayer(self, aMethod):
        r"""ForEachUniqueLayer(PADSTACK self, std::function< void (PCB_LAYER_ID) > const & aMethod)"""
        return _pcbnew.PADSTACK_ForEachUniqueLayer(self, aMethod)
 
    def UniqueLayers(self):
        r"""UniqueLayers(PADSTACK self) -> base_seqVect"""
        return _pcbnew.PADSTACK_UniqueLayers(self)
 
    def EffectiveLayerFor(self, aLayer):
        r"""EffectiveLayerFor(PADSTACK self, PCB_LAYER_ID aLayer) -> PCB_LAYER_ID"""
        return _pcbnew.PADSTACK_EffectiveLayerFor(self, aLayer)
 
    def RelevantShapeLayers(self, aOther):
        r"""RelevantShapeLayers(PADSTACK self, PADSTACK aOther) -> LSET"""
        return _pcbnew.PADSTACK_RelevantShapeLayers(self, aOther)
 
    def Shape(self, aLayer):
        r"""Shape(PADSTACK self, PCB_LAYER_ID aLayer) -> PAD_SHAPE"""
        return _pcbnew.PADSTACK_Shape(self, aLayer)
 
    def SetShape(self, aShape, aLayer):
        r"""SetShape(PADSTACK self, PAD_SHAPE aShape, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetShape(self, aShape, aLayer)
 
    def SetSize(self, aSize, aLayer):
        r"""SetSize(PADSTACK self, VECTOR2I aSize, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetSize(self, aSize, aLayer)
 
    def Size(self, aLayer):
        r"""Size(PADSTACK self, PCB_LAYER_ID aLayer) -> VECTOR2I"""
        return _pcbnew.PADSTACK_Size(self, aLayer)
 
    def DrillShape(self):
        r"""DrillShape(PADSTACK self) -> PAD_DRILL_SHAPE"""
        return _pcbnew.PADSTACK_DrillShape(self)
 
    def SetDrillShape(self, aShape):
        r"""SetDrillShape(PADSTACK self, PAD_DRILL_SHAPE aShape)"""
        return _pcbnew.PADSTACK_SetDrillShape(self, aShape)
 
    def Offset(self, *args):
        r"""
        Offset(PADSTACK self, PCB_LAYER_ID aLayer) -> VECTOR2I
        Offset(PADSTACK self, PCB_LAYER_ID aLayer) -> VECTOR2I
        """
        return _pcbnew.PADSTACK_Offset(self, *args)
 
    def AnchorShape(self, aLayer):
        r"""AnchorShape(PADSTACK self, PCB_LAYER_ID aLayer) -> PAD_SHAPE"""
        return _pcbnew.PADSTACK_AnchorShape(self, aLayer)
 
    def SetAnchorShape(self, aShape, aLayer):
        r"""SetAnchorShape(PADSTACK self, PAD_SHAPE aShape, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetAnchorShape(self, aShape, aLayer)
 
    def TrapezoidDeltaSize(self, *args):
        r"""
        TrapezoidDeltaSize(PADSTACK self, PCB_LAYER_ID aLayer) -> VECTOR2I
        TrapezoidDeltaSize(PADSTACK self, PCB_LAYER_ID aLayer) -> VECTOR2I
        """
        return _pcbnew.PADSTACK_TrapezoidDeltaSize(self, *args)
 
    def RoundRectRadiusRatio(self, aLayer):
        r"""RoundRectRadiusRatio(PADSTACK self, PCB_LAYER_ID aLayer) -> double"""
        return _pcbnew.PADSTACK_RoundRectRadiusRatio(self, aLayer)
 
    def SetRoundRectRadiusRatio(self, aRatio, aLayer):
        r"""SetRoundRectRadiusRatio(PADSTACK self, double aRatio, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetRoundRectRadiusRatio(self, aRatio, aLayer)
 
    def RoundRectRadius(self, aLayer):
        r"""RoundRectRadius(PADSTACK self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.PADSTACK_RoundRectRadius(self, aLayer)
 
    def SetRoundRectRadius(self, aRadius, aLayer):
        r"""SetRoundRectRadius(PADSTACK self, double aRadius, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetRoundRectRadius(self, aRadius, aLayer)
 
    def ChamferRatio(self, aLayer):
        r"""ChamferRatio(PADSTACK self, PCB_LAYER_ID aLayer) -> double"""
        return _pcbnew.PADSTACK_ChamferRatio(self, aLayer)
 
    def SetChamferRatio(self, aRatio, aLayer):
        r"""SetChamferRatio(PADSTACK self, double aRatio, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetChamferRatio(self, aRatio, aLayer)
 
    def ChamferPositions(self, *args):
        r"""
        ChamferPositions(PADSTACK self, PCB_LAYER_ID aLayer) -> int
        ChamferPositions(PADSTACK self, PCB_LAYER_ID aLayer) -> int const &
        """
        return _pcbnew.PADSTACK_ChamferPositions(self, *args)
 
    def SetChamferPositions(self, aPositions, aLayer):
        r"""SetChamferPositions(PADSTACK self, int aPositions, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_SetChamferPositions(self, aPositions, aLayer)
 
    def Clearance(self, *args):
        r"""
        Clearance(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int >
        Clearance(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int > const
        """
        return _pcbnew.PADSTACK_Clearance(self, *args)
 
    def SolderMaskMargin(self, *args):
        r"""
        SolderMaskMargin(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int >
        SolderMaskMargin(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int > const
        """
        return _pcbnew.PADSTACK_SolderMaskMargin(self, *args)
 
    def SolderPasteMargin(self, *args):
        r"""
        SolderPasteMargin(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int >
        SolderPasteMargin(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int > const
        """
        return _pcbnew.PADSTACK_SolderPasteMargin(self, *args)
 
    def SolderPasteMarginRatio(self, *args):
        r"""
        SolderPasteMarginRatio(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< double >
        SolderPasteMarginRatio(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< double > const
        """
        return _pcbnew.PADSTACK_SolderPasteMarginRatio(self, *args)
 
    def ZoneConnection(self, *args):
        r"""
        ZoneConnection(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< ZONE_CONNECTION >
        ZoneConnection(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< ZONE_CONNECTION > const
        """
        return _pcbnew.PADSTACK_ZoneConnection(self, *args)
 
    def ThermalSpokeWidth(self, *args):
        r"""
        ThermalSpokeWidth(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int >
        ThermalSpokeWidth(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int > const
        """
        return _pcbnew.PADSTACK_ThermalSpokeWidth(self, *args)
 
    def ThermalGap(self, *args):
        r"""
        ThermalGap(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int >
        ThermalGap(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> std::optional< int > const
        """
        return _pcbnew.PADSTACK_ThermalGap(self, *args)
 
    def DefaultThermalSpokeAngleForShape(self, aLayer=F_Cu):
        r"""DefaultThermalSpokeAngleForShape(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> EDA_ANGLE"""
        return _pcbnew.PADSTACK_DefaultThermalSpokeAngleForShape(self, aLayer)
 
    def ThermalSpokeAngle(self, aLayer=F_Cu):
        r"""ThermalSpokeAngle(PADSTACK self, PCB_LAYER_ID aLayer=F_Cu) -> EDA_ANGLE"""
        return _pcbnew.PADSTACK_ThermalSpokeAngle(self, aLayer)
 
    def SetThermalSpokeAngle(self, aAngle, aLayer=F_Cu):
        r"""SetThermalSpokeAngle(PADSTACK self, EDA_ANGLE aAngle, PCB_LAYER_ID aLayer=F_Cu)"""
        return _pcbnew.PADSTACK_SetThermalSpokeAngle(self, aAngle, aLayer)
 
    def Primitives(self, *args):
        r"""
        Primitives(PADSTACK self, PCB_LAYER_ID aLayer) -> std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > >
        Primitives(PADSTACK self, PCB_LAYER_ID aLayer) -> std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const &
        """
        return _pcbnew.PADSTACK_Primitives(self, *args)
 
    def AddPrimitive(self, aShape, aLayer):
        r"""AddPrimitive(PADSTACK self, PCB_SHAPE aShape, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_AddPrimitive(self, aShape, aLayer)
 
    def AppendPrimitives(self, aPrimitivesList, aLayer):
        r"""AppendPrimitives(PADSTACK self, std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const & aPrimitivesList, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_AppendPrimitives(self, aPrimitivesList, aLayer)
 
    def ReplacePrimitives(self, aPrimitivesList, aLayer):
        r"""ReplacePrimitives(PADSTACK self, std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const & aPrimitivesList, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_ReplacePrimitives(self, aPrimitivesList, aLayer)
 
    def ClearPrimitives(self, aLayer):
        r"""ClearPrimitives(PADSTACK self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PADSTACK_ClearPrimitives(self, aLayer)
 
# Register PADSTACK in _pcbnew:
_pcbnew.PADSTACK_swigregister(PADSTACK)
class PAD(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ 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, *args):
        r"""
        __init__(PAD self, FOOTPRINT parent) -> PAD
        __init__(PAD self, PAD aPad) -> PAD
        """
        _pcbnew.PAD_swiginit(self, _pcbnew.new_PAD(*args))
 
    def Serialize(self, aContainer):
        r"""Serialize(PAD self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PAD_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PAD self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PAD_Deserialize(self, aContainer)
 
    @staticmethod
    def PTHMask():
        r"""PTHMask() -> LSET"""
        return _pcbnew.PAD_PTHMask()
 
    @staticmethod
    def SMDMask():
        r"""SMDMask() -> LSET"""
        return _pcbnew.PAD_SMDMask()
 
    @staticmethod
    def ConnSMDMask():
        r"""ConnSMDMask() -> LSET"""
        return _pcbnew.PAD_ConnSMDMask()
 
    @staticmethod
    def UnplatedHoleMask():
        r"""UnplatedHoleMask() -> LSET"""
        return _pcbnew.PAD_UnplatedHoleMask()
 
    @staticmethod
    def ApertureMask():
        r"""ApertureMask() -> LSET"""
        return _pcbnew.PAD_ApertureMask()
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_ClassOf(aItem)
 
    def ImportSettingsFrom(self, aMasterPad):
        r"""ImportSettingsFrom(PAD self, PAD aMasterPad)"""
        return _pcbnew.PAD_ImportSettingsFrom(self, aMasterPad)
 
    def IsFlipped(self):
        r"""IsFlipped(PAD self) -> bool"""
        return _pcbnew.PAD_IsFlipped(self)
 
    def SetNumber(self, aNumber):
        r"""SetNumber(PAD self, wxString aNumber)"""
        return _pcbnew.PAD_SetNumber(self, aNumber)
 
    def GetNumber(self):
        r"""GetNumber(PAD self) -> wxString"""
        return _pcbnew.PAD_GetNumber(self)
 
    def CanHaveNumber(self):
        r"""CanHaveNumber(PAD self) -> bool"""
        return _pcbnew.PAD_CanHaveNumber(self)
 
    def SetPinFunction(self, aName):
        r"""SetPinFunction(PAD self, wxString aName)"""
        return _pcbnew.PAD_SetPinFunction(self, aName)
 
    def GetPinFunction(self):
        r"""GetPinFunction(PAD self) -> wxString"""
        return _pcbnew.PAD_GetPinFunction(self)
 
    def SetPinType(self, aType):
        r"""SetPinType(PAD self, wxString aType)"""
        return _pcbnew.PAD_SetPinType(self, aType)
 
    def GetPinType(self):
        r"""GetPinType(PAD self) -> wxString"""
        return _pcbnew.PAD_GetPinType(self)
 
    def SameLogicalPadAs(self, aOther):
        r"""SameLogicalPadAs(PAD self, PAD aOther) -> bool"""
        return _pcbnew.PAD_SameLogicalPadAs(self, aOther)
 
    def SharesNetTieGroup(self, aOther):
        r"""SharesNetTieGroup(PAD self, PAD aOther) -> bool"""
        return _pcbnew.PAD_SharesNetTieGroup(self, aOther)
 
    def IsNoConnectPad(self):
        r"""IsNoConnectPad(PAD self) -> bool"""
        return _pcbnew.PAD_IsNoConnectPad(self)
 
    def IsFreePad(self):
        r"""IsFreePad(PAD self) -> bool"""
        return _pcbnew.PAD_IsFreePad(self)
 
    def SetFrontShape(self, aShape):
        r"""SetFrontShape(PAD self, PAD_SHAPE aShape)"""
        return _pcbnew.PAD_SetFrontShape(self, aShape)
 
    def GetFrontShape(self):
        r"""GetFrontShape(PAD self) -> PAD_SHAPE"""
        return _pcbnew.PAD_GetFrontShape(self)
 
    def GetAnchorPadShape(self, aLayer):
        r"""GetAnchorPadShape(PAD self, PCB_LAYER_ID aLayer) -> PAD_SHAPE"""
        return _pcbnew.PAD_GetAnchorPadShape(self, aLayer)
 
    def GetCustomShapeInZoneOpt(self):
        r"""GetCustomShapeInZoneOpt(PAD self) -> PADSTACK::CUSTOM_SHAPE_ZONE_MODE"""
        return _pcbnew.PAD_GetCustomShapeInZoneOpt(self)
 
    def SetCustomShapeInZoneOpt(self, aOption):
        r"""SetCustomShapeInZoneOpt(PAD self, PADSTACK::CUSTOM_SHAPE_ZONE_MODE aOption)"""
        return _pcbnew.PAD_SetCustomShapeInZoneOpt(self, aOption)
 
    def SetAnchorPadShape(self, aLayer, aShape):
        r"""SetAnchorPadShape(PAD self, PCB_LAYER_ID aLayer, PAD_SHAPE aShape)"""
        return _pcbnew.PAD_SetAnchorPadShape(self, aLayer, aShape)
 
    def SetY(self, y):
        r"""SetY(PAD self, int y)"""
        return _pcbnew.PAD_SetY(self, y)
 
    def SetX(self, x):
        r"""SetX(PAD self, int x)"""
        return _pcbnew.PAD_SetX(self, x)
 
    def SetSizeX(self, aX):
        r"""SetSizeX(PAD self, int const aX)"""
        return _pcbnew.PAD_SetSizeX(self, aX)
 
    def GetSizeX(self):
        r"""GetSizeX(PAD self) -> int"""
        return _pcbnew.PAD_GetSizeX(self)
 
    def SetSizeY(self, aY):
        r"""SetSizeY(PAD self, int const aY)"""
        return _pcbnew.PAD_SetSizeY(self, aY)
 
    def GetSizeY(self):
        r"""GetSizeY(PAD self) -> int"""
        return _pcbnew.PAD_GetSizeY(self)
 
    def SetDrillSize(self, aSize):
        r"""SetDrillSize(PAD self, VECTOR2I aSize)"""
        return _pcbnew.PAD_SetDrillSize(self, aSize)
 
    def GetDrillSize(self):
        r"""GetDrillSize(PAD self) -> VECTOR2I"""
        return _pcbnew.PAD_GetDrillSize(self)
 
    def SetDrillSizeX(self, aX):
        r"""SetDrillSizeX(PAD self, int aX)"""
        return _pcbnew.PAD_SetDrillSizeX(self, aX)
 
    def GetDrillSizeX(self):
        r"""GetDrillSizeX(PAD self) -> int"""
        return _pcbnew.PAD_GetDrillSizeX(self)
 
    def SetDrillSizeY(self, aY):
        r"""SetDrillSizeY(PAD self, int aY)"""
        return _pcbnew.PAD_SetDrillSizeY(self, aY)
 
    def GetDrillSizeY(self):
        r"""GetDrillSizeY(PAD self) -> int"""
        return _pcbnew.PAD_GetDrillSizeY(self)
 
    def Padstack(self, *args):
        r"""
        Padstack(PAD self) -> PADSTACK
        Padstack(PAD self) -> PADSTACK
        """
        return _pcbnew.PAD_Padstack(self, *args)
 
    def SetPadstack(self, aPadstack):
        r"""SetPadstack(PAD self, PADSTACK aPadstack)"""
        return _pcbnew.PAD_SetPadstack(self, aPadstack)
 
    def AddPrimitivePoly(self, *args):
        r"""
        AddPrimitivePoly(PAD self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aPoly, int aThickness, bool aFilled)
        AddPrimitivePoly(PAD self, PCB_LAYER_ID aLayer, VECTOR_VECTOR2I aPoly, int aThickness, bool aFilled)
        """
        return _pcbnew.PAD_AddPrimitivePoly(self, *args)
 
    def MergePrimitivesAsPolygon(self, aLayer, aMergedPolygon, aErrorLoc=ERROR_INSIDE):
        r"""MergePrimitivesAsPolygon(PAD self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aMergedPolygon, ERROR_LOC aErrorLoc=ERROR_INSIDE)"""
        return _pcbnew.PAD_MergePrimitivesAsPolygon(self, aLayer, aMergedPolygon, aErrorLoc)
 
    def DeletePrimitivesList(self, aLayer=UNDEFINED_LAYER):
        r"""DeletePrimitivesList(PAD self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER)"""
        return _pcbnew.PAD_DeletePrimitivesList(self, aLayer)
 
    def GetPrimitives(self, aLayer):
        r"""GetPrimitives(PAD self, PCB_LAYER_ID aLayer) -> std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const &"""
        return _pcbnew.PAD_GetPrimitives(self, aLayer)
 
    def FlipPrimitives(self, aFlipDirection):
        r"""FlipPrimitives(PAD self, FLIP_DIRECTION aFlipDirection)"""
        return _pcbnew.PAD_FlipPrimitives(self, aFlipDirection)
 
    def ReplacePrimitives(self, aLayer, aPrimitivesList):
        r"""ReplacePrimitives(PAD self, PCB_LAYER_ID aLayer, std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const & aPrimitivesList)"""
        return _pcbnew.PAD_ReplacePrimitives(self, aLayer, aPrimitivesList)
 
    def AppendPrimitives(self, aLayer, aPrimitivesList):
        r"""AppendPrimitives(PAD self, PCB_LAYER_ID aLayer, std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const & aPrimitivesList)"""
        return _pcbnew.PAD_AppendPrimitives(self, aLayer, aPrimitivesList)
 
    def AddPrimitiveShape(self, aLayer, aPrimitive):
        r"""AddPrimitiveShape(PAD self, PCB_LAYER_ID aLayer, PCB_SHAPE aPrimitive)"""
        return _pcbnew.PAD_AddPrimitiveShape(self, aLayer, aPrimitive)
 
    def SetOrientation(self, aAngle):
        r"""SetOrientation(PAD self, EDA_ANGLE aAngle)"""
        return _pcbnew.PAD_SetOrientation(self, aAngle)
 
    def SetFPRelativeOrientation(self, aAngle):
        r"""SetFPRelativeOrientation(PAD self, EDA_ANGLE aAngle)"""
        return _pcbnew.PAD_SetFPRelativeOrientation(self, aAngle)
 
    def GetOrientation(self):
        r"""GetOrientation(PAD self) -> EDA_ANGLE"""
        return _pcbnew.PAD_GetOrientation(self)
 
    def GetFPRelativeOrientation(self):
        r"""GetFPRelativeOrientation(PAD self) -> EDA_ANGLE"""
        return _pcbnew.PAD_GetFPRelativeOrientation(self)
 
    def SetOrientationDegrees(self, aOrientation):
        r"""SetOrientationDegrees(PAD self, double aOrientation)"""
        return _pcbnew.PAD_SetOrientationDegrees(self, aOrientation)
 
    def GetOrientationDegrees(self):
        r"""GetOrientationDegrees(PAD self) -> double"""
        return _pcbnew.PAD_GetOrientationDegrees(self)
 
    def SetDrillShape(self, aShape):
        r"""SetDrillShape(PAD self, PAD_DRILL_SHAPE aShape)"""
        return _pcbnew.PAD_SetDrillShape(self, aShape)
 
    def GetDrillShape(self):
        r"""GetDrillShape(PAD self) -> PAD_DRILL_SHAPE"""
        return _pcbnew.PAD_GetDrillShape(self)
 
    def IsDirty(self):
        r"""IsDirty(PAD self) -> bool"""
        return _pcbnew.PAD_IsDirty(self)
 
    def SetDirty(self):
        r"""SetDirty(PAD self)"""
        return _pcbnew.PAD_SetDirty(self)
 
    def SetAttribute(self, aAttribute):
        r"""SetAttribute(PAD self, PAD_ATTRIB aAttribute)"""
        return _pcbnew.PAD_SetAttribute(self, aAttribute)
 
    def GetAttribute(self):
        r"""GetAttribute(PAD self) -> PAD_ATTRIB"""
        return _pcbnew.PAD_GetAttribute(self)
 
    def SetProperty(self, aProperty):
        r"""SetProperty(PAD self, PAD_PROP aProperty)"""
        return _pcbnew.PAD_SetProperty(self, aProperty)
 
    def GetProperty(self):
        r"""GetProperty(PAD self) -> PAD_PROP"""
        return _pcbnew.PAD_GetProperty(self)
 
    def IsAperturePad(self):
        r"""IsAperturePad(PAD self) -> bool"""
        return _pcbnew.PAD_IsAperturePad(self)
 
    def SetPadToDieLength(self, aLength):
        r"""SetPadToDieLength(PAD self, int aLength)"""
        return _pcbnew.PAD_SetPadToDieLength(self, aLength)
 
    def GetPadToDieLength(self):
        r"""GetPadToDieLength(PAD self) -> int"""
        return _pcbnew.PAD_GetPadToDieLength(self)
 
    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(PAD self, std::optional< int > aClearance)"""
        return _pcbnew.PAD_SetLocalClearance(self, aClearance)
 
    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(PAD self) -> std::optional< int >"""
        return _pcbnew.PAD_GetLocalSolderMaskMargin(self)
 
    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(PAD self, std::optional< int > aMargin)"""
        return _pcbnew.PAD_SetLocalSolderMaskMargin(self, aMargin)
 
    def GetLocalSolderPasteMargin(self):
        r"""GetLocalSolderPasteMargin(PAD self) -> std::optional< int >"""
        return _pcbnew.PAD_GetLocalSolderPasteMargin(self)
 
    def SetLocalSolderPasteMargin(self, aMargin):
        r"""SetLocalSolderPasteMargin(PAD self, std::optional< int > aMargin)"""
        return _pcbnew.PAD_SetLocalSolderPasteMargin(self, aMargin)
 
    def GetLocalSolderPasteMarginRatio(self):
        r"""GetLocalSolderPasteMarginRatio(PAD self) -> std::optional< double >"""
        return _pcbnew.PAD_GetLocalSolderPasteMarginRatio(self)
 
    def SetLocalSolderPasteMarginRatio(self, aRatio):
        r"""SetLocalSolderPasteMarginRatio(PAD self, std::optional< double > aRatio)"""
        return _pcbnew.PAD_SetLocalSolderPasteMarginRatio(self, aRatio)
 
    def SetLocalZoneConnection(self, aType):
        r"""SetLocalZoneConnection(PAD self, ZONE_CONNECTION aType)"""
        return _pcbnew.PAD_SetLocalZoneConnection(self, aType)
 
    def GetLocalZoneConnection(self):
        r"""GetLocalZoneConnection(PAD self) -> ZONE_CONNECTION"""
        return _pcbnew.PAD_GetLocalZoneConnection(self)
 
    def GetOwnClearance(self, aLayer, aSource=None):
        r"""GetOwnClearance(PAD self, PCB_LAYER_ID aLayer, wxString aSource=None) -> int"""
        return _pcbnew.PAD_GetOwnClearance(self, aLayer, aSource)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc=ERROR_INSIDE, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(PAD self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc=ERROR_INSIDE, bool ignoreLineWidth=False)"""
        return _pcbnew.PAD_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, ignoreLineWidth)
 
    def TransformHoleToPolygon(self, aBuffer, aClearance, aError, aErrorLoc=ERROR_INSIDE):
        r"""TransformHoleToPolygon(PAD self, SHAPE_POLY_SET aBuffer, int aClearance, int aError, ERROR_LOC aErrorLoc=ERROR_INSIDE) -> bool"""
        return _pcbnew.PAD_TransformHoleToPolygon(self, aBuffer, aClearance, aError, aErrorLoc)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PAD self, PCB_LAYER_ID aLayer, FLASHING flashPTHPads=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PAD_GetEffectiveShape(self, *args)
 
    def GetEffectivePolygon(self, aLayer, aErrorLoc=ERROR_INSIDE):
        r"""GetEffectivePolygon(PAD self, PCB_LAYER_ID aLayer, ERROR_LOC aErrorLoc=ERROR_INSIDE) -> std::shared_ptr< SHAPE_POLY_SET > const"""
        return _pcbnew.PAD_GetEffectivePolygon(self, aLayer, aErrorLoc)
 
    def GetBoundingRadius(self):
        r"""GetBoundingRadius(PAD self) -> int"""
        return _pcbnew.PAD_GetBoundingRadius(self)
 
    def GetLocalClearance(self, *args):
        r"""
        GetLocalClearance(PAD self) -> std::optional< int >
        GetLocalClearance(PAD self, wxString aSource) -> std::optional< int >
        """
        return _pcbnew.PAD_GetLocalClearance(self, *args)
 
    def GetSolderMaskExpansion(self, aLayer):
        r"""GetSolderMaskExpansion(PAD self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.PAD_GetSolderMaskExpansion(self, aLayer)
 
    def GetSolderPasteMargin(self, aLayer):
        r"""GetSolderPasteMargin(PAD self, PCB_LAYER_ID aLayer) -> VECTOR2I"""
        return _pcbnew.PAD_GetSolderPasteMargin(self, aLayer)
 
    def GetZoneConnectionOverrides(self, aSource=None):
        r"""GetZoneConnectionOverrides(PAD self, wxString aSource=None) -> ZONE_CONNECTION"""
        return _pcbnew.PAD_GetZoneConnectionOverrides(self, aSource)
 
    def SetLocalThermalSpokeWidthOverride(self, aWidth):
        r"""SetLocalThermalSpokeWidthOverride(PAD self, std::optional< int > aWidth)"""
        return _pcbnew.PAD_SetLocalThermalSpokeWidthOverride(self, aWidth)
 
    def GetLocalThermalSpokeWidthOverride(self):
        r"""GetLocalThermalSpokeWidthOverride(PAD self) -> std::optional< int >"""
        return _pcbnew.PAD_GetLocalThermalSpokeWidthOverride(self)
 
    def GetLocalSpokeWidthOverride(self, aSource=None):
        r"""GetLocalSpokeWidthOverride(PAD self, wxString aSource=None) -> int"""
        return _pcbnew.PAD_GetLocalSpokeWidthOverride(self, aSource)
 
    def SetThermalSpokeAngle(self, aAngle):
        r"""SetThermalSpokeAngle(PAD self, EDA_ANGLE aAngle)"""
        return _pcbnew.PAD_SetThermalSpokeAngle(self, aAngle)
 
    def GetThermalSpokeAngle(self):
        r"""GetThermalSpokeAngle(PAD self) -> EDA_ANGLE"""
        return _pcbnew.PAD_GetThermalSpokeAngle(self)
 
    def SetThermalSpokeAngleDegrees(self, aAngle):
        r"""SetThermalSpokeAngleDegrees(PAD self, double aAngle)"""
        return _pcbnew.PAD_SetThermalSpokeAngleDegrees(self, aAngle)
 
    def GetThermalSpokeAngleDegrees(self):
        r"""GetThermalSpokeAngleDegrees(PAD self) -> double"""
        return _pcbnew.PAD_GetThermalSpokeAngleDegrees(self)
 
    def SetThermalGap(self, aGap):
        r"""SetThermalGap(PAD self, int aGap)"""
        return _pcbnew.PAD_SetThermalGap(self, aGap)
 
    def GetThermalGap(self):
        r"""GetThermalGap(PAD self) -> int"""
        return _pcbnew.PAD_GetThermalGap(self)
 
    def GetLocalThermalGapOverride(self, *args):
        r"""
        GetLocalThermalGapOverride(PAD self, wxString aSource) -> int
        GetLocalThermalGapOverride(PAD self) -> std::optional< int >
        """
        return _pcbnew.PAD_GetLocalThermalGapOverride(self, *args)
 
    def SetLocalThermalGapOverride(self, aOverride):
        r"""SetLocalThermalGapOverride(PAD self, std::optional< int > const & aOverride)"""
        return _pcbnew.PAD_SetLocalThermalGapOverride(self, aOverride)
 
    def ShapePos(self, aLayer):
        r"""ShapePos(PAD self, PCB_LAYER_ID aLayer) -> VECTOR2I"""
        return _pcbnew.PAD_ShapePos(self, aLayer)
 
    def SetFrontRoundRectRadiusRatio(self, aRadiusScale):
        r"""SetFrontRoundRectRadiusRatio(PAD self, double aRadiusScale)"""
        return _pcbnew.PAD_SetFrontRoundRectRadiusRatio(self, aRadiusScale)
 
    def GetFrontRoundRectRadiusRatio(self):
        r"""GetFrontRoundRectRadiusRatio(PAD self) -> double"""
        return _pcbnew.PAD_GetFrontRoundRectRadiusRatio(self)
 
    def SetFrontRoundRectRadiusSize(self, aRadius):
        r"""SetFrontRoundRectRadiusSize(PAD self, int aRadius)"""
        return _pcbnew.PAD_SetFrontRoundRectRadiusSize(self, aRadius)
 
    def GetFrontRoundRectRadiusSize(self):
        r"""GetFrontRoundRectRadiusSize(PAD self) -> int"""
        return _pcbnew.PAD_GetFrontRoundRectRadiusSize(self)
 
    def GetSubRatsnest(self):
        r"""GetSubRatsnest(PAD self) -> int"""
        return _pcbnew.PAD_GetSubRatsnest(self)
 
    def SetSubRatsnest(self, aSubRatsnest):
        r"""SetSubRatsnest(PAD self, int aSubRatsnest)"""
        return _pcbnew.PAD_SetSubRatsnest(self, aSubRatsnest)
 
    def SetRemoveUnconnected(self, aSet):
        r"""SetRemoveUnconnected(PAD self, bool aSet)"""
        return _pcbnew.PAD_SetRemoveUnconnected(self, aSet)
 
    def GetRemoveUnconnected(self):
        r"""GetRemoveUnconnected(PAD self) -> bool"""
        return _pcbnew.PAD_GetRemoveUnconnected(self)
 
    def SetKeepTopBottom(self, aSet):
        r"""SetKeepTopBottom(PAD self, bool aSet)"""
        return _pcbnew.PAD_SetKeepTopBottom(self, aSet)
 
    def GetKeepTopBottom(self):
        r"""GetKeepTopBottom(PAD self) -> bool"""
        return _pcbnew.PAD_GetKeepTopBottom(self)
 
    def SetUnconnectedLayerMode(self, aMode):
        r"""SetUnconnectedLayerMode(PAD self, PADSTACK::UNCONNECTED_LAYER_MODE aMode)"""
        return _pcbnew.PAD_SetUnconnectedLayerMode(self, aMode)
 
    def GetUnconnectedLayerMode(self):
        r"""GetUnconnectedLayerMode(PAD self) -> PADSTACK::UNCONNECTED_LAYER_MODE"""
        return _pcbnew.PAD_GetUnconnectedLayerMode(self)
 
    def ConditionallyFlashed(self, aLayer):
        r"""ConditionallyFlashed(PAD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PAD_ConditionallyFlashed(self, aLayer)
 
    def CanFlashLayer(self, aLayer):
        r"""CanFlashLayer(PAD self, int aLayer) -> bool"""
        return _pcbnew.PAD_CanFlashLayer(self, aLayer)
 
    def GetPrincipalLayer(self):
        r"""GetPrincipalLayer(PAD self) -> PCB_LAYER_ID"""
        return _pcbnew.PAD_GetPrincipalLayer(self)
 
    def FlashLayer(self, *args):
        r"""
        FlashLayer(PAD self, int aLayer, bool aOnlyCheckIfPermitted=False) -> bool
        FlashLayer(PAD self, LSET aLayers) -> bool
        """
        return _pcbnew.PAD_FlashLayer(self, *args)
 
    def HitTest(self, *args):
        r"""
        HitTest(PAD self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PAD self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        HitTest(PAD self, VECTOR2I aPosition, int aAccuracy, PCB_LAYER_ID aLayer) -> bool
        """
        return _pcbnew.PAD_HitTest(self, *args)
 
    def Recombine(self, aIsDryRun, aMaxError):
        r"""Recombine(PAD self, bool aIsDryRun, int aMaxError) -> std::vector< PCB_SHAPE *,std::allocator< PCB_SHAPE * > >"""
        return _pcbnew.PAD_Recombine(self, aIsDryRun, aMaxError)
 
    def GetClass(self):
        r"""GetClass(PAD self) -> wxString"""
        return _pcbnew.PAD_GetClass(self)
 
    def GetBoundingBox(self, *args):
        r"""
        GetBoundingBox(PAD self) -> BOX2I
        GetBoundingBox(PAD self, PCB_LAYER_ID aLayer) -> BOX2I
        """
        return _pcbnew.PAD_GetBoundingBox(self, *args)
 
    @staticmethod
    def Compare(aPadRef, aPadCmp):
        r"""Compare(PAD aPadRef, PAD aPadCmp) -> int"""
        return _pcbnew.PAD_Compare(aPadRef, aPadCmp)
 
    def ShowPadShape(self, aLayer):
        r"""ShowPadShape(PAD self, PCB_LAYER_ID aLayer) -> wxString"""
        return _pcbnew.PAD_ShowPadShape(self, aLayer)
 
    def ShowPadAttr(self):
        r"""ShowPadAttr(PAD self) -> wxString"""
        return _pcbnew.PAD_ShowPadAttr(self)
 
    def ClonePad(self):
        r"""ClonePad(PAD self) -> PAD"""
        return _pcbnew.PAD_ClonePad(self)
 
    def BuildEffectiveShapes(self):
        r"""BuildEffectiveShapes(PAD self)"""
        return _pcbnew.PAD_BuildEffectiveShapes(self)
 
    def BuildEffectivePolygon(self, aErrorLoc=ERROR_INSIDE):
        r"""BuildEffectivePolygon(PAD self, ERROR_LOC aErrorLoc=ERROR_INSIDE)"""
        return _pcbnew.PAD_BuildEffectivePolygon(self, aErrorLoc)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PAD self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PAD_ViewGetLOD(self, aLayer, aView)
 
    def ClearZoneLayerOverrides(self):
        r"""ClearZoneLayerOverrides(PAD self)"""
        return _pcbnew.PAD_ClearZoneLayerOverrides(self)
 
    def GetZoneLayerOverride(self, aLayer):
        r"""GetZoneLayerOverride(PAD self, PCB_LAYER_ID aLayer) -> ZONE_LAYER_OVERRIDE const &"""
        return _pcbnew.PAD_GetZoneLayerOverride(self, aLayer)
 
    def SetZoneLayerOverride(self, aLayer, aOverride):
        r"""SetZoneLayerOverride(PAD self, PCB_LAYER_ID aLayer, ZONE_LAYER_OVERRIDE aOverride)"""
        return _pcbnew.PAD_SetZoneLayerOverride(self, aLayer, aOverride)
 
    def CheckPad(self, aUnitsProvider, aForPadProperties, aErrorHandler):
        r"""CheckPad(PAD self, UNITS_PROVIDER aUnitsProvider, bool aForPadProperties, std::function< void (int,wxString const &) > const & aErrorHandler)"""
        return _pcbnew.PAD_CheckPad(self, aUnitsProvider, aForPadProperties, aErrorHandler)
 
    def __eq__(self, *args):
        r"""
        __eq__(PAD self, PAD aOther) -> bool
        __eq__(PAD self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PAD___eq__(self, *args)
 
    def GetShape(self, *args):
        r"""
        GetShape(PAD self, PCB_LAYER_ID aLayer) -> PAD_SHAPE
        GetShape(PAD self) -> PAD_SHAPE
        """
        return _pcbnew.PAD_GetShape(self, *args)
 
    def SetShape(self, *args):
        r"""
        SetShape(PAD self, PCB_LAYER_ID aLayer, PAD_SHAPE aShape)
        SetShape(PAD self, PAD_SHAPE aShape)
        """
        return _pcbnew.PAD_SetShape(self, *args)
 
    def GetSize(self, *args):
        r"""
        GetSize(PAD self, PCB_LAYER_ID aLayer) -> VECTOR2I
        GetSize(PAD self) -> VECTOR2I
        """
        return _pcbnew.PAD_GetSize(self, *args)
 
    def SetSize(self, *args):
        r"""
        SetSize(PAD self, PCB_LAYER_ID aLayer, VECTOR2I aSize)
        SetSize(PAD self, VECTOR2I aSize)
        """
        return _pcbnew.PAD_SetSize(self, *args)
 
    def GetDelta(self, *args):
        r"""
        GetDelta(PAD self, PCB_LAYER_ID aLayer) -> VECTOR2I
        GetDelta(PAD self) -> VECTOR2I
        """
        return _pcbnew.PAD_GetDelta(self, *args)
 
    def SetDelta(self, *args):
        r"""
        SetDelta(PAD self, PCB_LAYER_ID aLayer, VECTOR2I aSize)
        SetDelta(PAD self, VECTOR2I aSize)
        """
        return _pcbnew.PAD_SetDelta(self, *args)
 
    def GetOffset(self, *args):
        r"""
        GetOffset(PAD self, PCB_LAYER_ID aLayer) -> VECTOR2I
        GetOffset(PAD self) -> VECTOR2I
        """
        return _pcbnew.PAD_GetOffset(self, *args)
 
    def SetOffset(self, *args):
        r"""
        SetOffset(PAD self, PCB_LAYER_ID aLayer, VECTOR2I aOffset)
        SetOffset(PAD self, VECTOR2I aOffset)
        """
        return _pcbnew.PAD_SetOffset(self, *args)
 
    def GetRoundRectCornerRadius(self, *args):
        r"""
        GetRoundRectCornerRadius(PAD self, PCB_LAYER_ID aLayer) -> int
        GetRoundRectCornerRadius(PAD self) -> double
        """
        return _pcbnew.PAD_GetRoundRectCornerRadius(self, *args)
 
    def SetRoundRectCornerRadius(self, *args):
        r"""
        SetRoundRectCornerRadius(PAD self, PCB_LAYER_ID aLayer, double aRadius)
        SetRoundRectCornerRadius(PAD self, double aRadius)
        """
        return _pcbnew.PAD_SetRoundRectCornerRadius(self, *args)
 
    def GetRoundRectRadiusRatio(self, *args):
        r"""
        GetRoundRectRadiusRatio(PAD self, PCB_LAYER_ID aLayer) -> double
        GetRoundRectRadiusRatio(PAD self) -> double
        """
        return _pcbnew.PAD_GetRoundRectRadiusRatio(self, *args)
 
    def SetRoundRectRadiusRatio(self, *args):
        r"""
        SetRoundRectRadiusRatio(PAD self, PCB_LAYER_ID aLayer, double aRadiusScale)
        SetRoundRectRadiusRatio(PAD self, double aRatio)
        """
        return _pcbnew.PAD_SetRoundRectRadiusRatio(self, *args)
 
    def GetChamferRectRatio(self, *args):
        r"""
        GetChamferRectRatio(PAD self, PCB_LAYER_ID aLayer) -> double
        GetChamferRectRatio(PAD self) -> double
        """
        return _pcbnew.PAD_GetChamferRectRatio(self, *args)
 
    def SetChamferRectRatio(self, *args):
        r"""
        SetChamferRectRatio(PAD self, PCB_LAYER_ID aLayer, double aChamferScale)
        SetChamferRectRatio(PAD self, double aRatio)
        """
        return _pcbnew.PAD_SetChamferRectRatio(self, *args)
 
    def GetChamferPositions(self, *args):
        r"""
        GetChamferPositions(PAD self, PCB_LAYER_ID aLayer) -> int
        GetChamferPositions(PAD self) -> int
        """
        return _pcbnew.PAD_GetChamferPositions(self, *args)
 
    def SetChamferPositions(self, *args):
        r"""
        SetChamferPositions(PAD self, PCB_LAYER_ID aLayer, int aPositions)
        SetChamferPositions(PAD self, int aPositions)
        """
        return _pcbnew.PAD_SetChamferPositions(self, *args)
 
 
        # SetPadName() is the old name for PAD::SetName()
        # define it for compatibility
    def SetPadName(self, aName):
        return self.SetNumber(aName)
 
    def SetName(self, aName):
        return self.SetNumber(aName)
 
    # GetPadName() is the old name for PAD::GetName()
    # define it for compatibility
    def GetPadName(self):
        return self.GetNumber()
 
    def GetName(self):
        return self.GetNumber()
 
    # AddPrimitive() used to be multiple functions on the C++ side and this single Python function
    # was made to maintain compatibility with an even older version of the PAD class that had a
    # single function.  Now we're back to a single function, but different, and Python scripts
    # have gotten used to this API, so keep compatibility with it
    def AddPrimitive(self, *args):
        if len(args) == 2:
            return self.AddPrimitivePoly(F_Cu, *args, True)
        elif len(args) == 3:
            if type(args[1] in [wxPoint,wxSize,VECTOR2I]):
                s = PCB_SHAPE(None, SHAPE_T_SEGMENT)
                s.SetStart(args[0])
                s.SetEnd(args[1])
                s.SetWidth(args[2])
            else:
                s = PCB_SHAPE(None, SHAPE_T_CIRCLE)
                s.SetCenter(args[0])
                s.SetRadius(args[1])
                s.SetWidth(args[2])
        elif len(args) == 4:
            s = PCB_SHAPE(None, SHAPE_T_ARC)
            s.SetCenter(args[0])
            s.SetStart(args[1])
            s.SetArcAngleAndEnd(args[2])
            s.SetWidth(args[3])
        elif len(args) == 5:
            s = PCB_SHAPE(None, SHAPE_T_BEZIER)
            s.SetStart(args[0])
            s.SetEnd(args[1])
            s.SetBezierC1(args[2])
            s.SetBezierC2(args[3])
            s.SetWidth(args[4])
        else:
            raise TypeError(f"Arguments not recognized; expected 2-5 args, got {len(args)}")
 
        self.AddPrimitiveShape(s)
 
    # GetCustomShapeAsPolygon() is the old accessor to get custom shapes
    def GetCustomShapeAsPolygon(self, layer=UNDEFINED_LAYER):
        polygon_set = SHAPE_POLY_SET()
        self.MergePrimitivesAsPolygon(F_Cu, polygon_set)
        return polygon_set
 
    __swig_destroy__ = _pcbnew.delete_PAD
 
# Register PAD in _pcbnew:
_pcbnew.PAD_swigregister(PAD)
ENDPOINT_START = _pcbnew.ENDPOINT_START
 
ENDPOINT_END = _pcbnew.ENDPOINT_END
 
VIATYPE_THROUGH = _pcbnew.VIATYPE_THROUGH
 
VIATYPE_BLIND_BURIED = _pcbnew.VIATYPE_BLIND_BURIED
 
VIATYPE_MICROVIA = _pcbnew.VIATYPE_MICROVIA
 
VIATYPE_NOT_DEFINED = _pcbnew.VIATYPE_NOT_DEFINED
 
TENTING_MODE_FROM_RULES = _pcbnew.TENTING_MODE_FROM_RULES
 
TENTING_MODE_TENTED = _pcbnew.TENTING_MODE_TENTED
 
TENTING_MODE_NOT_TENTED = _pcbnew.TENTING_MODE_NOT_TENTED
 
UNDEFINED_DRILL_DIAMETER = _pcbnew.UNDEFINED_DRILL_DIAMETER
 
class PCB_TRACK(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ PCB_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.PCB_TRACK_ClassOf(aItem)
 
    def __init__(self, aParent, idtype=PCB_TRACE_T):
        r"""__init__(PCB_TRACK self, BOARD_ITEM aParent, KICAD_T idtype=PCB_TRACE_T) -> PCB_TRACK"""
        _pcbnew.PCB_TRACK_swiginit(self, _pcbnew.new_PCB_TRACK(aParent, idtype))
 
    def SetWidth(self, aWidth):
        r"""SetWidth(PCB_TRACK self, int aWidth)"""
        return _pcbnew.PCB_TRACK_SetWidth(self, aWidth)
 
    def GetWidth(self):
        r"""GetWidth(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetWidth(self)
 
    def SetEnd(self, aEnd):
        r"""SetEnd(PCB_TRACK self, VECTOR2I aEnd)"""
        return _pcbnew.PCB_TRACK_SetEnd(self, aEnd)
 
    def GetEnd(self):
        r"""GetEnd(PCB_TRACK self) -> VECTOR2I"""
        return _pcbnew.PCB_TRACK_GetEnd(self)
 
    def SetStart(self, aStart):
        r"""SetStart(PCB_TRACK self, VECTOR2I aStart)"""
        return _pcbnew.PCB_TRACK_SetStart(self, aStart)
 
    def GetStart(self):
        r"""GetStart(PCB_TRACK self) -> VECTOR2I"""
        return _pcbnew.PCB_TRACK_GetStart(self)
 
    def SetStartX(self, aX):
        r"""SetStartX(PCB_TRACK self, int aX)"""
        return _pcbnew.PCB_TRACK_SetStartX(self, aX)
 
    def SetStartY(self, aY):
        r"""SetStartY(PCB_TRACK self, int aY)"""
        return _pcbnew.PCB_TRACK_SetStartY(self, aY)
 
    def GetStartX(self):
        r"""GetStartX(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetStartX(self)
 
    def GetStartY(self):
        r"""GetStartY(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetStartY(self)
 
    def SetEndX(self, aX):
        r"""SetEndX(PCB_TRACK self, int aX)"""
        return _pcbnew.PCB_TRACK_SetEndX(self, aX)
 
    def SetEndY(self, aY):
        r"""SetEndY(PCB_TRACK self, int aY)"""
        return _pcbnew.PCB_TRACK_SetEndY(self, aY)
 
    def GetEndX(self):
        r"""GetEndX(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetEndX(self)
 
    def GetEndY(self):
        r"""GetEndY(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetEndY(self)
 
    def GetEndPoint(self, aEndPoint):
        r"""GetEndPoint(PCB_TRACK self, ENDPOINT_T aEndPoint) -> VECTOR2I"""
        return _pcbnew.PCB_TRACK_GetEndPoint(self, aEndPoint)
 
    def SetHasSolderMask(self, aVal):
        r"""SetHasSolderMask(PCB_TRACK self, bool aVal)"""
        return _pcbnew.PCB_TRACK_SetHasSolderMask(self, aVal)
 
    def HasSolderMask(self):
        r"""HasSolderMask(PCB_TRACK self) -> bool"""
        return _pcbnew.PCB_TRACK_HasSolderMask(self)
 
    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(PCB_TRACK self, std::optional< int > aMargin)"""
        return _pcbnew.PCB_TRACK_SetLocalSolderMaskMargin(self, aMargin)
 
    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(PCB_TRACK self) -> std::optional< int >"""
        return _pcbnew.PCB_TRACK_GetLocalSolderMaskMargin(self)
 
    def GetSolderMaskExpansion(self):
        r"""GetSolderMaskExpansion(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetSolderMaskExpansion(self)
 
    def GetLength(self):
        r"""GetLength(PCB_TRACK self) -> double"""
        return _pcbnew.PCB_TRACK_GetLength(self)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_TRACK self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PCB_TRACK_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_TRACK self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TRACK_GetEffectiveShape(self, *args)
 
    def IsPointOnEnds(self, point, min_dist=0):
        r"""IsPointOnEnds(PCB_TRACK self, VECTOR2I point, int min_dist=0) -> EDA_ITEM_FLAGS"""
        return _pcbnew.PCB_TRACK_IsPointOnEnds(self, point, min_dist)
 
    def IsNull(self):
        r"""IsNull(PCB_TRACK self) -> bool"""
        return _pcbnew.PCB_TRACK_IsNull(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_TRACK self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_TRACK self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TRACK_HitTest(self, *args)
 
    def ApproxCollinear(self, aTrack):
        r"""ApproxCollinear(PCB_TRACK self, PCB_TRACK aTrack) -> bool"""
        return _pcbnew.PCB_TRACK_ApproxCollinear(self, aTrack)
 
    def GetClass(self):
        r"""GetClass(PCB_TRACK self) -> wxString"""
        return _pcbnew.PCB_TRACK_GetClass(self)
 
    def GetWidthConstraint(self, aSource=None):
        r"""GetWidthConstraint(PCB_TRACK self, wxString aSource=None) -> MINOPTMAX< int >"""
        return _pcbnew.PCB_TRACK_GetWidthConstraint(self, aSource)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_TRACK self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_TRACK_ViewGetLOD(self, aLayer, aView)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_TRACK self, BOARD_ITEM aOther) -> bool
        __eq__(PCB_TRACK self, PCB_TRACK aOther) -> bool
        """
        return _pcbnew.PCB_TRACK___eq__(self, *args)
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_TRACK self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_TRACK_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_TRACK self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_TRACK_Deserialize(self, aContainer)
    __swig_destroy__ = _pcbnew.delete_PCB_TRACK
 
# Register PCB_TRACK in _pcbnew:
_pcbnew.PCB_TRACK_swigregister(PCB_TRACK)
PAD_SHAPE_RECT = cvar.PAD_SHAPE_RECT
 
class PCB_ARC(PCB_TRACK):
    r"""Proxy of C++ PCB_ARC 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_ARC self, BOARD_ITEM aParent) -> PCB_ARC
        __init__(PCB_ARC self, BOARD_ITEM aParent, SHAPE_ARC aArc) -> PCB_ARC
        """
        _pcbnew.PCB_ARC_swiginit(self, _pcbnew.new_PCB_ARC(*args))
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_ARC_ClassOf(aItem)
 
    def SetMid(self, aMid):
        r"""SetMid(PCB_ARC self, VECTOR2I aMid)"""
        return _pcbnew.PCB_ARC_SetMid(self, aMid)
 
    def GetMid(self):
        r"""GetMid(PCB_ARC self) -> VECTOR2I"""
        return _pcbnew.PCB_ARC_GetMid(self)
 
    def GetRadius(self):
        r"""GetRadius(PCB_ARC self) -> double"""
        return _pcbnew.PCB_ARC_GetRadius(self)
 
    def GetAngle(self):
        r"""GetAngle(PCB_ARC self) -> EDA_ANGLE"""
        return _pcbnew.PCB_ARC_GetAngle(self)
 
    def GetArcAngleStart(self):
        r"""GetArcAngleStart(PCB_ARC self) -> EDA_ANGLE"""
        return _pcbnew.PCB_ARC_GetArcAngleStart(self)
 
    def GetArcAngleEnd(self):
        r"""GetArcAngleEnd(PCB_ARC self) -> EDA_ANGLE"""
        return _pcbnew.PCB_ARC_GetArcAngleEnd(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_ARC self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_ARC self, BOX2I aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_ARC_HitTest(self, *args)
 
    def IsCCW(self):
        r"""IsCCW(PCB_ARC self) -> bool"""
        return _pcbnew.PCB_ARC_IsCCW(self)
 
    def GetClass(self):
        r"""GetClass(PCB_ARC self) -> wxString"""
        return _pcbnew.PCB_ARC_GetClass(self)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_ARC self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_ARC_GetEffectiveShape(self, *args)
 
    def IsDegenerated(self, aThreshold=5):
        r"""IsDegenerated(PCB_ARC self, int aThreshold=5) -> bool"""
        return _pcbnew.PCB_ARC_IsDegenerated(self, aThreshold)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_ARC self, PCB_ARC aOther) -> bool
        __eq__(PCB_ARC self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_ARC___eq__(self, *args)
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_ARC self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_ARC_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_ARC self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_ARC_Deserialize(self, aContainer)
    __swig_destroy__ = _pcbnew.delete_PCB_ARC
 
# Register PCB_ARC in _pcbnew:
_pcbnew.PCB_ARC_swigregister(PCB_ARC)
class PCB_VIA(PCB_TRACK):
    r"""Proxy of C++ PCB_VIA 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.PCB_VIA_ClassOf(aItem)
 
    def __init__(self, *args):
        r"""
        __init__(PCB_VIA self, BOARD_ITEM aParent) -> PCB_VIA
        __init__(PCB_VIA self, PCB_VIA aOther) -> PCB_VIA
        """
        _pcbnew.PCB_VIA_swiginit(self, _pcbnew.new_PCB_VIA(*args))
 
    def HasValidLayerPair(self, aCopperLayerCount):
        r"""HasValidLayerPair(PCB_VIA self, int aCopperLayerCount) -> bool"""
        return _pcbnew.PCB_VIA_HasValidLayerPair(self, aCopperLayerCount)
 
    def GetViaType(self):
        r"""GetViaType(PCB_VIA self) -> VIATYPE"""
        return _pcbnew.PCB_VIA_GetViaType(self)
 
    def SetViaType(self, aViaType):
        r"""SetViaType(PCB_VIA self, VIATYPE aViaType)"""
        return _pcbnew.PCB_VIA_SetViaType(self, aViaType)
 
    def Padstack(self, *args):
        r"""
        Padstack(PCB_VIA self) -> PADSTACK
        Padstack(PCB_VIA self) -> PADSTACK
        """
        return _pcbnew.PCB_VIA_Padstack(self, *args)
 
    def SetPadstack(self, aPadstack):
        r"""SetPadstack(PCB_VIA self, PADSTACK aPadstack)"""
        return _pcbnew.PCB_VIA_SetPadstack(self, aPadstack)
 
    def SetWidth(self, *args):
        r"""
        SetWidth(PCB_VIA self, int aWidth)
        SetWidth(PCB_VIA self, PCB_LAYER_ID aLayer, int aWidth)
        """
        return _pcbnew.PCB_VIA_SetWidth(self, *args)
 
    def GetWidth(self, *args):
        r"""
        GetWidth(PCB_VIA self) -> int
        GetWidth(PCB_VIA self, PCB_LAYER_ID aLayer) -> int
        """
        return _pcbnew.PCB_VIA_GetWidth(self, *args)
 
    def SetFrontWidth(self, aWidth):
        r"""SetFrontWidth(PCB_VIA self, int aWidth)"""
        return _pcbnew.PCB_VIA_SetFrontWidth(self, aWidth)
 
    def GetFrontWidth(self):
        r"""GetFrontWidth(PCB_VIA self) -> int"""
        return _pcbnew.PCB_VIA_GetFrontWidth(self)
 
    def GetWidthConstraint(self, aSource=None):
        r"""GetWidthConstraint(PCB_VIA self, wxString aSource=None) -> MINOPTMAX< int >"""
        return _pcbnew.PCB_VIA_GetWidthConstraint(self, aSource)
 
    def GetDrillConstraint(self, aSource=None):
        r"""GetDrillConstraint(PCB_VIA self, wxString aSource=None) -> MINOPTMAX< int >"""
        return _pcbnew.PCB_VIA_GetDrillConstraint(self, aSource)
 
    def SetFrontTentingMode(self, aMode):
        r"""SetFrontTentingMode(PCB_VIA self, TENTING_MODE aMode)"""
        return _pcbnew.PCB_VIA_SetFrontTentingMode(self, aMode)
 
    def GetFrontTentingMode(self):
        r"""GetFrontTentingMode(PCB_VIA self) -> TENTING_MODE"""
        return _pcbnew.PCB_VIA_GetFrontTentingMode(self)
 
    def SetBackTentingMode(self, aMode):
        r"""SetBackTentingMode(PCB_VIA self, TENTING_MODE aMode)"""
        return _pcbnew.PCB_VIA_SetBackTentingMode(self, aMode)
 
    def GetBackTentingMode(self):
        r"""GetBackTentingMode(PCB_VIA self) -> TENTING_MODE"""
        return _pcbnew.PCB_VIA_GetBackTentingMode(self)
 
    def GetSolderMaskExpansion(self):
        r"""GetSolderMaskExpansion(PCB_VIA self) -> int"""
        return _pcbnew.PCB_VIA_GetSolderMaskExpansion(self)
 
    def SetLayerPair(self, aTopLayer, aBottomLayer):
        r"""SetLayerPair(PCB_VIA self, PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)"""
        return _pcbnew.PCB_VIA_SetLayerPair(self, aTopLayer, aBottomLayer)
 
    def SetBottomLayer(self, aLayer):
        r"""SetBottomLayer(PCB_VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PCB_VIA_SetBottomLayer(self, aLayer)
 
    def SetTopLayer(self, aLayer):
        r"""SetTopLayer(PCB_VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PCB_VIA_SetTopLayer(self, aLayer)
 
    def LayerPair(self, top_layer, bottom_layer):
        r"""LayerPair(PCB_VIA self, PCB_LAYER_ID * top_layer, PCB_LAYER_ID * bottom_layer)"""
        return _pcbnew.PCB_VIA_LayerPair(self, top_layer, bottom_layer)
 
    def TopLayer(self):
        r"""TopLayer(PCB_VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.PCB_VIA_TopLayer(self)
 
    def BottomLayer(self):
        r"""BottomLayer(PCB_VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.PCB_VIA_BottomLayer(self)
 
    def SanitizeLayers(self):
        r"""SanitizeLayers(PCB_VIA self)"""
        return _pcbnew.PCB_VIA_SanitizeLayers(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_VIA self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_VIA self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_VIA_HitTest(self, *args)
 
    def GetClass(self):
        r"""GetClass(PCB_VIA self) -> wxString"""
        return _pcbnew.PCB_VIA_GetClass(self)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_VIA self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_VIA_ViewGetLOD(self, aLayer, aView)
 
    def GetMinAnnulus(self, aLayer, aSource):
        r"""GetMinAnnulus(PCB_VIA self, PCB_LAYER_ID aLayer, wxString aSource) -> int"""
        return _pcbnew.PCB_VIA_GetMinAnnulus(self, aLayer, aSource)
 
    def SetRemoveUnconnected(self, aSet):
        r"""SetRemoveUnconnected(PCB_VIA self, bool aSet)"""
        return _pcbnew.PCB_VIA_SetRemoveUnconnected(self, aSet)
 
    def GetRemoveUnconnected(self):
        r"""GetRemoveUnconnected(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_GetRemoveUnconnected(self)
 
    def SetKeepStartEnd(self, aSet):
        r"""SetKeepStartEnd(PCB_VIA self, bool aSet)"""
        return _pcbnew.PCB_VIA_SetKeepStartEnd(self, aSet)
 
    def GetKeepStartEnd(self):
        r"""GetKeepStartEnd(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_GetKeepStartEnd(self)
 
    def ConditionallyFlashed(self, aLayer):
        r"""ConditionallyFlashed(PCB_VIA self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PCB_VIA_ConditionallyFlashed(self, aLayer)
 
    def FlashLayer(self, *args):
        r"""
        FlashLayer(PCB_VIA self, int aLayer) -> bool
        FlashLayer(PCB_VIA self, LSET aLayers) -> bool
        """
        return _pcbnew.PCB_VIA_FlashLayer(self, *args)
 
    def GetOutermostConnectedLayers(self, aTopmost, aBottommost):
        r"""GetOutermostConnectedLayers(PCB_VIA self, PCB_LAYER_ID * aTopmost, PCB_LAYER_ID * aBottommost)"""
        return _pcbnew.PCB_VIA_GetOutermostConnectedLayers(self, aTopmost, aBottommost)
 
    def SetDrill(self, aDrill):
        r"""SetDrill(PCB_VIA self, int aDrill)"""
        return _pcbnew.PCB_VIA_SetDrill(self, aDrill)
 
    def GetDrill(self):
        r"""GetDrill(PCB_VIA self) -> int"""
        return _pcbnew.PCB_VIA_GetDrill(self)
 
    def GetDrillValue(self):
        r"""GetDrillValue(PCB_VIA self) -> int"""
        return _pcbnew.PCB_VIA_GetDrillValue(self)
 
    def SetDrillDefault(self):
        r"""SetDrillDefault(PCB_VIA self)"""
        return _pcbnew.PCB_VIA_SetDrillDefault(self)
 
    def GetIsFree(self):
        r"""GetIsFree(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_GetIsFree(self)
 
    def SetIsFree(self, aFree=True):
        r"""SetIsFree(PCB_VIA self, bool aFree=True)"""
        return _pcbnew.PCB_VIA_SetIsFree(self, aFree)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_VIA self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_VIA_GetEffectiveShape(self, *args)
 
    def ClearZoneLayerOverrides(self):
        r"""ClearZoneLayerOverrides(PCB_VIA self)"""
        return _pcbnew.PCB_VIA_ClearZoneLayerOverrides(self)
 
    def GetZoneLayerOverride(self, aLayer):
        r"""GetZoneLayerOverride(PCB_VIA self, PCB_LAYER_ID aLayer) -> ZONE_LAYER_OVERRIDE const &"""
        return _pcbnew.PCB_VIA_GetZoneLayerOverride(self, aLayer)
 
    def SetZoneLayerOverride(self, aLayer, aOverride):
        r"""SetZoneLayerOverride(PCB_VIA self, PCB_LAYER_ID aLayer, ZONE_LAYER_OVERRIDE aOverride)"""
        return _pcbnew.PCB_VIA_SetZoneLayerOverride(self, aLayer, aOverride)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_VIA self, PCB_VIA aOther) -> bool
        __eq__(PCB_VIA self, BOARD_ITEM aOther) -> bool
        """
        return _pcbnew.PCB_VIA___eq__(self, *args)
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_VIA self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_VIA_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_VIA self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_VIA_Deserialize(self, aContainer)
    __swig_destroy__ = _pcbnew.delete_PCB_VIA
 
# Register PCB_VIA in _pcbnew:
_pcbnew.PCB_VIA_swigregister(PCB_VIA)
class ISOLATED_ISLANDS(object):
    r"""Proxy of C++ ISOLATED_ISLANDS class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_IsolatedOutlines = property(_pcbnew.ISOLATED_ISLANDS_m_IsolatedOutlines_get, _pcbnew.ISOLATED_ISLANDS_m_IsolatedOutlines_set, doc=r"""m_IsolatedOutlines : std::vector<(int,std::allocator<(int)>)>""")
    m_SingleConnectionOutlines = property(_pcbnew.ISOLATED_ISLANDS_m_SingleConnectionOutlines_get, _pcbnew.ISOLATED_ISLANDS_m_SingleConnectionOutlines_set, doc=r"""m_SingleConnectionOutlines : std::vector<(int,std::allocator<(int)>)>""")
 
    def __init__(self):
        r"""__init__(ISOLATED_ISLANDS self) -> ISOLATED_ISLANDS"""
        _pcbnew.ISOLATED_ISLANDS_swiginit(self, _pcbnew.new_ISOLATED_ISLANDS())
    __swig_destroy__ = _pcbnew.delete_ISOLATED_ISLANDS
 
# Register ISOLATED_ISLANDS in _pcbnew:
_pcbnew.ISOLATED_ISLANDS_swigregister(ISOLATED_ISLANDS)
class ZONE(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ ZONE 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__(ZONE self, BOARD_ITEM_CONTAINER parent) -> ZONE
        __init__(ZONE self, ZONE aZone) -> ZONE
        """
        _pcbnew.ZONE_swiginit(self, _pcbnew.new_ZONE(*args))
    __swig_destroy__ = _pcbnew.delete_ZONE
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.ZONE_ClassOf(aItem)
 
    def Serialize(self, aContainer):
        r"""Serialize(ZONE self, google::protobuf::Any & aContainer)"""
        return _pcbnew.ZONE_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(ZONE self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.ZONE_Deserialize(self, aContainer)
 
    def InitDataFromSrcInCopyCtor(self, aZone):
        r"""InitDataFromSrcInCopyCtor(ZONE self, ZONE aZone)"""
        return _pcbnew.ZONE_InitDataFromSrcInCopyCtor(self, aZone)
 
    def IsConflicting(self):
        r"""IsConflicting(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsConflicting(self)
 
    def SetAssignedPriority(self, aPriority):
        r"""SetAssignedPriority(ZONE self, unsigned int aPriority)"""
        return _pcbnew.ZONE_SetAssignedPriority(self, aPriority)
 
    def GetAssignedPriority(self):
        r"""GetAssignedPriority(ZONE self) -> unsigned int"""
        return _pcbnew.ZONE_GetAssignedPriority(self)
 
    def HigherPriority(self, aOther):
        r"""HigherPriority(ZONE self, ZONE aOther) -> bool"""
        return _pcbnew.ZONE_HigherPriority(self, aOther)
 
    def SameNet(self, aOther):
        r"""SameNet(ZONE self, ZONE aOther) -> bool"""
        return _pcbnew.ZONE_SameNet(self, aOther)
 
    def SetLayerSetAndRemoveUnusedFills(self, aLayerSet):
        r"""SetLayerSetAndRemoveUnusedFills(ZONE self, LSET aLayerSet)"""
        return _pcbnew.ZONE_SetLayerSetAndRemoveUnusedFills(self, aLayerSet)
 
    def GetZoneName(self):
        r"""GetZoneName(ZONE self) -> wxString"""
        return _pcbnew.ZONE_GetZoneName(self)
 
    def SetZoneName(self, aName):
        r"""SetZoneName(ZONE self, wxString aName)"""
        return _pcbnew.ZONE_SetZoneName(self, aName)
 
    def CacheBoundingBox(self):
        r"""CacheBoundingBox(ZONE self)"""
        return _pcbnew.ZONE_CacheBoundingBox(self)
 
    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(ZONE self, std::optional< int > aClearance)"""
        return _pcbnew.ZONE_SetLocalClearance(self, aClearance)
 
    def GetLocalClearance(self, *args):
        r"""
        GetLocalClearance(ZONE self) -> std::optional< int >
        GetLocalClearance(ZONE self, wxString aSource) -> std::optional< int >
        """
        return _pcbnew.ZONE_GetLocalClearance(self, *args)
 
    def GetFirstLayer(self):
        r"""GetFirstLayer(ZONE self) -> PCB_LAYER_ID"""
        return _pcbnew.ZONE_GetFirstLayer(self)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(ZONE self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.ZONE_ViewGetLOD(self, aLayer, aView)
 
    def SetFillMode(self, aFillMode):
        r"""SetFillMode(ZONE self, ZONE_FILL_MODE aFillMode)"""
        return _pcbnew.ZONE_SetFillMode(self, aFillMode)
 
    def GetFillMode(self):
        r"""GetFillMode(ZONE self) -> ZONE_FILL_MODE"""
        return _pcbnew.ZONE_GetFillMode(self)
 
    def SetThermalReliefGap(self, aThermalReliefGap):
        r"""SetThermalReliefGap(ZONE self, int aThermalReliefGap)"""
        return _pcbnew.ZONE_SetThermalReliefGap(self, aThermalReliefGap)
 
    def GetThermalReliefGap(self, *args):
        r"""
        GetThermalReliefGap(ZONE self) -> int
        GetThermalReliefGap(ZONE self, PAD aPad, wxString aSource=None) -> int
        """
        return _pcbnew.ZONE_GetThermalReliefGap(self, *args)
 
    def SetThermalReliefSpokeWidth(self, aThermalReliefSpokeWidth):
        r"""SetThermalReliefSpokeWidth(ZONE self, int aThermalReliefSpokeWidth)"""
        return _pcbnew.ZONE_SetThermalReliefSpokeWidth(self, aThermalReliefSpokeWidth)
 
    def GetThermalReliefSpokeWidth(self):
        r"""GetThermalReliefSpokeWidth(ZONE self) -> int"""
        return _pcbnew.ZONE_GetThermalReliefSpokeWidth(self)
 
    def CalculateFilledArea(self):
        r"""CalculateFilledArea(ZONE self) -> double"""
        return _pcbnew.ZONE_CalculateFilledArea(self)
 
    def CalculateOutlineArea(self):
        r"""CalculateOutlineArea(ZONE self) -> double"""
        return _pcbnew.ZONE_CalculateOutlineArea(self)
 
    def GetFilledArea(self):
        r"""GetFilledArea(ZONE self) -> double"""
        return _pcbnew.ZONE_GetFilledArea(self)
 
    def GetOutlineArea(self):
        r"""GetOutlineArea(ZONE self) -> double"""
        return _pcbnew.ZONE_GetOutlineArea(self)
 
    def GetLock(self):
        r"""GetLock(ZONE self) -> std::mutex &"""
        return _pcbnew.ZONE_GetLock(self)
 
    def GetFillFlag(self, aLayer):
        r"""GetFillFlag(ZONE self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.ZONE_GetFillFlag(self, aLayer)
 
    def SetFillFlag(self, aLayer, aFlag):
        r"""SetFillFlag(ZONE self, PCB_LAYER_ID aLayer, bool aFlag)"""
        return _pcbnew.ZONE_SetFillFlag(self, aLayer, aFlag)
 
    def IsFilled(self):
        r"""IsFilled(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsFilled(self)
 
    def SetIsFilled(self, isFilled):
        r"""SetIsFilled(ZONE self, bool isFilled)"""
        return _pcbnew.ZONE_SetIsFilled(self, isFilled)
 
    def NeedRefill(self):
        r"""NeedRefill(ZONE self) -> bool"""
        return _pcbnew.ZONE_NeedRefill(self)
 
    def SetNeedRefill(self, aNeedRefill):
        r"""SetNeedRefill(ZONE self, bool aNeedRefill)"""
        return _pcbnew.ZONE_SetNeedRefill(self, aNeedRefill)
 
    def GetPadConnection(self):
        r"""GetPadConnection(ZONE self) -> ZONE_CONNECTION"""
        return _pcbnew.ZONE_GetPadConnection(self)
 
    def SetPadConnection(self, aPadConnection):
        r"""SetPadConnection(ZONE self, ZONE_CONNECTION aPadConnection)"""
        return _pcbnew.ZONE_SetPadConnection(self, aPadConnection)
 
    def GetMinThickness(self):
        r"""GetMinThickness(ZONE self) -> int"""
        return _pcbnew.ZONE_GetMinThickness(self)
 
    def SetMinThickness(self, aMinThickness):
        r"""SetMinThickness(ZONE self, int aMinThickness)"""
        return _pcbnew.ZONE_SetMinThickness(self, aMinThickness)
 
    def GetHatchThickness(self):
        r"""GetHatchThickness(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchThickness(self)
 
    def SetHatchThickness(self, aThickness):
        r"""SetHatchThickness(ZONE self, int aThickness)"""
        return _pcbnew.ZONE_SetHatchThickness(self, aThickness)
 
    def GetHatchGap(self):
        r"""GetHatchGap(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchGap(self)
 
    def SetHatchGap(self, aStep):
        r"""SetHatchGap(ZONE self, int aStep)"""
        return _pcbnew.ZONE_SetHatchGap(self, aStep)
 
    def GetHatchOrientation(self):
        r"""GetHatchOrientation(ZONE self) -> EDA_ANGLE"""
        return _pcbnew.ZONE_GetHatchOrientation(self)
 
    def SetHatchOrientation(self, aStep):
        r"""SetHatchOrientation(ZONE self, EDA_ANGLE aStep)"""
        return _pcbnew.ZONE_SetHatchOrientation(self, aStep)
 
    def GetHatchSmoothingLevel(self):
        r"""GetHatchSmoothingLevel(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchSmoothingLevel(self)
 
    def SetHatchSmoothingLevel(self, aLevel):
        r"""SetHatchSmoothingLevel(ZONE self, int aLevel)"""
        return _pcbnew.ZONE_SetHatchSmoothingLevel(self, aLevel)
 
    def GetHatchSmoothingValue(self):
        r"""GetHatchSmoothingValue(ZONE self) -> double"""
        return _pcbnew.ZONE_GetHatchSmoothingValue(self)
 
    def SetHatchSmoothingValue(self, aValue):
        r"""SetHatchSmoothingValue(ZONE self, double aValue)"""
        return _pcbnew.ZONE_SetHatchSmoothingValue(self, aValue)
 
    def GetHatchHoleMinArea(self):
        r"""GetHatchHoleMinArea(ZONE self) -> double"""
        return _pcbnew.ZONE_GetHatchHoleMinArea(self)
 
    def SetHatchHoleMinArea(self, aPct):
        r"""SetHatchHoleMinArea(ZONE self, double aPct)"""
        return _pcbnew.ZONE_SetHatchHoleMinArea(self, aPct)
 
    def GetHatchBorderAlgorithm(self):
        r"""GetHatchBorderAlgorithm(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchBorderAlgorithm(self)
 
    def SetHatchBorderAlgorithm(self, aAlgo):
        r"""SetHatchBorderAlgorithm(ZONE self, int aAlgo)"""
        return _pcbnew.ZONE_SetHatchBorderAlgorithm(self, aAlgo)
 
    def GetSelectedCorner(self):
        r"""GetSelectedCorner(ZONE self) -> int"""
        return _pcbnew.ZONE_GetSelectedCorner(self)
 
    def SetSelectedCorner(self, aCorner):
        r"""SetSelectedCorner(ZONE self, int aCorner)"""
        return _pcbnew.ZONE_SetSelectedCorner(self, aCorner)
 
    def GetLocalFlags(self):
        r"""GetLocalFlags(ZONE self) -> int"""
        return _pcbnew.ZONE_GetLocalFlags(self)
 
    def SetLocalFlags(self, aFlags):
        r"""SetLocalFlags(ZONE self, int aFlags)"""
        return _pcbnew.ZONE_SetLocalFlags(self, aFlags)
 
    def Outline(self, *args):
        r"""
        Outline(ZONE self) -> SHAPE_POLY_SET
        Outline(ZONE self) -> SHAPE_POLY_SET
        """
        return _pcbnew.ZONE_Outline(self, *args)
 
    def SetOutline(self, aOutline):
        r"""SetOutline(ZONE self, SHAPE_POLY_SET aOutline)"""
        return _pcbnew.ZONE_SetOutline(self, aOutline)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(ZONE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.ZONE_GetEffectiveShape(self, *args)
 
    def HitTestFilledArea(self, aLayer, aRefPos, aAccuracy=0):
        r"""HitTestFilledArea(ZONE self, PCB_LAYER_ID aLayer, VECTOR2I aRefPos, int aAccuracy=0) -> bool"""
        return _pcbnew.ZONE_HitTestFilledArea(self, aLayer, aRefPos, aAccuracy)
 
    def HitTestCutout(self, aRefPos, aOutlineIdx=None, aHoleIdx=None):
        r"""HitTestCutout(ZONE self, VECTOR2I aRefPos, int * aOutlineIdx=None, int * aHoleIdx=None) -> bool"""
        return _pcbnew.ZONE_HitTestCutout(self, aRefPos, aOutlineIdx, aHoleIdx)
 
    def GetInteractingZones(self, aLayer, aSameNetCollidingZones, aOtherNetIntersectingZones):
        r"""GetInteractingZones(ZONE self, PCB_LAYER_ID aLayer, ZONES aSameNetCollidingZones, ZONES aOtherNetIntersectingZones)"""
        return _pcbnew.ZONE_GetInteractingZones(self, aLayer, aSameNetCollidingZones, aOtherNetIntersectingZones)
 
    def TransformSolidAreasShapesToPolygon(self, aLayer, aBuffer):
        r"""TransformSolidAreasShapesToPolygon(ZONE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aBuffer)"""
        return _pcbnew.ZONE_TransformSolidAreasShapesToPolygon(self, aLayer, aBuffer)
 
    def TransformSmoothedOutlineToPolygon(self, aBuffer, aClearance, aError, aErrorLoc, aBoardOutline):
        r"""TransformSmoothedOutlineToPolygon(ZONE self, SHAPE_POLY_SET aBuffer, int aClearance, int aError, ERROR_LOC aErrorLoc, SHAPE_POLY_SET aBoardOutline)"""
        return _pcbnew.ZONE_TransformSmoothedOutlineToPolygon(self, aBuffer, aClearance, aError, aErrorLoc, aBoardOutline)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(ZONE self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.ZONE_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth)
 
    def HitTestForCorner(self, refPos, aAccuracy, aCornerHit=None):
        r"""HitTestForCorner(ZONE self, VECTOR2I refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX * aCornerHit=None) -> bool"""
        return _pcbnew.ZONE_HitTestForCorner(self, refPos, aAccuracy, aCornerHit)
 
    def HitTestForEdge(self, refPos, aAccuracy, aCornerHit=None):
        r"""HitTestForEdge(ZONE self, VECTOR2I refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX * aCornerHit=None) -> bool"""
        return _pcbnew.ZONE_HitTestForEdge(self, refPos, aAccuracy, aCornerHit)
 
    def HitTest(self, *args):
        r"""
        HitTest(ZONE self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(ZONE self, BOX2I aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.ZONE_HitTest(self, *args)
 
    def UnFill(self):
        r"""UnFill(ZONE self) -> bool"""
        return _pcbnew.ZONE_UnFill(self)
 
    def MoveEdge(self, offset, aEdge):
        r"""MoveEdge(ZONE self, VECTOR2I offset, int aEdge)"""
        return _pcbnew.ZONE_MoveEdge(self, offset, aEdge)
 
    def GetClass(self):
        r"""GetClass(ZONE self) -> wxString"""
        return _pcbnew.ZONE_GetClass(self)
 
    def GetNumCorners(self):
        r"""GetNumCorners(ZONE self) -> int"""
        return _pcbnew.ZONE_GetNumCorners(self)
 
    def Iterate(self):
        r"""Iterate(ZONE self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_Iterate(self)
 
    def IterateWithHoles(self):
        r"""IterateWithHoles(ZONE self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_IterateWithHoles(self)
 
    def CIterateWithHoles(self):
        r"""CIterateWithHoles(ZONE self) -> SHAPE_POLY_SET::CONST_ITERATOR"""
        return _pcbnew.ZONE_CIterateWithHoles(self)
 
    def RemoveAllContours(self):
        r"""RemoveAllContours(ZONE self)"""
        return _pcbnew.ZONE_RemoveAllContours(self)
 
    def GetCornerPosition(self, aCornerIndex):
        r"""GetCornerPosition(ZONE self, int aCornerIndex) -> VECTOR2I"""
        return _pcbnew.ZONE_GetCornerPosition(self, aCornerIndex)
 
    def SetCornerPosition(self, aCornerIndex, new_pos):
        r"""SetCornerPosition(ZONE self, int aCornerIndex, VECTOR2I new_pos)"""
        return _pcbnew.ZONE_SetCornerPosition(self, aCornerIndex, new_pos)
 
    def NewHole(self):
        r"""NewHole(ZONE self)"""
        return _pcbnew.ZONE_NewHole(self)
 
    def AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication=False):
        r"""AppendCorner(ZONE self, VECTOR2I aPosition, int aHoleIdx, bool aAllowDuplication=False) -> bool"""
        return _pcbnew.ZONE_AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication)
 
    def GetHatchStyle(self):
        r"""GetHatchStyle(ZONE self) -> ZONE_BORDER_DISPLAY_STYLE"""
        return _pcbnew.ZONE_GetHatchStyle(self)
 
    def SetHatchStyle(self, aStyle):
        r"""SetHatchStyle(ZONE self, ZONE_BORDER_DISPLAY_STYLE aStyle)"""
        return _pcbnew.ZONE_SetHatchStyle(self, aStyle)
 
    def HasFilledPolysForLayer(self, aLayer):
        r"""HasFilledPolysForLayer(ZONE self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.ZONE_HasFilledPolysForLayer(self, aLayer)
 
    def GetFilledPolysList(self, aLayer):
        r"""GetFilledPolysList(ZONE self, PCB_LAYER_ID aLayer) -> std::shared_ptr< SHAPE_POLY_SET > const &"""
        return _pcbnew.ZONE_GetFilledPolysList(self, aLayer)
 
    def GetFill(self, aLayer):
        r"""GetFill(ZONE self, PCB_LAYER_ID aLayer) -> SHAPE_POLY_SET"""
        return _pcbnew.ZONE_GetFill(self, aLayer)
 
    def CacheTriangulation(self, aLayer=UNDEFINED_LAYER):
        r"""CacheTriangulation(ZONE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER)"""
        return _pcbnew.ZONE_CacheTriangulation(self, aLayer)
 
    def SetFilledPolysList(self, aLayer, aPolysList):
        r"""SetFilledPolysList(ZONE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_SetFilledPolysList(self, aLayer, aPolysList)
 
    def IsIsland(self, aLayer, aPolyIdx):
        r"""IsIsland(ZONE self, PCB_LAYER_ID aLayer, int aPolyIdx) -> bool"""
        return _pcbnew.ZONE_IsIsland(self, aLayer, aPolyIdx)
 
    def SetIsIsland(self, aLayer, aPolyIdx):
        r"""SetIsIsland(ZONE self, PCB_LAYER_ID aLayer, int aPolyIdx)"""
        return _pcbnew.ZONE_SetIsIsland(self, aLayer, aPolyIdx)
 
    def BuildSmoothedPoly(self, aSmoothedPoly, aLayer, aBoardOutline, aSmoothedPolyWithApron=None):
        r"""BuildSmoothedPoly(ZONE self, SHAPE_POLY_SET aSmoothedPoly, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aBoardOutline, SHAPE_POLY_SET aSmoothedPolyWithApron=None) -> bool"""
        return _pcbnew.ZONE_BuildSmoothedPoly(self, aSmoothedPoly, aLayer, aBoardOutline, aSmoothedPolyWithApron)
 
    def SetCornerSmoothingType(self, aType):
        r"""SetCornerSmoothingType(ZONE self, int aType)"""
        return _pcbnew.ZONE_SetCornerSmoothingType(self, aType)
 
    def GetCornerSmoothingType(self):
        r"""GetCornerSmoothingType(ZONE self) -> int"""
        return _pcbnew.ZONE_GetCornerSmoothingType(self)
 
    def SetCornerRadius(self, aRadius):
        r"""SetCornerRadius(ZONE self, unsigned int aRadius)"""
        return _pcbnew.ZONE_SetCornerRadius(self, aRadius)
 
    def GetCornerRadius(self):
        r"""GetCornerRadius(ZONE self) -> unsigned int"""
        return _pcbnew.ZONE_GetCornerRadius(self)
 
    def RemoveCutout(self, aOutlineIdx, aHoleIdx):
        r"""RemoveCutout(ZONE self, int aOutlineIdx, int aHoleIdx)"""
        return _pcbnew.ZONE_RemoveCutout(self, aOutlineIdx, aHoleIdx)
 
    def AddPolygon(self, *args):
        r"""
        AddPolygon(ZONE self, VECTOR_VECTOR2I aPolygon)
        AddPolygon(ZONE self, SHAPE_LINE_CHAIN aPolygon)
        """
        return _pcbnew.ZONE_AddPolygon(self, *args)
 
    def IsTeardropArea(self):
        r"""IsTeardropArea(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsTeardropArea(self)
 
    def SetTeardropAreaType(self, aType):
        r"""SetTeardropAreaType(ZONE self, TEARDROP_TYPE aType)"""
        return _pcbnew.ZONE_SetTeardropAreaType(self, aType)
 
    def GetTeardropAreaType(self):
        r"""GetTeardropAreaType(ZONE self) -> TEARDROP_TYPE"""
        return _pcbnew.ZONE_GetTeardropAreaType(self)
 
    def HasKeepoutParametersSet(self):
        r"""HasKeepoutParametersSet(ZONE self) -> bool"""
        return _pcbnew.ZONE_HasKeepoutParametersSet(self)
 
    def GetIsRuleArea(self):
        r"""GetIsRuleArea(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetIsRuleArea(self)
 
    def GetRuleAreaPlacementEnabled(self):
        r"""GetRuleAreaPlacementEnabled(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetRuleAreaPlacementEnabled(self)
 
    def GetRuleAreaPlacementSourceType(self):
        r"""GetRuleAreaPlacementSourceType(ZONE self) -> RULE_AREA_PLACEMENT_SOURCE_TYPE"""
        return _pcbnew.ZONE_GetRuleAreaPlacementSourceType(self)
 
    def GetRuleAreaPlacementSource(self):
        r"""GetRuleAreaPlacementSource(ZONE self) -> wxString"""
        return _pcbnew.ZONE_GetRuleAreaPlacementSource(self)
 
    def GetDoNotAllowCopperPour(self):
        r"""GetDoNotAllowCopperPour(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowCopperPour(self)
 
    def GetDoNotAllowVias(self):
        r"""GetDoNotAllowVias(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowVias(self)
 
    def GetDoNotAllowTracks(self):
        r"""GetDoNotAllowTracks(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowTracks(self)
 
    def GetDoNotAllowPads(self):
        r"""GetDoNotAllowPads(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowPads(self)
 
    def GetDoNotAllowFootprints(self):
        r"""GetDoNotAllowFootprints(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowFootprints(self)
 
    def SetIsRuleArea(self, aEnable):
        r"""SetIsRuleArea(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetIsRuleArea(self, aEnable)
 
    def SetRuleAreaPlacementEnabled(self, aEnabled):
        r"""SetRuleAreaPlacementEnabled(ZONE self, bool aEnabled)"""
        return _pcbnew.ZONE_SetRuleAreaPlacementEnabled(self, aEnabled)
 
    def SetRuleAreaPlacementSourceType(self, aType):
        r"""SetRuleAreaPlacementSourceType(ZONE self, RULE_AREA_PLACEMENT_SOURCE_TYPE aType)"""
        return _pcbnew.ZONE_SetRuleAreaPlacementSourceType(self, aType)
 
    def SetRuleAreaPlacementSource(self, aSource):
        r"""SetRuleAreaPlacementSource(ZONE self, wxString aSource)"""
        return _pcbnew.ZONE_SetRuleAreaPlacementSource(self, aSource)
 
    def SetDoNotAllowCopperPour(self, aEnable):
        r"""SetDoNotAllowCopperPour(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowCopperPour(self, aEnable)
 
    def SetDoNotAllowVias(self, aEnable):
        r"""SetDoNotAllowVias(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowVias(self, aEnable)
 
    def SetDoNotAllowTracks(self, aEnable):
        r"""SetDoNotAllowTracks(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowTracks(self, aEnable)
 
    def SetDoNotAllowPads(self, aEnable):
        r"""SetDoNotAllowPads(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowPads(self, aEnable)
 
    def SetDoNotAllowFootprints(self, aEnable):
        r"""SetDoNotAllowFootprints(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowFootprints(self, aEnable)
 
    def GetIslandRemovalMode(self):
        r"""GetIslandRemovalMode(ZONE self) -> ISLAND_REMOVAL_MODE"""
        return _pcbnew.ZONE_GetIslandRemovalMode(self)
 
    def SetIslandRemovalMode(self, aRemove):
        r"""SetIslandRemovalMode(ZONE self, ISLAND_REMOVAL_MODE aRemove)"""
        return _pcbnew.ZONE_SetIslandRemovalMode(self, aRemove)
 
    def GetMinIslandArea(self):
        r"""GetMinIslandArea(ZONE self) -> long long"""
        return _pcbnew.ZONE_GetMinIslandArea(self)
 
    def SetMinIslandArea(self, aArea):
        r"""SetMinIslandArea(ZONE self, long long aArea)"""
        return _pcbnew.ZONE_SetMinIslandArea(self, aArea)
 
    def GetBorderHatchPitch(self):
        r"""GetBorderHatchPitch(ZONE self) -> int"""
        return _pcbnew.ZONE_GetBorderHatchPitch(self)
 
    @staticmethod
    def GetDefaultHatchPitch():
        r"""GetDefaultHatchPitch() -> int"""
        return _pcbnew.ZONE_GetDefaultHatchPitch()
 
    def SetBorderDisplayStyle(self, aBorderHatchStyle, aBorderHatchPitch, aRebuilBorderdHatch):
        r"""SetBorderDisplayStyle(ZONE self, ZONE_BORDER_DISPLAY_STYLE aBorderHatchStyle, int aBorderHatchPitch, bool aRebuilBorderdHatch)"""
        return _pcbnew.ZONE_SetBorderDisplayStyle(self, aBorderHatchStyle, aBorderHatchPitch, aRebuilBorderdHatch)
 
    def SetBorderHatchPitch(self, aPitch):
        r"""SetBorderHatchPitch(ZONE self, int aPitch)"""
        return _pcbnew.ZONE_SetBorderHatchPitch(self, aPitch)
 
    def UnHatchBorder(self):
        r"""UnHatchBorder(ZONE self)"""
        return _pcbnew.ZONE_UnHatchBorder(self)
 
    def HatchBorder(self):
        r"""HatchBorder(ZONE self)"""
        return _pcbnew.ZONE_HatchBorder(self)
 
    def GetHatchLines(self):
        r"""GetHatchLines(ZONE self) -> std::vector< SEG,std::allocator< SEG > > const &"""
        return _pcbnew.ZONE_GetHatchLines(self)
 
    def BuildHashValue(self, aLayer):
        r"""BuildHashValue(ZONE self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.ZONE_BuildHashValue(self, aLayer)
 
    def GetHashValue(self, aLayer):
        r"""GetHashValue(ZONE self, PCB_LAYER_ID aLayer) -> HASH_128"""
        return _pcbnew.ZONE_GetHashValue(self, aLayer)
 
    def __eq__(self, *args):
        r"""
        __eq__(ZONE self, ZONE aOther) -> bool
        __eq__(ZONE self, BOARD_ITEM aOther) -> bool
        """
        return _pcbnew.ZONE___eq__(self, *args)
 
# Register ZONE in _pcbnew:
_pcbnew.ZONE_swigregister(ZONE)
ZONE_THERMAL_RELIEF_GAP_MM = _pcbnew.ZONE_THERMAL_RELIEF_GAP_MM
 
ZONE_THERMAL_RELIEF_COPPER_WIDTH_MM = _pcbnew.ZONE_THERMAL_RELIEF_COPPER_WIDTH_MM
 
ZONE_THICKNESS_MM = _pcbnew.ZONE_THICKNESS_MM
 
ZONE_THICKNESS_MIN_VALUE_MM = _pcbnew.ZONE_THICKNESS_MIN_VALUE_MM
 
ZONE_CLEARANCE_MM = _pcbnew.ZONE_CLEARANCE_MM
 
ZONE_CLEARANCE_MAX_VALUE_MM = _pcbnew.ZONE_CLEARANCE_MAX_VALUE_MM
 
ZONE_BORDER_HATCH_DIST_MM = _pcbnew.ZONE_BORDER_HATCH_DIST_MM
 
ZONE_BORDER_HATCH_MINDIST_MM = _pcbnew.ZONE_BORDER_HATCH_MINDIST_MM
 
ZONE_BORDER_HATCH_MAXDIST_MM = _pcbnew.ZONE_BORDER_HATCH_MAXDIST_MM
 
ZONE_MANAGER_REPOUR = _pcbnew.ZONE_MANAGER_REPOUR
 
ZONE_CONNECTION_INHERITED = _pcbnew.ZONE_CONNECTION_INHERITED
 
ZONE_CONNECTION_NONE = _pcbnew.ZONE_CONNECTION_NONE
 
ZONE_CONNECTION_THERMAL = _pcbnew.ZONE_CONNECTION_THERMAL
 
ZONE_CONNECTION_FULL = _pcbnew.ZONE_CONNECTION_FULL
 
ZONE_CONNECTION_THT_THERMAL = _pcbnew.ZONE_CONNECTION_THT_THERMAL
 
 
def PrintZoneConnection(aConnection):
    r"""PrintZoneConnection(ZONE_CONNECTION aConnection) -> wxString"""
    return _pcbnew.PrintZoneConnection(aConnection)
 
def InvokeNonCopperZonesEditor(aParent, aSettings, aConvertSettings=None):
    r"""InvokeNonCopperZonesEditor(PCB_BASE_FRAME * aParent, ZONE_SETTINGS aSettings, CONVERT_SETTINGS * aConvertSettings=None) -> int"""
    return _pcbnew.InvokeNonCopperZonesEditor(aParent, aSettings, aConvertSettings)
 
def InvokeCopperZonesEditor(aCaller, aSettings, aConvertSettings=None):
    r"""InvokeCopperZonesEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings, CONVERT_SETTINGS * aConvertSettings=None) -> int"""
    return _pcbnew.InvokeCopperZonesEditor(aCaller, aSettings, aConvertSettings)
 
def InvokeRuleAreaEditor(aCaller, aSettings, aBoard=None, aConvertSettings=None):
    r"""InvokeRuleAreaEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings, BOARD aBoard=None, CONVERT_SETTINGS * aConvertSettings=None) -> int"""
    return _pcbnew.InvokeRuleAreaEditor(aCaller, aSettings, aBoard, aConvertSettings)
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
    __swig_destroy__ = _pcbnew.delete_ZONE_FILLER
 
    def SetProgressReporter(self, aReporter):
        r"""SetProgressReporter(ZONE_FILLER self, PROGRESS_REPORTER * aReporter)"""
        return _pcbnew.ZONE_FILLER_SetProgressReporter(self, aReporter)
 
    def GetProgressReporter(self):
        r"""GetProgressReporter(ZONE_FILLER self) -> PROGRESS_REPORTER *"""
        return _pcbnew.ZONE_FILLER_GetProgressReporter(self)
 
    def Fill(self, aZones, aCheck=False, aParent=None):
        r"""Fill(ZONE_FILLER self, ZONES aZones, bool aCheck=False, wxWindow * aParent=None) -> bool"""
        return _pcbnew.ZONE_FILLER_Fill(self, aZones, aCheck, aParent)
 
    def IsDebug(self):
        r"""IsDebug(ZONE_FILLER self) -> bool"""
        return _pcbnew.ZONE_FILLER_IsDebug(self)
 
    def __init__(self, aBoard):
        r"""__init__(ZONE_FILLER self, BOARD aBoard) -> ZONE_FILLER"""
        _pcbnew.ZONE_FILLER_swiginit(self, _pcbnew.new_ZONE_FILLER(aBoard))
 
# Register ZONE_FILLER in _pcbnew:
_pcbnew.ZONE_FILLER_swigregister(ZONE_FILLER)
ZONE_FILL_MODE_POLYGONS = _pcbnew.ZONE_FILL_MODE_POLYGONS
 
ZONE_FILL_MODE_HATCH_PATTERN = _pcbnew.ZONE_FILL_MODE_HATCH_PATTERN
 
ZONE_BORDER_DISPLAY_STYLE_NO_HATCH = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_NO_HATCH
 
ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_FULL = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_FULL
 
ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_EDGE = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_EDGE
 
ZONE_BORDER_DISPLAY_STYLE_INVISIBLE_BORDER = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_INVISIBLE_BORDER
 
ISLAND_REMOVAL_MODE_ALWAYS = _pcbnew.ISLAND_REMOVAL_MODE_ALWAYS
 
ISLAND_REMOVAL_MODE_NEVER = _pcbnew.ISLAND_REMOVAL_MODE_NEVER
 
ISLAND_REMOVAL_MODE_AREA = _pcbnew.ISLAND_REMOVAL_MODE_AREA
 
RULE_AREA_PLACEMENT_SOURCE_TYPE_SHEETNAME = _pcbnew.RULE_AREA_PLACEMENT_SOURCE_TYPE_SHEETNAME
 
RULE_AREA_PLACEMENT_SOURCE_TYPE_COMPONENT_CLASS = _pcbnew.RULE_AREA_PLACEMENT_SOURCE_TYPE_COMPONENT_CLASS
 
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_ZonePriority = property(_pcbnew.ZONE_SETTINGS_m_ZonePriority_get, _pcbnew.ZONE_SETTINGS_m_ZonePriority_set, doc=r"""m_ZonePriority : unsigned int""")
    m_FillMode = property(_pcbnew.ZONE_SETTINGS_m_FillMode_get, _pcbnew.ZONE_SETTINGS_m_FillMode_set, doc=r"""m_FillMode : ZONE_FILL_MODE""")
    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_HatchThickness = property(_pcbnew.ZONE_SETTINGS_m_HatchThickness_get, _pcbnew.ZONE_SETTINGS_m_HatchThickness_set, doc=r"""m_HatchThickness : int""")
    m_HatchGap = property(_pcbnew.ZONE_SETTINGS_m_HatchGap_get, _pcbnew.ZONE_SETTINGS_m_HatchGap_set, doc=r"""m_HatchGap : int""")
    m_HatchOrientation = property(_pcbnew.ZONE_SETTINGS_m_HatchOrientation_get, _pcbnew.ZONE_SETTINGS_m_HatchOrientation_set, doc=r"""m_HatchOrientation : EDA_ANGLE""")
    m_HatchSmoothingLevel = property(_pcbnew.ZONE_SETTINGS_m_HatchSmoothingLevel_get, _pcbnew.ZONE_SETTINGS_m_HatchSmoothingLevel_set, doc=r"""m_HatchSmoothingLevel : int""")
    m_HatchSmoothingValue = property(_pcbnew.ZONE_SETTINGS_m_HatchSmoothingValue_get, _pcbnew.ZONE_SETTINGS_m_HatchSmoothingValue_set, doc=r"""m_HatchSmoothingValue : double""")
    m_HatchHoleMinArea = property(_pcbnew.ZONE_SETTINGS_m_HatchHoleMinArea_get, _pcbnew.ZONE_SETTINGS_m_HatchHoleMinArea_set, doc=r"""m_HatchHoleMinArea : double""")
    m_HatchBorderAlgorithm = property(_pcbnew.ZONE_SETTINGS_m_HatchBorderAlgorithm_get, _pcbnew.ZONE_SETTINGS_m_HatchBorderAlgorithm_set, doc=r"""m_HatchBorderAlgorithm : int""")
    m_Netcode = property(_pcbnew.ZONE_SETTINGS_m_Netcode_get, _pcbnew.ZONE_SETTINGS_m_Netcode_set, doc=r"""m_Netcode : int""")
    m_Name = property(_pcbnew.ZONE_SETTINGS_m_Name_get, _pcbnew.ZONE_SETTINGS_m_Name_set, doc=r"""m_Name : wxString""")
    m_Layers = property(_pcbnew.ZONE_SETTINGS_m_Layers_get, _pcbnew.ZONE_SETTINGS_m_Layers_set, doc=r"""m_Layers : LSET""")
    m_ZoneBorderDisplayStyle = property(_pcbnew.ZONE_SETTINGS_m_ZoneBorderDisplayStyle_get, _pcbnew.ZONE_SETTINGS_m_ZoneBorderDisplayStyle_set, doc=r"""m_ZoneBorderDisplayStyle : ZONE_BORDER_DISPLAY_STYLE""")
    m_BorderHatchPitch = property(_pcbnew.ZONE_SETTINGS_m_BorderHatchPitch_get, _pcbnew.ZONE_SETTINGS_m_BorderHatchPitch_set, doc=r"""m_BorderHatchPitch : int""")
    m_ThermalReliefGap = property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set, doc=r"""m_ThermalReliefGap : long""")
    m_ThermalReliefSpokeWidth = property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefSpokeWidth_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefSpokeWidth_set, doc=r"""m_ThermalReliefSpokeWidth : long""")
    m_Locked = property(_pcbnew.ZONE_SETTINGS_m_Locked_get, _pcbnew.ZONE_SETTINGS_m_Locked_set, doc=r"""m_Locked : bool""")
    m_TeardropType = property(_pcbnew.ZONE_SETTINGS_m_TeardropType_get, _pcbnew.ZONE_SETTINGS_m_TeardropType_set, doc=r"""m_TeardropType : TEARDROP_TYPE""")
 
    def __init__(self):
        r"""__init__(ZONE_SETTINGS self) -> ZONE_SETTINGS"""
        _pcbnew.ZONE_SETTINGS_swiginit(self, _pcbnew.new_ZONE_SETTINGS())
 
    def __eq__(self, aOther):
        r"""__eq__(ZONE_SETTINGS self, ZONE_SETTINGS aOther) -> bool"""
        return _pcbnew.ZONE_SETTINGS___eq__(self, aOther)
 
    def __ne__(self, aOther):
        r"""__ne__(ZONE_SETTINGS self, ZONE_SETTINGS aOther) -> bool"""
        return _pcbnew.ZONE_SETTINGS___ne__(self, aOther)
 
    def __lshift__(self, aSource):
        r"""__lshift__(ZONE_SETTINGS self, ZONE aSource) -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS___lshift__(self, aSource)
 
    @staticmethod
    def GetDefaultSettings():
        r"""GetDefaultSettings() -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS_GetDefaultSettings()
 
    def SetupLayersList(self, aList, aFrame, aLayers, aFpEditorMode):
        r"""SetupLayersList(ZONE_SETTINGS self, wxDataViewListCtrl * aList, PCB_BASE_FRAME * aFrame, LSET aLayers, bool aFpEditorMode)"""
        return _pcbnew.ZONE_SETTINGS_SetupLayersList(self, aList, aFrame, aLayers, aFpEditorMode)
 
    def ExportSetting(self, aTarget, aFullExport=True):
        r"""ExportSetting(ZONE_SETTINGS self, ZONE 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) -> ZONE_CONNECTION"""
        return _pcbnew.ZONE_SETTINGS_GetPadConnection(self)
 
    def SetPadConnection(self, aPadConnection):
        r"""SetPadConnection(ZONE_SETTINGS self, ZONE_CONNECTION aPadConnection)"""
        return _pcbnew.ZONE_SETTINGS_SetPadConnection(self, aPadConnection)
 
    def HasKeepoutParametersSet(self):
        r"""HasKeepoutParametersSet(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_HasKeepoutParametersSet(self)
 
    def GetIsRuleArea(self):
        r"""GetIsRuleArea(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetIsRuleArea(self)
 
    def GetRuleAreaPlacementEnabled(self):
        r"""GetRuleAreaPlacementEnabled(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetRuleAreaPlacementEnabled(self)
 
    def GetRuleAreaPlacementSourceType(self):
        r"""GetRuleAreaPlacementSourceType(ZONE_SETTINGS self) -> RULE_AREA_PLACEMENT_SOURCE_TYPE"""
        return _pcbnew.ZONE_SETTINGS_GetRuleAreaPlacementSourceType(self)
 
    def GetRuleAreaPlacementSource(self):
        r"""GetRuleAreaPlacementSource(ZONE_SETTINGS self) -> wxString"""
        return _pcbnew.ZONE_SETTINGS_GetRuleAreaPlacementSource(self)
 
    def GetDoNotAllowCopperPour(self):
        r"""GetDoNotAllowCopperPour(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowCopperPour(self)
 
    def GetDoNotAllowVias(self):
        r"""GetDoNotAllowVias(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowVias(self)
 
    def GetDoNotAllowTracks(self):
        r"""GetDoNotAllowTracks(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowTracks(self)
 
    def GetDoNotAllowPads(self):
        r"""GetDoNotAllowPads(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowPads(self)
 
    def GetDoNotAllowFootprints(self):
        r"""GetDoNotAllowFootprints(ZONE_SETTINGS self) -> bool"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowFootprints(self)
 
    def SetIsRuleArea(self, aEnable):
        r"""SetIsRuleArea(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetIsRuleArea(self, aEnable)
 
    def SetRuleAreaPlacementEnabled(self, aEnabled):
        r"""SetRuleAreaPlacementEnabled(ZONE_SETTINGS self, bool aEnabled)"""
        return _pcbnew.ZONE_SETTINGS_SetRuleAreaPlacementEnabled(self, aEnabled)
 
    def SetRuleAreaPlacementSourceType(self, aType):
        r"""SetRuleAreaPlacementSourceType(ZONE_SETTINGS self, RULE_AREA_PLACEMENT_SOURCE_TYPE aType)"""
        return _pcbnew.ZONE_SETTINGS_SetRuleAreaPlacementSourceType(self, aType)
 
    def SetRuleAreaPlacementSource(self, aSource):
        r"""SetRuleAreaPlacementSource(ZONE_SETTINGS self, wxString aSource)"""
        return _pcbnew.ZONE_SETTINGS_SetRuleAreaPlacementSource(self, aSource)
 
    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)
 
    def SetDoNotAllowPads(self, aEnable):
        r"""SetDoNotAllowPads(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowPads(self, aEnable)
 
    def SetDoNotAllowFootprints(self, aEnable):
        r"""SetDoNotAllowFootprints(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowFootprints(self, aEnable)
 
    def GetIslandRemovalMode(self):
        r"""GetIslandRemovalMode(ZONE_SETTINGS self) -> ISLAND_REMOVAL_MODE"""
        return _pcbnew.ZONE_SETTINGS_GetIslandRemovalMode(self)
 
    def SetIslandRemovalMode(self, aRemove):
        r"""SetIslandRemovalMode(ZONE_SETTINGS self, ISLAND_REMOVAL_MODE aRemove)"""
        return _pcbnew.ZONE_SETTINGS_SetIslandRemovalMode(self, aRemove)
 
    def GetMinIslandArea(self):
        r"""GetMinIslandArea(ZONE_SETTINGS self) -> long long"""
        return _pcbnew.ZONE_SETTINGS_GetMinIslandArea(self)
 
    def SetMinIslandArea(self, aArea):
        r"""SetMinIslandArea(ZONE_SETTINGS self, long long aArea)"""
        return _pcbnew.ZONE_SETTINGS_SetMinIslandArea(self, aArea)
    __swig_destroy__ = _pcbnew.delete_ZONE_SETTINGS
 
# Register ZONE_SETTINGS in _pcbnew:
_pcbnew.ZONE_SETTINGS_swigregister(ZONE_SETTINGS)
TENTHS_OF_A_DEGREE_T = _pcbnew.TENTHS_OF_A_DEGREE_T
 
DEGREES_T = _pcbnew.DEGREES_T
 
RADIANS_T = _pcbnew.RADIANS_T
 
class EDA_ANGLE(object):
    r"""Proxy of C++ EDA_ANGLE 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_ANGLE self, double aValue, EDA_ANGLE_T aAngleType) -> EDA_ANGLE
        __init__(EDA_ANGLE self, double aAngleInDegrees) -> EDA_ANGLE
        __init__(EDA_ANGLE self, VECTOR2D const & aVector) -> EDA_ANGLE
        __init__(EDA_ANGLE self) -> EDA_ANGLE
        """
        _pcbnew.EDA_ANGLE_swiginit(self, _pcbnew.new_EDA_ANGLE(*args))
 
    def AsDegrees(self):
        r"""AsDegrees(EDA_ANGLE self) -> double"""
        return _pcbnew.EDA_ANGLE_AsDegrees(self)
 
    def AsTenthsOfADegree(self):
        r"""AsTenthsOfADegree(EDA_ANGLE self) -> int"""
        return _pcbnew.EDA_ANGLE_AsTenthsOfADegree(self)
 
    def AsRadians(self):
        r"""AsRadians(EDA_ANGLE self) -> double"""
        return _pcbnew.EDA_ANGLE_AsRadians(self)
    DEGREES_TO_RADIANS = _pcbnew.EDA_ANGLE_DEGREES_TO_RADIANS
    
 
    def IsCardinal(self):
        r"""IsCardinal(EDA_ANGLE self) -> bool"""
        return _pcbnew.EDA_ANGLE_IsCardinal(self)
 
    def IsCardinal90(self):
        r"""IsCardinal90(EDA_ANGLE self) -> bool"""
        return _pcbnew.EDA_ANGLE_IsCardinal90(self)
 
    def IsZero(self):
        r"""IsZero(EDA_ANGLE self) -> bool"""
        return _pcbnew.EDA_ANGLE_IsZero(self)
 
    def IsHorizontal(self):
        r"""IsHorizontal(EDA_ANGLE self) -> bool"""
        return _pcbnew.EDA_ANGLE_IsHorizontal(self)
 
    def IsVertical(self):
        r"""IsVertical(EDA_ANGLE self) -> bool"""
        return _pcbnew.EDA_ANGLE_IsVertical(self)
 
    def IsParallelTo(self, aAngle):
        r"""IsParallelTo(EDA_ANGLE self, EDA_ANGLE aAngle) -> bool"""
        return _pcbnew.EDA_ANGLE_IsParallelTo(self, aAngle)
 
    def Invert(self):
        r"""Invert(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Invert(self)
 
    def Sin(self):
        r"""Sin(EDA_ANGLE self) -> double"""
        return _pcbnew.EDA_ANGLE_Sin(self)
 
    def Cos(self):
        r"""Cos(EDA_ANGLE self) -> double"""
        return _pcbnew.EDA_ANGLE_Cos(self)
 
    def Tan(self):
        r"""Tan(EDA_ANGLE self) -> double"""
        return _pcbnew.EDA_ANGLE_Tan(self)
 
    @staticmethod
    def Arccos(x):
        r"""Arccos(double x) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Arccos(x)
 
    @staticmethod
    def Arcsin(x):
        r"""Arcsin(double x) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Arcsin(x)
 
    @staticmethod
    def Arctan(x):
        r"""Arctan(double x) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Arctan(x)
 
    @staticmethod
    def Arctan2(y, x):
        r"""Arctan2(double y, double x) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Arctan2(y, x)
 
    def Normalize(self):
        r"""Normalize(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Normalize(self)
 
    def Normalized(self):
        r"""Normalized(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Normalized(self)
 
    def NormalizeNegative(self):
        r"""NormalizeNegative(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_NormalizeNegative(self)
 
    def Normalize90(self):
        r"""Normalize90(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Normalize90(self)
 
    def Normalize180(self):
        r"""Normalize180(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Normalize180(self)
 
    def Normalize720(self):
        r"""Normalize720(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Normalize720(self)
 
    def KeepUpright(self):
        r"""KeepUpright(EDA_ANGLE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_KeepUpright(self)
 
    def Round(self, digits):
        r"""Round(EDA_ANGLE self, int digits) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE_Round(self, digits)
 
    def __iadd__(self, aAngle):
        r"""__iadd__(EDA_ANGLE self, EDA_ANGLE aAngle) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE___iadd__(self, aAngle)
 
    def __isub__(self, aAngle):
        r"""__isub__(EDA_ANGLE self, EDA_ANGLE aAngle) -> EDA_ANGLE"""
        return _pcbnew.EDA_ANGLE___isub__(self, aAngle)
 
    def __add__(self, other):
        n = EDA_ANGLE(self.AsDegrees(), DEGREES_T)
        n += other
        return n
 
    def __sub__(self, other):
        n = EDA_ANGLE(self.AsDegrees(), DEGREES_T)
        n -= other
        return n
 
    def __mul__(self, other):
        return EDA_ANGLE(self.AsDegrees() * other, DEGREES_T)
 
    def __rmul__(self, other):
        return EDA_ANGLE(other * self.AsDegrees(), DEGREES_T)
 
    def __truediv__(self, other):
        return EDA_ANGLE(self.AsDegrees() / other, DEGREES_T)
 
    def __abs__(self):
        return EDA_ANGLE(abs(self.AsDegrees()), DEGREES_T)
 
    __swig_destroy__ = _pcbnew.delete_EDA_ANGLE
 
# Register EDA_ANGLE in _pcbnew:
_pcbnew.EDA_ANGLE_swigregister(EDA_ANGLE)
SHAPE_T_UNDEFINED = _pcbnew.SHAPE_T_UNDEFINED
 
SHAPE_T_SEGMENT = _pcbnew.SHAPE_T_SEGMENT
 
SHAPE_T_RECTANGLE = _pcbnew.SHAPE_T_RECTANGLE
 
SHAPE_T_ARC = _pcbnew.SHAPE_T_ARC
 
SHAPE_T_CIRCLE = _pcbnew.SHAPE_T_CIRCLE
 
SHAPE_T_POLY = _pcbnew.SHAPE_T_POLY
 
SHAPE_T_BEZIER = _pcbnew.SHAPE_T_BEZIER
 
FILL_T_NO_FILL = _pcbnew.FILL_T_NO_FILL
 
FILL_T_FILLED_SHAPE = _pcbnew.FILL_T_FILLED_SHAPE
 
FILL_T_FILLED_WITH_BG_BODYCOLOR = _pcbnew.FILL_T_FILLED_WITH_BG_BODYCOLOR
 
FILL_T_FILLED_WITH_COLOR = _pcbnew.FILL_T_FILLED_WITH_COLOR
 
class ARC_MID(object):
    r"""Proxy of C++ ARC_MID class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mid = property(_pcbnew.ARC_MID_mid_get, _pcbnew.ARC_MID_mid_set, doc=r"""mid : VECTOR2I""")
    start = property(_pcbnew.ARC_MID_start_get, _pcbnew.ARC_MID_start_set, doc=r"""start : VECTOR2I""")
    end = property(_pcbnew.ARC_MID_end_get, _pcbnew.ARC_MID_end_set, doc=r"""end : VECTOR2I""")
    center = property(_pcbnew.ARC_MID_center_get, _pcbnew.ARC_MID_center_set, doc=r"""center : VECTOR2I""")
 
    def __init__(self):
        r"""__init__(ARC_MID self) -> ARC_MID"""
        _pcbnew.ARC_MID_swiginit(self, _pcbnew.new_ARC_MID())
    __swig_destroy__ = _pcbnew.delete_ARC_MID
 
# Register ARC_MID in _pcbnew:
_pcbnew.ARC_MID_swigregister(ARC_MID)
ANGLE_HORIZONTAL = cvar.ANGLE_HORIZONTAL
ANGLE_VERTICAL = cvar.ANGLE_VERTICAL
FULL_CIRCLE = cvar.FULL_CIRCLE
ANGLE_0 = cvar.ANGLE_0
ANGLE_45 = cvar.ANGLE_45
ANGLE_90 = cvar.ANGLE_90
ANGLE_135 = cvar.ANGLE_135
ANGLE_180 = cvar.ANGLE_180
ANGLE_270 = cvar.ANGLE_270
ANGLE_360 = cvar.ANGLE_360
 
class EDA_SHAPE(object):
    r"""Proxy of C++ EDA_SHAPE 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_SHAPE self, SHAPE_T aType, int aLineWidth, FILL_T aFill) -> EDA_SHAPE
        __init__(EDA_SHAPE self, SHAPE aShape) -> EDA_SHAPE
        """
        _pcbnew.EDA_SHAPE_swiginit(self, _pcbnew.new_EDA_SHAPE(*args))
    __swig_destroy__ = _pcbnew.delete_EDA_SHAPE
 
    def SwapShape(self, aImage):
        r"""SwapShape(EDA_SHAPE self, EDA_SHAPE aImage)"""
        return _pcbnew.EDA_SHAPE_SwapShape(self, aImage)
 
    def Serialize(self, aContainer):
        r"""Serialize(EDA_SHAPE self, google::protobuf::Any & aContainer)"""
        return _pcbnew.EDA_SHAPE_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(EDA_SHAPE self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.EDA_SHAPE_Deserialize(self, aContainer)
 
    def ShowShape(self):
        r"""ShowShape(EDA_SHAPE self) -> wxString"""
        return _pcbnew.EDA_SHAPE_ShowShape(self)
 
    def SHAPE_T_asString(self):
        r"""SHAPE_T_asString(EDA_SHAPE self) -> wxString"""
        return _pcbnew.EDA_SHAPE_SHAPE_T_asString(self)
 
    def IsProxyItem(self):
        r"""IsProxyItem(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsProxyItem(self)
 
    def SetIsProxyItem(self, aIsProxy=True):
        r"""SetIsProxyItem(EDA_SHAPE self, bool aIsProxy=True)"""
        return _pcbnew.EDA_SHAPE_SetIsProxyItem(self, aIsProxy)
 
    def IsFilled(self):
        r"""IsFilled(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsFilled(self)
 
    def IsFilledForHitTesting(self):
        r"""IsFilledForHitTesting(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsFilledForHitTesting(self)
 
    def SetFilled(self, aFlag):
        r"""SetFilled(EDA_SHAPE self, bool aFlag)"""
        return _pcbnew.EDA_SHAPE_SetFilled(self, aFlag)
 
    def SetFillMode(self, aFill):
        r"""SetFillMode(EDA_SHAPE self, FILL_T aFill)"""
        return _pcbnew.EDA_SHAPE_SetFillMode(self, aFill)
 
    def GetFillMode(self):
        r"""GetFillMode(EDA_SHAPE self) -> FILL_T"""
        return _pcbnew.EDA_SHAPE_GetFillMode(self)
 
    def IsClosed(self):
        r"""IsClosed(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsClosed(self)
 
    def GetFillColor(self):
        r"""GetFillColor(EDA_SHAPE self) -> COLOR4D"""
        return _pcbnew.EDA_SHAPE_GetFillColor(self)
 
    def SetFillColor(self, aColor):
        r"""SetFillColor(EDA_SHAPE self, COLOR4D aColor)"""
        return _pcbnew.EDA_SHAPE_SetFillColor(self, aColor)
 
    def SetWidth(self, aWidth):
        r"""SetWidth(EDA_SHAPE self, int aWidth)"""
        return _pcbnew.EDA_SHAPE_SetWidth(self, aWidth)
 
    def GetWidth(self):
        r"""GetWidth(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetWidth(self)
 
    def GetEffectiveWidth(self):
        r"""GetEffectiveWidth(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetEffectiveWidth(self)
 
    def SetLineStyle(self, aStyle):
        r"""SetLineStyle(EDA_SHAPE self, LINE_STYLE const aStyle)"""
        return _pcbnew.EDA_SHAPE_SetLineStyle(self, aStyle)
 
    def GetLineStyle(self):
        r"""GetLineStyle(EDA_SHAPE self) -> LINE_STYLE"""
        return _pcbnew.EDA_SHAPE_GetLineStyle(self)
 
    def SetLineColor(self, aColor):
        r"""SetLineColor(EDA_SHAPE self, COLOR4D aColor)"""
        return _pcbnew.EDA_SHAPE_SetLineColor(self, aColor)
 
    def GetLineColor(self):
        r"""GetLineColor(EDA_SHAPE self) -> COLOR4D"""
        return _pcbnew.EDA_SHAPE_GetLineColor(self)
 
    def SetShape(self, aShape):
        r"""SetShape(EDA_SHAPE self, SHAPE_T aShape)"""
        return _pcbnew.EDA_SHAPE_SetShape(self, aShape)
 
    def GetShape(self):
        r"""GetShape(EDA_SHAPE self) -> SHAPE_T"""
        return _pcbnew.EDA_SHAPE_GetShape(self)
 
    def GetStart(self):
        r"""GetStart(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetStart(self)
 
    def GetStartY(self):
        r"""GetStartY(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetStartY(self)
 
    def GetStartX(self):
        r"""GetStartX(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetStartX(self)
 
    def SetStart(self, aStart):
        r"""SetStart(EDA_SHAPE self, VECTOR2I aStart)"""
        return _pcbnew.EDA_SHAPE_SetStart(self, aStart)
 
    def SetStartY(self, y):
        r"""SetStartY(EDA_SHAPE self, int y)"""
        return _pcbnew.EDA_SHAPE_SetStartY(self, y)
 
    def SetStartX(self, x):
        r"""SetStartX(EDA_SHAPE self, int x)"""
        return _pcbnew.EDA_SHAPE_SetStartX(self, x)
 
    def SetCenterY(self, y):
        r"""SetCenterY(EDA_SHAPE self, int y)"""
        return _pcbnew.EDA_SHAPE_SetCenterY(self, y)
 
    def SetCenterX(self, x):
        r"""SetCenterX(EDA_SHAPE self, int x)"""
        return _pcbnew.EDA_SHAPE_SetCenterX(self, x)
 
    def GetEnd(self):
        r"""GetEnd(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetEnd(self)
 
    def GetEndY(self):
        r"""GetEndY(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetEndY(self)
 
    def GetEndX(self):
        r"""GetEndX(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetEndX(self)
 
    def SetEnd(self, aEnd):
        r"""SetEnd(EDA_SHAPE self, VECTOR2I aEnd)"""
        return _pcbnew.EDA_SHAPE_SetEnd(self, aEnd)
 
    def SetEndY(self, aY):
        r"""SetEndY(EDA_SHAPE self, int aY)"""
        return _pcbnew.EDA_SHAPE_SetEndY(self, aY)
 
    def SetEndX(self, aX):
        r"""SetEndX(EDA_SHAPE self, int aX)"""
        return _pcbnew.EDA_SHAPE_SetEndX(self, aX)
 
    def SetRadius(self, aX):
        r"""SetRadius(EDA_SHAPE self, int aX)"""
        return _pcbnew.EDA_SHAPE_SetRadius(self, aX)
 
    def GetTopLeft(self):
        r"""GetTopLeft(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetTopLeft(self)
 
    def GetBotRight(self):
        r"""GetBotRight(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetBotRight(self)
 
    def SetTop(self, val):
        r"""SetTop(EDA_SHAPE self, int val)"""
        return _pcbnew.EDA_SHAPE_SetTop(self, val)
 
    def SetLeft(self, val):
        r"""SetLeft(EDA_SHAPE self, int val)"""
        return _pcbnew.EDA_SHAPE_SetLeft(self, val)
 
    def SetRight(self, val):
        r"""SetRight(EDA_SHAPE self, int val)"""
        return _pcbnew.EDA_SHAPE_SetRight(self, val)
 
    def SetBottom(self, val):
        r"""SetBottom(EDA_SHAPE self, int val)"""
        return _pcbnew.EDA_SHAPE_SetBottom(self, val)
 
    def SetBezierC1(self, aPt):
        r"""SetBezierC1(EDA_SHAPE self, VECTOR2I aPt)"""
        return _pcbnew.EDA_SHAPE_SetBezierC1(self, aPt)
 
    def GetBezierC1(self):
        r"""GetBezierC1(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetBezierC1(self)
 
    def SetBezierC2(self, aPt):
        r"""SetBezierC2(EDA_SHAPE self, VECTOR2I aPt)"""
        return _pcbnew.EDA_SHAPE_SetBezierC2(self, aPt)
 
    def GetBezierC2(self):
        r"""GetBezierC2(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetBezierC2(self)
 
    def SetCenter(self, aCenter):
        r"""SetCenter(EDA_SHAPE self, VECTOR2I aCenter)"""
        return _pcbnew.EDA_SHAPE_SetCenter(self, aCenter)
 
    def SetArcAngleAndEnd(self, aAngle, aCheckNegativeAngle=False):
        r"""SetArcAngleAndEnd(EDA_SHAPE self, EDA_ANGLE aAngle, bool aCheckNegativeAngle=False)"""
        return _pcbnew.EDA_SHAPE_SetArcAngleAndEnd(self, aAngle, aCheckNegativeAngle)
 
    def GetArcAngle(self):
        r"""GetArcAngle(EDA_SHAPE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_SHAPE_GetArcAngle(self)
 
    def GetSegmentAngle(self):
        r"""GetSegmentAngle(EDA_SHAPE self) -> EDA_ANGLE"""
        return _pcbnew.EDA_SHAPE_GetSegmentAngle(self)
 
    def EndsSwapped(self):
        r"""EndsSwapped(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_EndsSwapped(self)
 
    def GetArcMid(self):
        r"""GetArcMid(EDA_SHAPE self) -> VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetArcMid(self)
 
    def GetRectCorners(self):
        r"""GetRectCorners(EDA_SHAPE self) -> VECTOR_VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetRectCorners(self)
 
    def GetCornersInSequence(self, angle):
        r"""GetCornersInSequence(EDA_SHAPE self, EDA_ANGLE angle) -> VECTOR_VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetCornersInSequence(self, angle)
 
    def CalcArcAngles(self, aStartAngle, aEndAngle):
        r"""CalcArcAngles(EDA_SHAPE self, EDA_ANGLE aStartAngle, EDA_ANGLE aEndAngle)"""
        return _pcbnew.EDA_SHAPE_CalcArcAngles(self, aStartAngle, aEndAngle)
 
    def GetRadius(self):
        r"""GetRadius(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetRadius(self)
 
    def SetArcGeometry(self, aStart, aMid, aEnd):
        r"""SetArcGeometry(EDA_SHAPE self, VECTOR2I aStart, VECTOR2I aMid, VECTOR2I aEnd)"""
        return _pcbnew.EDA_SHAPE_SetArcGeometry(self, aStart, aMid, aEnd)
 
    def SetCachedArcData(self, aStart, aMid, aEnd, aCenter):
        r"""SetCachedArcData(EDA_SHAPE self, VECTOR2I aStart, VECTOR2I aMid, VECTOR2I aEnd, VECTOR2I aCenter)"""
        return _pcbnew.EDA_SHAPE_SetCachedArcData(self, aStart, aMid, aEnd, aCenter)
 
    def GetBezierPoints(self):
        r"""GetBezierPoints(EDA_SHAPE self) -> VECTOR_VECTOR2I"""
        return _pcbnew.EDA_SHAPE_GetBezierPoints(self)
 
    def DupPolyPointsList(self, aBuffer):
        r"""DupPolyPointsList(EDA_SHAPE self, VECTOR_VECTOR2I aBuffer)"""
        return _pcbnew.EDA_SHAPE_DupPolyPointsList(self, aBuffer)
 
    def GetPointCount(self):
        r"""GetPointCount(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetPointCount(self)
 
    def GetPolyShape(self, *args):
        r"""
        GetPolyShape(EDA_SHAPE self) -> SHAPE_POLY_SET
        GetPolyShape(EDA_SHAPE self) -> SHAPE_POLY_SET
        """
        return _pcbnew.EDA_SHAPE_GetPolyShape(self, *args)
 
    def IsPolyShapeValid(self):
        r"""IsPolyShapeValid(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsPolyShapeValid(self)
 
    def SetPolyShape(self, aShape):
        r"""SetPolyShape(EDA_SHAPE self, SHAPE_POLY_SET aShape)"""
        return _pcbnew.EDA_SHAPE_SetPolyShape(self, aShape)
 
    def SetPolyPoints(self, aPoints):
        r"""SetPolyPoints(EDA_SHAPE self, VECTOR_VECTOR2I aPoints)"""
        return _pcbnew.EDA_SHAPE_SetPolyPoints(self, aPoints)
 
    def RebuildBezierToSegmentsPointsList(self, aMaxError):
        r"""RebuildBezierToSegmentsPointsList(EDA_SHAPE self, int aMaxError)"""
        return _pcbnew.EDA_SHAPE_RebuildBezierToSegmentsPointsList(self, aMaxError)
 
    def MakeEffectiveShapes(self, aEdgeOnly=False):
        r"""MakeEffectiveShapes(EDA_SHAPE self, bool aEdgeOnly=False) -> std::vector< SHAPE *,std::allocator< SHAPE * > >"""
        return _pcbnew.EDA_SHAPE_MakeEffectiveShapes(self, aEdgeOnly)
 
    def ShapeGetMsgPanelInfo(self, aFrame, aList):
        r"""ShapeGetMsgPanelInfo(EDA_SHAPE self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDA_SHAPE_ShapeGetMsgPanelInfo(self, aFrame, aList)
 
    def SetLength(self, aLength):
        r"""SetLength(EDA_SHAPE self, double const & aLength)"""
        return _pcbnew.EDA_SHAPE_SetLength(self, aLength)
 
    def SetRectangleHeight(self, aHeight):
        r"""SetRectangleHeight(EDA_SHAPE self, int const & aHeight)"""
        return _pcbnew.EDA_SHAPE_SetRectangleHeight(self, aHeight)
 
    def SetRectangleWidth(self, aWidth):
        r"""SetRectangleWidth(EDA_SHAPE self, int const & aWidth)"""
        return _pcbnew.EDA_SHAPE_SetRectangleWidth(self, aWidth)
 
    def SetRectangle(self, aHeight, aWidth):
        r"""SetRectangle(EDA_SHAPE self, long long const & aHeight, long long const & aWidth)"""
        return _pcbnew.EDA_SHAPE_SetRectangle(self, aHeight, aWidth)
 
    def SetSegmentAngle(self, aAngle):
        r"""SetSegmentAngle(EDA_SHAPE self, EDA_ANGLE aAngle)"""
        return _pcbnew.EDA_SHAPE_SetSegmentAngle(self, aAngle)
 
    def IsClockwiseArc(self):
        r"""IsClockwiseArc(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsClockwiseArc(self)
 
    def GetLength(self):
        r"""GetLength(EDA_SHAPE self) -> double"""
        return _pcbnew.EDA_SHAPE_GetLength(self)
 
    def GetRectangleHeight(self):
        r"""GetRectangleHeight(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetRectangleHeight(self)
 
    def GetRectangleWidth(self):
        r"""GetRectangleWidth(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetRectangleWidth(self)
 
    def TransformShapeToPolygon(self, aBuffer, aClearance, aError, aErrorLoc, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(EDA_SHAPE self, SHAPE_POLY_SET aBuffer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.EDA_SHAPE_TransformShapeToPolygon(self, aBuffer, aClearance, aError, aErrorLoc, ignoreLineWidth)
 
    def Compare(self, aOther):
        r"""Compare(EDA_SHAPE self, EDA_SHAPE aOther) -> int"""
        return _pcbnew.EDA_SHAPE_Compare(self, aOther)
 
    def Similarity(self, aOther):
        r"""Similarity(EDA_SHAPE self, EDA_SHAPE aOther) -> double"""
        return _pcbnew.EDA_SHAPE_Similarity(self, aOther)
 
    def __eq__(self, aOther):
        r"""__eq__(EDA_SHAPE self, EDA_SHAPE aOther) -> bool"""
        return _pcbnew.EDA_SHAPE___eq__(self, aOther)
 
# Register EDA_SHAPE in _pcbnew:
_pcbnew.EDA_SHAPE_swigregister(EDA_SHAPE)
class PCB_SHAPE(BOARD_CONNECTED_ITEM, EDA_SHAPE):
    r"""Proxy of C++ PCB_SHAPE 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_SHAPE self, BOARD_ITEM aParent, KICAD_T aItemType, SHAPE_T aShapeType) -> PCB_SHAPE
        __init__(PCB_SHAPE self, BOARD_ITEM aParent=None, SHAPE_T aShapeType=SEGMENT) -> PCB_SHAPE
        """
        _pcbnew.PCB_SHAPE_swiginit(self, _pcbnew.new_PCB_SHAPE(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_SHAPE
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_SHAPE_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_SHAPE self) -> wxString"""
        return _pcbnew.PCB_SHAPE_GetClass(self)
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_SHAPE self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_SHAPE_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_SHAPE self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_SHAPE_Deserialize(self, aContainer)
 
    def GetConnectionPoints(self):
        r"""GetConnectionPoints(PCB_SHAPE self) -> VECTOR_VECTOR2I"""
        return _pcbnew.PCB_SHAPE_GetConnectionPoints(self)
 
    def GetCorners(self):
        r"""GetCorners(PCB_SHAPE self) -> VECTOR_VECTOR2I"""
        return _pcbnew.PCB_SHAPE_GetCorners(self)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_SHAPE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_SHAPE_GetEffectiveShape(self, *args)
 
    def SetIsProxyItem(self, aIsProxy=True):
        r"""SetIsProxyItem(PCB_SHAPE self, bool aIsProxy=True)"""
        return _pcbnew.PCB_SHAPE_SetIsProxyItem(self, aIsProxy)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_SHAPE self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_SHAPE self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_SHAPE_HitTest(self, *args)
 
    def Scale(self, aScale):
        r"""Scale(PCB_SHAPE self, double aScale)"""
        return _pcbnew.PCB_SHAPE_Scale(self, aScale)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_SHAPE self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PCB_SHAPE_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_SHAPE self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_SHAPE_ViewGetLOD(self, aLayer, aView)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_SHAPE self, PCB_SHAPE aShape) -> bool
        __eq__(PCB_SHAPE self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_SHAPE___eq__(self, *args)
 
    def SetHasSolderMask(self, aVal):
        r"""SetHasSolderMask(PCB_SHAPE self, bool aVal)"""
        return _pcbnew.PCB_SHAPE_SetHasSolderMask(self, aVal)
 
    def HasSolderMask(self):
        r"""HasSolderMask(PCB_SHAPE self) -> bool"""
        return _pcbnew.PCB_SHAPE_HasSolderMask(self)
 
    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(PCB_SHAPE self, std::optional< int > aMargin)"""
        return _pcbnew.PCB_SHAPE_SetLocalSolderMaskMargin(self, aMargin)
 
    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(PCB_SHAPE self) -> std::optional< int >"""
        return _pcbnew.PCB_SHAPE_GetLocalSolderMaskMargin(self)
 
    def GetSolderMaskExpansion(self):
        r"""GetSolderMaskExpansion(PCB_SHAPE self) -> int"""
        return _pcbnew.PCB_SHAPE_GetSolderMaskExpansion(self)
 
    def GetArcAngleStart(self):
        r"""GetArcAngleStart(PCB_SHAPE self) -> EDA_ANGLE"""
        return _pcbnew.PCB_SHAPE_GetArcAngleStart(self)
 
    def GetShapeStr(self):
        return self.ShowShape()
 
 
# Register PCB_SHAPE in _pcbnew:
_pcbnew.PCB_SHAPE_swigregister(PCB_SHAPE)
class PCB_TEXT(BOARD_ITEM, EDA_TEXT):
    r"""Proxy of C++ PCB_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__(PCB_TEXT self, BOARD_ITEM parent, KICAD_T idtype=PCB_TEXT_T) -> PCB_TEXT
        __init__(PCB_TEXT self, FOOTPRINT aParent, KICAD_T idtype=PCB_TEXT_T) -> PCB_TEXT
        """
        _pcbnew.PCB_TEXT_swiginit(self, _pcbnew.new_PCB_TEXT(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_TEXT
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TEXT_ClassOf(aItem)
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_TEXT self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_TEXT_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_TEXT self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_TEXT_Deserialize(self, aContainer)
 
    def KeepUpright(self):
        r"""KeepUpright(PCB_TEXT self)"""
        return _pcbnew.PCB_TEXT_KeepUpright(self)
 
    def GetShownText(self, aAllowExtraText, aDepth=0):
        r"""GetShownText(PCB_TEXT self, bool aAllowExtraText, int aDepth=0) -> wxString"""
        return _pcbnew.PCB_TEXT_GetShownText(self, aAllowExtraText, aDepth)
 
    def TextHitTest(self, *args):
        r"""
        TextHitTest(PCB_TEXT self, VECTOR2I aPoint, int aAccuracy=0) -> bool
        TextHitTest(PCB_TEXT self, BOX2I aRect, bool aContains, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TEXT_TextHitTest(self, *args)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_TEXT self, VECTOR2I aPosition, int aAccuracy) -> bool
        HitTest(PCB_TEXT self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TEXT_HitTest(self, *args)
 
    def GetClass(self):
        r"""GetClass(PCB_TEXT self) -> wxString"""
        return _pcbnew.PCB_TEXT_GetClass(self)
 
    def TransformTextToPolySet(self, aBuffer, aClearance, aMaxError, aErrorLoc):
        r"""TransformTextToPolySet(PCB_TEXT self, SHAPE_POLY_SET aBuffer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.PCB_TEXT_TransformTextToPolySet(self, aBuffer, aClearance, aMaxError, aErrorLoc)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aIgnoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_TEXT self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=False)"""
        return _pcbnew.PCB_TEXT_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aIgnoreLineWidth)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_TEXT self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TEXT_GetEffectiveShape(self, *args)
 
    def GetKnockoutCache(self, aFont, forResolvedText, aMaxError):
        r"""GetKnockoutCache(PCB_TEXT self, KIFONT::FONT const * aFont, wxString forResolvedText, int aMaxError) -> SHAPE_POLY_SET"""
        return _pcbnew.PCB_TEXT_GetKnockoutCache(self, aFont, forResolvedText, aMaxError)
 
    def GetTextTypeDescription(self):
        r"""GetTextTypeDescription(PCB_TEXT self) -> wxString"""
        return _pcbnew.PCB_TEXT_GetTextTypeDescription(self)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_TEXT self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_TEXT_ViewGetLOD(self, aLayer, aView)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_TEXT self, PCB_TEXT aOther) -> bool
        __eq__(PCB_TEXT self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_TEXT___eq__(self, *args)
 
# Register PCB_TEXT in _pcbnew:
_pcbnew.PCB_TEXT_swigregister(PCB_TEXT)
S_SEGMENT = cvar.S_SEGMENT
S_RECT = cvar.S_RECT
S_ARC = cvar.S_ARC
S_CIRCLE = cvar.S_CIRCLE
S_POLYGON = cvar.S_POLYGON
S_CURVE = cvar.S_CURVE
SHAPE_T_RECT = cvar.SHAPE_T_RECT
 
class PCB_TEXTBOX(PCB_SHAPE, EDA_TEXT):
    r"""Proxy of C++ PCB_TEXTBOX 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, aType=PCB_TEXTBOX_T):
        r"""__init__(PCB_TEXTBOX self, BOARD_ITEM aParent, KICAD_T aType=PCB_TEXTBOX_T) -> PCB_TEXTBOX"""
        _pcbnew.PCB_TEXTBOX_swiginit(self, _pcbnew.new_PCB_TEXTBOX(aParent, aType))
    __swig_destroy__ = _pcbnew.delete_PCB_TEXTBOX
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TEXTBOX_ClassOf(aItem)
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_TEXTBOX self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_TEXTBOX_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_TEXTBOX self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_TEXTBOX_Deserialize(self, aContainer)
 
    def GetLegacyTextMargin(self):
        r"""GetLegacyTextMargin(PCB_TEXTBOX self) -> int"""
        return _pcbnew.PCB_TEXTBOX_GetLegacyTextMargin(self)
 
    def SetMarginLeft(self, aLeft):
        r"""SetMarginLeft(PCB_TEXTBOX self, int aLeft)"""
        return _pcbnew.PCB_TEXTBOX_SetMarginLeft(self, aLeft)
 
    def SetMarginTop(self, aTop):
        r"""SetMarginTop(PCB_TEXTBOX self, int aTop)"""
        return _pcbnew.PCB_TEXTBOX_SetMarginTop(self, aTop)
 
    def SetMarginRight(self, aRight):
        r"""SetMarginRight(PCB_TEXTBOX self, int aRight)"""
        return _pcbnew.PCB_TEXTBOX_SetMarginRight(self, aRight)
 
    def SetMarginBottom(self, aBottom):
        r"""SetMarginBottom(PCB_TEXTBOX self, int aBottom)"""
        return _pcbnew.PCB_TEXTBOX_SetMarginBottom(self, aBottom)
 
    def GetMarginLeft(self):
        r"""GetMarginLeft(PCB_TEXTBOX self) -> int"""
        return _pcbnew.PCB_TEXTBOX_GetMarginLeft(self)
 
    def GetMarginTop(self):
        r"""GetMarginTop(PCB_TEXTBOX self) -> int"""
        return _pcbnew.PCB_TEXTBOX_GetMarginTop(self)
 
    def GetMarginRight(self):
        r"""GetMarginRight(PCB_TEXTBOX self) -> int"""
        return _pcbnew.PCB_TEXTBOX_GetMarginRight(self)
 
    def GetMarginBottom(self):
        r"""GetMarginBottom(PCB_TEXTBOX self) -> int"""
        return _pcbnew.PCB_TEXTBOX_GetMarginBottom(self)
 
    def GetDrawPos(self, *args):
        r"""
        GetDrawPos(PCB_TEXTBOX self) -> VECTOR2I
        GetDrawPos(PCB_TEXTBOX self, bool aIsFlipped) -> VECTOR2I
        """
        return _pcbnew.PCB_TEXTBOX_GetDrawPos(self, *args)
 
    def GetShownText(self, aAllowExtraText, aDepth=0):
        r"""GetShownText(PCB_TEXTBOX self, bool aAllowExtraText, int aDepth=0) -> wxString"""
        return _pcbnew.PCB_TEXTBOX_GetShownText(self, aAllowExtraText, aDepth)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_TEXTBOX self, VECTOR2I aPosition, int aAccuracy) -> bool
        HitTest(PCB_TEXTBOX self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TEXTBOX_HitTest(self, *args)
 
    def GetClass(self):
        r"""GetClass(PCB_TEXTBOX self) -> wxString"""
        return _pcbnew.PCB_TEXTBOX_GetClass(self)
 
    def TransformTextToPolySet(self, aBuffer, aClearance, aMaxError, aErrorLoc):
        r"""TransformTextToPolySet(PCB_TEXTBOX self, SHAPE_POLY_SET aBuffer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.PCB_TEXTBOX_TransformTextToPolySet(self, aBuffer, aClearance, aMaxError, aErrorLoc)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aIgnoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_TEXTBOX self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=False)"""
        return _pcbnew.PCB_TEXTBOX_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aIgnoreLineWidth)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_TEXTBOX self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TEXTBOX_GetEffectiveShape(self, *args)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_TEXTBOX self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_TEXTBOX_ViewGetLOD(self, aLayer, aView)
 
    def IsBorderEnabled(self):
        r"""IsBorderEnabled(PCB_TEXTBOX self) -> bool"""
        return _pcbnew.PCB_TEXTBOX_IsBorderEnabled(self)
 
    def SetBorderEnabled(self, enabled):
        r"""SetBorderEnabled(PCB_TEXTBOX self, bool enabled)"""
        return _pcbnew.PCB_TEXTBOX_SetBorderEnabled(self, enabled)
 
    def SetBorderWidth(self, aSize):
        r"""SetBorderWidth(PCB_TEXTBOX self, int const aSize)"""
        return _pcbnew.PCB_TEXTBOX_SetBorderWidth(self, aSize)
 
    def GetBorderWidth(self):
        r"""GetBorderWidth(PCB_TEXTBOX self) -> int"""
        return _pcbnew.PCB_TEXTBOX_GetBorderWidth(self)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_TEXTBOX self, PCB_TEXTBOX aOther) -> bool
        __eq__(PCB_TEXTBOX self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_TEXTBOX___eq__(self, *args)
 
# Register PCB_TEXTBOX in _pcbnew:
_pcbnew.PCB_TEXTBOX_swigregister(PCB_TEXTBOX)
GR_TEXT_H_ALIGN_LEFT = _pcbnew.GR_TEXT_H_ALIGN_LEFT
 
GR_TEXT_H_ALIGN_CENTER = _pcbnew.GR_TEXT_H_ALIGN_CENTER
 
GR_TEXT_H_ALIGN_RIGHT = _pcbnew.GR_TEXT_H_ALIGN_RIGHT
 
GR_TEXT_H_ALIGN_INDETERMINATE = _pcbnew.GR_TEXT_H_ALIGN_INDETERMINATE
 
GR_TEXT_V_ALIGN_TOP = _pcbnew.GR_TEXT_V_ALIGN_TOP
 
GR_TEXT_V_ALIGN_CENTER = _pcbnew.GR_TEXT_V_ALIGN_CENTER
 
GR_TEXT_V_ALIGN_BOTTOM = _pcbnew.GR_TEXT_V_ALIGN_BOTTOM
 
GR_TEXT_V_ALIGN_INDETERMINATE = _pcbnew.GR_TEXT_V_ALIGN_INDETERMINATE
 
 
def GetFlippedAlignment(*args):
    r"""
    GetFlippedAlignment(GR_TEXT_H_ALIGN_T aAlign) -> GR_TEXT_H_ALIGN_T
    GetFlippedAlignment(GR_TEXT_V_ALIGN_T aAlign) -> GR_TEXT_V_ALIGN_T
    """
    return _pcbnew.GetFlippedAlignment(*args)
 
def ToHAlignment(x):
    r"""ToHAlignment(int x) -> GR_TEXT_H_ALIGN_T"""
    return _pcbnew.ToHAlignment(x)
class TEXT_ATTRIBUTES(object):
    r"""Proxy of C++ TEXT_ATTRIBUTES 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, aFont=None):
        r"""__init__(TEXT_ATTRIBUTES self, KIFONT::FONT * aFont=None) -> TEXT_ATTRIBUTES"""
        _pcbnew.TEXT_ATTRIBUTES_swiginit(self, _pcbnew.new_TEXT_ATTRIBUTES(aFont))
 
    def Compare(self, aRhs):
        r"""Compare(TEXT_ATTRIBUTES self, TEXT_ATTRIBUTES aRhs) -> int"""
        return _pcbnew.TEXT_ATTRIBUTES_Compare(self, aRhs)
 
    def __eq__(self, aRhs):
        r"""__eq__(TEXT_ATTRIBUTES self, TEXT_ATTRIBUTES aRhs) -> bool"""
        return _pcbnew.TEXT_ATTRIBUTES___eq__(self, aRhs)
 
    def __gt__(self, aRhs):
        r"""__gt__(TEXT_ATTRIBUTES self, TEXT_ATTRIBUTES aRhs) -> bool"""
        return _pcbnew.TEXT_ATTRIBUTES___gt__(self, aRhs)
 
    def __lt__(self, aRhs):
        r"""__lt__(TEXT_ATTRIBUTES self, TEXT_ATTRIBUTES aRhs) -> bool"""
        return _pcbnew.TEXT_ATTRIBUTES___lt__(self, aRhs)
    m_Font = property(_pcbnew.TEXT_ATTRIBUTES_m_Font_get, _pcbnew.TEXT_ATTRIBUTES_m_Font_set, doc=r"""m_Font : p.KIFONT::FONT""")
    m_Halign = property(_pcbnew.TEXT_ATTRIBUTES_m_Halign_get, _pcbnew.TEXT_ATTRIBUTES_m_Halign_set, doc=r"""m_Halign : GR_TEXT_H_ALIGN_T""")
    m_Valign = property(_pcbnew.TEXT_ATTRIBUTES_m_Valign_get, _pcbnew.TEXT_ATTRIBUTES_m_Valign_set, doc=r"""m_Valign : GR_TEXT_V_ALIGN_T""")
    m_Angle = property(_pcbnew.TEXT_ATTRIBUTES_m_Angle_get, _pcbnew.TEXT_ATTRIBUTES_m_Angle_set, doc=r"""m_Angle : EDA_ANGLE""")
    m_LineSpacing = property(_pcbnew.TEXT_ATTRIBUTES_m_LineSpacing_get, _pcbnew.TEXT_ATTRIBUTES_m_LineSpacing_set, doc=r"""m_LineSpacing : double""")
    m_StrokeWidth = property(_pcbnew.TEXT_ATTRIBUTES_m_StrokeWidth_get, _pcbnew.TEXT_ATTRIBUTES_m_StrokeWidth_set, doc=r"""m_StrokeWidth : int""")
    m_Italic = property(_pcbnew.TEXT_ATTRIBUTES_m_Italic_get, _pcbnew.TEXT_ATTRIBUTES_m_Italic_set, doc=r"""m_Italic : bool""")
    m_Bold = property(_pcbnew.TEXT_ATTRIBUTES_m_Bold_get, _pcbnew.TEXT_ATTRIBUTES_m_Bold_set, doc=r"""m_Bold : bool""")
    m_Underlined = property(_pcbnew.TEXT_ATTRIBUTES_m_Underlined_get, _pcbnew.TEXT_ATTRIBUTES_m_Underlined_set, doc=r"""m_Underlined : bool""")
    m_Color = property(_pcbnew.TEXT_ATTRIBUTES_m_Color_get, _pcbnew.TEXT_ATTRIBUTES_m_Color_set, doc=r"""m_Color : KIGFX::COLOR4D""")
    m_Mirrored = property(_pcbnew.TEXT_ATTRIBUTES_m_Mirrored_get, _pcbnew.TEXT_ATTRIBUTES_m_Mirrored_set, doc=r"""m_Mirrored : bool""")
    m_Multiline = property(_pcbnew.TEXT_ATTRIBUTES_m_Multiline_get, _pcbnew.TEXT_ATTRIBUTES_m_Multiline_set, doc=r"""m_Multiline : bool""")
    m_Size = property(_pcbnew.TEXT_ATTRIBUTES_m_Size_get, _pcbnew.TEXT_ATTRIBUTES_m_Size_set, doc=r"""m_Size : VECTOR2I""")
    m_KeepUpright = property(_pcbnew.TEXT_ATTRIBUTES_m_KeepUpright_get, _pcbnew.TEXT_ATTRIBUTES_m_KeepUpright_set, doc=r"""m_KeepUpright : bool""")
    m_StoredStrokeWidth = property(_pcbnew.TEXT_ATTRIBUTES_m_StoredStrokeWidth_get, _pcbnew.TEXT_ATTRIBUTES_m_StoredStrokeWidth_set, doc=r"""m_StoredStrokeWidth : int""")
    __swig_destroy__ = _pcbnew.delete_TEXT_ATTRIBUTES
 
# Register TEXT_ATTRIBUTES in _pcbnew:
_pcbnew.TEXT_ATTRIBUTES_swigregister(TEXT_ATTRIBUTES)
class PCB_FIELD(PCB_TEXT):
    r"""Proxy of C++ PCB_FIELD 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_FIELD self, FOOTPRINT aParent, int aFieldId, wxString aName=wxEmptyString) -> PCB_FIELD
        __init__(PCB_FIELD self, PCB_TEXT aText, int aFieldId, wxString aName=wxEmptyString) -> PCB_FIELD
        """
        _pcbnew.PCB_FIELD_swiginit(self, _pcbnew.new_PCB_FIELD(*args))
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_FIELD self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_FIELD_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_FIELD self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_FIELD_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_FIELD_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_FIELD self) -> wxString"""
        return _pcbnew.PCB_FIELD_GetClass(self)
 
    def IsReference(self):
        r"""IsReference(PCB_FIELD self) -> bool"""
        return _pcbnew.PCB_FIELD_IsReference(self)
 
    def IsValue(self):
        r"""IsValue(PCB_FIELD self) -> bool"""
        return _pcbnew.PCB_FIELD_IsValue(self)
 
    def IsDatasheet(self):
        r"""IsDatasheet(PCB_FIELD self) -> bool"""
        return _pcbnew.PCB_FIELD_IsDatasheet(self)
 
    def IsComponentClass(self):
        r"""IsComponentClass(PCB_FIELD self) -> bool"""
        return _pcbnew.PCB_FIELD_IsComponentClass(self)
 
    def IsMandatory(self):
        r"""IsMandatory(PCB_FIELD self) -> bool"""
        return _pcbnew.PCB_FIELD_IsMandatory(self)
 
    def IsHypertext(self):
        r"""IsHypertext(PCB_FIELD self) -> bool"""
        return _pcbnew.PCB_FIELD_IsHypertext(self)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_FIELD self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_FIELD_ViewGetLOD(self, aLayer, aView)
 
    def CloneField(self):
        r"""CloneField(PCB_FIELD self) -> PCB_FIELD"""
        return _pcbnew.PCB_FIELD_CloneField(self)
 
    def GetName(self, aUseDefaultName=True):
        r"""GetName(PCB_FIELD self, bool aUseDefaultName=True) -> wxString"""
        return _pcbnew.PCB_FIELD_GetName(self, aUseDefaultName)
 
    def GetCanonicalName(self):
        r"""GetCanonicalName(PCB_FIELD self) -> wxString"""
        return _pcbnew.PCB_FIELD_GetCanonicalName(self)
 
    def SetName(self, aName):
        r"""SetName(PCB_FIELD self, wxString aName)"""
        return _pcbnew.PCB_FIELD_SetName(self, aName)
 
    def GetId(self):
        r"""GetId(PCB_FIELD self) -> int"""
        return _pcbnew.PCB_FIELD_GetId(self)
 
    def SetId(self, aId):
        r"""SetId(PCB_FIELD self, int aId)"""
        return _pcbnew.PCB_FIELD_SetId(self, aId)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_FIELD self, PCB_FIELD aOther) -> bool
        __eq__(PCB_FIELD self, BOARD_ITEM aOther) -> bool
        """
        return _pcbnew.PCB_FIELD___eq__(self, *args)
    __swig_destroy__ = _pcbnew.delete_PCB_FIELD
 
# Register PCB_FIELD in _pcbnew:
_pcbnew.PCB_FIELD_swigregister(PCB_FIELD)
DIM_UNITS_FORMAT_NO_SUFFIX = _pcbnew.DIM_UNITS_FORMAT_NO_SUFFIX
 
DIM_UNITS_FORMAT_BARE_SUFFIX = _pcbnew.DIM_UNITS_FORMAT_BARE_SUFFIX
 
DIM_UNITS_FORMAT_PAREN_SUFFIX = _pcbnew.DIM_UNITS_FORMAT_PAREN_SUFFIX
 
DIM_PRECISION_X = _pcbnew.DIM_PRECISION_X
 
DIM_PRECISION_X_X = _pcbnew.DIM_PRECISION_X_X
 
DIM_PRECISION_X_XX = _pcbnew.DIM_PRECISION_X_XX
 
DIM_PRECISION_X_XXX = _pcbnew.DIM_PRECISION_X_XXX
 
DIM_PRECISION_X_XXXX = _pcbnew.DIM_PRECISION_X_XXXX
 
DIM_PRECISION_X_XXXXX = _pcbnew.DIM_PRECISION_X_XXXXX
 
DIM_PRECISION_V_VV = _pcbnew.DIM_PRECISION_V_VV
 
DIM_PRECISION_V_VVV = _pcbnew.DIM_PRECISION_V_VVV
 
DIM_PRECISION_V_VVVV = _pcbnew.DIM_PRECISION_V_VVVV
 
DIM_PRECISION_V_VVVVV = _pcbnew.DIM_PRECISION_V_VVVVV
 
DIM_TEXT_POSITION_OUTSIDE = _pcbnew.DIM_TEXT_POSITION_OUTSIDE
 
DIM_TEXT_POSITION_INLINE = _pcbnew.DIM_TEXT_POSITION_INLINE
 
DIM_TEXT_POSITION_MANUAL = _pcbnew.DIM_TEXT_POSITION_MANUAL
 
DIM_UNITS_MODE_INCH = _pcbnew.DIM_UNITS_MODE_INCH
 
DIM_UNITS_MODE_MILS = _pcbnew.DIM_UNITS_MODE_MILS
 
DIM_UNITS_MODE_MM = _pcbnew.DIM_UNITS_MODE_MM
 
DIM_UNITS_MODE_AUTOMATIC = _pcbnew.DIM_UNITS_MODE_AUTOMATIC
 
DIM_ARROW_DIRECTION_INWARD = _pcbnew.DIM_ARROW_DIRECTION_INWARD
 
DIM_ARROW_DIRECTION_OUTWARD = _pcbnew.DIM_ARROW_DIRECTION_OUTWARD
 
DIM_TEXT_BORDER_NONE = _pcbnew.DIM_TEXT_BORDER_NONE
 
DIM_TEXT_BORDER_RECTANGLE = _pcbnew.DIM_TEXT_BORDER_RECTANGLE
 
DIM_TEXT_BORDER_CIRCLE = _pcbnew.DIM_TEXT_BORDER_CIRCLE
 
DIM_TEXT_BORDER_ROUNDRECT = _pcbnew.DIM_TEXT_BORDER_ROUNDRECT
 
class PCB_DIMENSION_BASE(PCB_TEXT):
    r"""Proxy of C++ PCB_DIMENSION_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 - class is abstract")
    __repr__ = _swig_repr
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_DIMENSION_BASE self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_DIMENSION_BASE_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_DIMENSION_BASE self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_Deserialize(self, aContainer)
 
    def GetStart(self):
        r"""GetStart(PCB_DIMENSION_BASE self) -> VECTOR2I"""
        return _pcbnew.PCB_DIMENSION_BASE_GetStart(self)
 
    def SetStart(self, aPoint):
        r"""SetStart(PCB_DIMENSION_BASE self, VECTOR2I aPoint)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetStart(self, aPoint)
 
    def GetEnd(self):
        r"""GetEnd(PCB_DIMENSION_BASE self) -> VECTOR2I"""
        return _pcbnew.PCB_DIMENSION_BASE_GetEnd(self)
 
    def SetEnd(self, aPoint):
        r"""SetEnd(PCB_DIMENSION_BASE self, VECTOR2I aPoint)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetEnd(self, aPoint)
 
    def GetOverrideTextEnabled(self):
        r"""GetOverrideTextEnabled(PCB_DIMENSION_BASE self) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_GetOverrideTextEnabled(self)
 
    def SetOverrideTextEnabled(self, aOverride):
        r"""SetOverrideTextEnabled(PCB_DIMENSION_BASE self, bool aOverride)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetOverrideTextEnabled(self, aOverride)
 
    def GetOverrideText(self):
        r"""GetOverrideText(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetOverrideText(self)
 
    def SetOverrideText(self, aValue):
        r"""SetOverrideText(PCB_DIMENSION_BASE self, wxString aValue)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetOverrideText(self, aValue)
 
    def ChangeOverrideText(self, aValue):
        r"""ChangeOverrideText(PCB_DIMENSION_BASE self, wxString aValue)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeOverrideText(self, aValue)
 
    def GetMeasuredValue(self):
        r"""GetMeasuredValue(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetMeasuredValue(self)
 
    def SetMeasuredValue(self, aValue):
        r"""SetMeasuredValue(PCB_DIMENSION_BASE self, int aValue)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetMeasuredValue(self, aValue)
 
    def GetValueText(self):
        r"""GetValueText(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetValueText(self)
 
    def Update(self):
        r"""Update(PCB_DIMENSION_BASE self)"""
        return _pcbnew.PCB_DIMENSION_BASE_Update(self)
 
    def UpdateUnits(self):
        r"""UpdateUnits(PCB_DIMENSION_BASE self)"""
        return _pcbnew.PCB_DIMENSION_BASE_UpdateUnits(self)
 
    def GetPrefix(self):
        r"""GetPrefix(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetPrefix(self)
 
    def SetPrefix(self, aPrefix):
        r"""SetPrefix(PCB_DIMENSION_BASE self, wxString aPrefix)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetPrefix(self, aPrefix)
 
    def ChangePrefix(self, aPrefix):
        r"""ChangePrefix(PCB_DIMENSION_BASE self, wxString aPrefix)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangePrefix(self, aPrefix)
 
    def GetSuffix(self):
        r"""GetSuffix(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetSuffix(self)
 
    def SetSuffix(self, aSuffix):
        r"""SetSuffix(PCB_DIMENSION_BASE self, wxString aSuffix)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetSuffix(self, aSuffix)
 
    def ChangeSuffix(self, aSuffix):
        r"""ChangeSuffix(PCB_DIMENSION_BASE self, wxString aSuffix)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeSuffix(self, aSuffix)
 
    def GetArrowDirection(self):
        r"""GetArrowDirection(PCB_DIMENSION_BASE self) -> DIM_ARROW_DIRECTION"""
        return _pcbnew.PCB_DIMENSION_BASE_GetArrowDirection(self)
 
    def SetArrowDirection(self, aDirection):
        r"""SetArrowDirection(PCB_DIMENSION_BASE self, DIM_ARROW_DIRECTION const & aDirection)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetArrowDirection(self, aDirection)
 
    def ChangeArrowDirection(self, aDirection):
        r"""ChangeArrowDirection(PCB_DIMENSION_BASE self, DIM_ARROW_DIRECTION const & aDirection)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeArrowDirection(self, aDirection)
 
    def GetUnits(self):
        r"""GetUnits(PCB_DIMENSION_BASE self) -> EDA_UNITS"""
        return _pcbnew.PCB_DIMENSION_BASE_GetUnits(self)
 
    def SetUnits(self, aUnits):
        r"""SetUnits(PCB_DIMENSION_BASE self, EDA_UNITS aUnits)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetUnits(self, aUnits)
 
    def GetUnitsMode(self):
        r"""GetUnitsMode(PCB_DIMENSION_BASE self) -> DIM_UNITS_MODE"""
        return _pcbnew.PCB_DIMENSION_BASE_GetUnitsMode(self)
 
    def SetUnitsMode(self, aMode):
        r"""SetUnitsMode(PCB_DIMENSION_BASE self, DIM_UNITS_MODE aMode)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetUnitsMode(self, aMode)
 
    def ChangeUnitsMode(self, aMode):
        r"""ChangeUnitsMode(PCB_DIMENSION_BASE self, DIM_UNITS_MODE aMode)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeUnitsMode(self, aMode)
 
    def SetAutoUnits(self, aAuto=True):
        r"""SetAutoUnits(PCB_DIMENSION_BASE self, bool aAuto=True)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetAutoUnits(self, aAuto)
 
    def GetUnitsFormat(self):
        r"""GetUnitsFormat(PCB_DIMENSION_BASE self) -> DIM_UNITS_FORMAT"""
        return _pcbnew.PCB_DIMENSION_BASE_GetUnitsFormat(self)
 
    def SetUnitsFormat(self, aFormat):
        r"""SetUnitsFormat(PCB_DIMENSION_BASE self, DIM_UNITS_FORMAT const aFormat)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetUnitsFormat(self, aFormat)
 
    def ChangeUnitsFormat(self, aFormat):
        r"""ChangeUnitsFormat(PCB_DIMENSION_BASE self, DIM_UNITS_FORMAT const aFormat)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeUnitsFormat(self, aFormat)
 
    def GetPrecision(self):
        r"""GetPrecision(PCB_DIMENSION_BASE self) -> DIM_PRECISION"""
        return _pcbnew.PCB_DIMENSION_BASE_GetPrecision(self)
 
    def SetPrecision(self, aPrecision):
        r"""SetPrecision(PCB_DIMENSION_BASE self, DIM_PRECISION aPrecision)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetPrecision(self, aPrecision)
 
    def ChangePrecision(self, aPrecision):
        r"""ChangePrecision(PCB_DIMENSION_BASE self, DIM_PRECISION aPrecision)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangePrecision(self, aPrecision)
 
    def GetSuppressZeroes(self):
        r"""GetSuppressZeroes(PCB_DIMENSION_BASE self) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_GetSuppressZeroes(self)
 
    def SetSuppressZeroes(self, aSuppress):
        r"""SetSuppressZeroes(PCB_DIMENSION_BASE self, bool aSuppress)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetSuppressZeroes(self, aSuppress)
 
    def ChangeSuppressZeroes(self, aSuppress):
        r"""ChangeSuppressZeroes(PCB_DIMENSION_BASE self, bool aSuppress)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeSuppressZeroes(self, aSuppress)
 
    def GetKeepTextAligned(self):
        r"""GetKeepTextAligned(PCB_DIMENSION_BASE self) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_GetKeepTextAligned(self)
 
    def SetKeepTextAligned(self, aKeepAligned):
        r"""SetKeepTextAligned(PCB_DIMENSION_BASE self, bool aKeepAligned)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetKeepTextAligned(self, aKeepAligned)
 
    def GetTextAngleDegreesProp(self):
        r"""GetTextAngleDegreesProp(PCB_DIMENSION_BASE self) -> double"""
        return _pcbnew.PCB_DIMENSION_BASE_GetTextAngleDegreesProp(self)
 
    def ChangeTextAngleDegrees(self, aDegrees):
        r"""ChangeTextAngleDegrees(PCB_DIMENSION_BASE self, double aDegrees)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeTextAngleDegrees(self, aDegrees)
 
    def ChangeKeepTextAligned(self, aKeepAligned):
        r"""ChangeKeepTextAligned(PCB_DIMENSION_BASE self, bool aKeepAligned)"""
        return _pcbnew.PCB_DIMENSION_BASE_ChangeKeepTextAligned(self, aKeepAligned)
 
    def SetTextPositionMode(self, aMode):
        r"""SetTextPositionMode(PCB_DIMENSION_BASE self, DIM_TEXT_POSITION aMode)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetTextPositionMode(self, aMode)
 
    def GetTextPositionMode(self):
        r"""GetTextPositionMode(PCB_DIMENSION_BASE self) -> DIM_TEXT_POSITION"""
        return _pcbnew.PCB_DIMENSION_BASE_GetTextPositionMode(self)
 
    def GetArrowLength(self):
        r"""GetArrowLength(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetArrowLength(self)
 
    def SetArrowLength(self, aLength):
        r"""SetArrowLength(PCB_DIMENSION_BASE self, int aLength)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetArrowLength(self, aLength)
 
    def SetExtensionOffset(self, aOffset):
        r"""SetExtensionOffset(PCB_DIMENSION_BASE self, int aOffset)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetExtensionOffset(self, aOffset)
 
    def GetExtensionOffset(self):
        r"""GetExtensionOffset(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetExtensionOffset(self)
 
    def GetLineThickness(self):
        r"""GetLineThickness(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetLineThickness(self)
 
    def SetLineThickness(self, aWidth):
        r"""SetLineThickness(PCB_DIMENSION_BASE self, int aWidth)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetLineThickness(self, aWidth)
 
    def GetShapes(self):
        r"""GetShapes(PCB_DIMENSION_BASE self) -> VECTOR_SHAPEPTR"""
        return _pcbnew.PCB_DIMENSION_BASE_GetShapes(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_DIMENSION_BASE self, VECTOR2I aPosition, int aAccuracy) -> bool
        HitTest(PCB_DIMENSION_BASE self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_DIMENSION_BASE_HitTest(self, *args)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_DIMENSION_BASE self, PCB_LAYER_ID aLayer, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_DIMENSION_BASE_GetEffectiveShape(self, *args)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, aIgnoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_DIMENSION_BASE self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=False)"""
        return _pcbnew.PCB_DIMENSION_BASE_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, aIgnoreLineWidth)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_DIMENSION_BASE self, PCB_DIMENSION_BASE aOther) -> bool
        __eq__(PCB_DIMENSION_BASE self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_DIMENSION_BASE___eq__(self, *args)
    __swig_destroy__ = _pcbnew.delete_PCB_DIMENSION_BASE
 
# Register PCB_DIMENSION_BASE in _pcbnew:
_pcbnew.PCB_DIMENSION_BASE_swigregister(PCB_DIMENSION_BASE)
class PCB_DIM_ALIGNED(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_ALIGNED 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, aType=PCB_DIM_ALIGNED_T):
        r"""__init__(PCB_DIM_ALIGNED self, BOARD_ITEM aParent, KICAD_T aType=PCB_DIM_ALIGNED_T) -> PCB_DIM_ALIGNED"""
        _pcbnew.PCB_DIM_ALIGNED_swiginit(self, _pcbnew.new_PCB_DIM_ALIGNED(aParent, aType))
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_ALIGNED
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_DIM_ALIGNED self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_DIM_ALIGNED_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_DIM_ALIGNED self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_DIM_ALIGNED_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_ALIGNED_ClassOf(aItem)
 
    def GetCrossbarStart(self):
        r"""GetCrossbarStart(PCB_DIM_ALIGNED self) -> VECTOR2I"""
        return _pcbnew.PCB_DIM_ALIGNED_GetCrossbarStart(self)
 
    def GetCrossbarEnd(self):
        r"""GetCrossbarEnd(PCB_DIM_ALIGNED self) -> VECTOR2I"""
        return _pcbnew.PCB_DIM_ALIGNED_GetCrossbarEnd(self)
 
    def SetHeight(self, aHeight):
        r"""SetHeight(PCB_DIM_ALIGNED self, int aHeight)"""
        return _pcbnew.PCB_DIM_ALIGNED_SetHeight(self, aHeight)
 
    def GetHeight(self):
        r"""GetHeight(PCB_DIM_ALIGNED self) -> int"""
        return _pcbnew.PCB_DIM_ALIGNED_GetHeight(self)
 
    def ChangeHeight(self, aHeight):
        r"""ChangeHeight(PCB_DIM_ALIGNED self, int aHeight)"""
        return _pcbnew.PCB_DIM_ALIGNED_ChangeHeight(self, aHeight)
 
    def UpdateHeight(self, aCrossbarStart, aCrossbarEnd):
        r"""UpdateHeight(PCB_DIM_ALIGNED self, VECTOR2I aCrossbarStart, VECTOR2I aCrossbarEnd)"""
        return _pcbnew.PCB_DIM_ALIGNED_UpdateHeight(self, aCrossbarStart, aCrossbarEnd)
 
    def SetExtensionHeight(self, aHeight):
        r"""SetExtensionHeight(PCB_DIM_ALIGNED self, int aHeight)"""
        return _pcbnew.PCB_DIM_ALIGNED_SetExtensionHeight(self, aHeight)
 
    def GetExtensionHeight(self):
        r"""GetExtensionHeight(PCB_DIM_ALIGNED self) -> int"""
        return _pcbnew.PCB_DIM_ALIGNED_GetExtensionHeight(self)
 
    def ChangeExtensionHeight(self, aHeight):
        r"""ChangeExtensionHeight(PCB_DIM_ALIGNED self, int aHeight)"""
        return _pcbnew.PCB_DIM_ALIGNED_ChangeExtensionHeight(self, aHeight)
 
    def GetAngle(self):
        r"""GetAngle(PCB_DIM_ALIGNED self) -> double"""
        return _pcbnew.PCB_DIM_ALIGNED_GetAngle(self)
 
    def GetClass(self):
        r"""GetClass(PCB_DIM_ALIGNED self) -> wxString"""
        return _pcbnew.PCB_DIM_ALIGNED_GetClass(self)
 
# Register PCB_DIM_ALIGNED in _pcbnew:
_pcbnew.PCB_DIM_ALIGNED_swigregister(PCB_DIM_ALIGNED)
class PCB_DIM_ORTHOGONAL(PCB_DIM_ALIGNED):
    r"""Proxy of C++ PCB_DIM_ORTHOGONAL class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    DIR_HORIZONTAL = _pcbnew.PCB_DIM_ORTHOGONAL_DIR_HORIZONTAL
    
    DIR_VERTICAL = _pcbnew.PCB_DIM_ORTHOGONAL_DIR_VERTICAL
    
 
    def __init__(self, aParent):
        r"""__init__(PCB_DIM_ORTHOGONAL self, BOARD_ITEM aParent) -> PCB_DIM_ORTHOGONAL"""
        _pcbnew.PCB_DIM_ORTHOGONAL_swiginit(self, _pcbnew.new_PCB_DIM_ORTHOGONAL(aParent))
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_ORTHOGONAL
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_DIM_ORTHOGONAL self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_DIM_ORTHOGONAL self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_ClassOf(aItem)
 
    def SetOrientation(self, aOrientation):
        r"""SetOrientation(PCB_DIM_ORTHOGONAL self, PCB_DIM_ORTHOGONAL::DIR aOrientation)"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_SetOrientation(self, aOrientation)
 
    def GetOrientation(self):
        r"""GetOrientation(PCB_DIM_ORTHOGONAL self) -> PCB_DIM_ORTHOGONAL::DIR"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_GetOrientation(self)
 
    def GetClass(self):
        r"""GetClass(PCB_DIM_ORTHOGONAL self) -> wxString"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_GetClass(self)
 
# Register PCB_DIM_ORTHOGONAL in _pcbnew:
_pcbnew.PCB_DIM_ORTHOGONAL_swigregister(PCB_DIM_ORTHOGONAL)
class PCB_DIM_RADIAL(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_RADIAL 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__(PCB_DIM_RADIAL self, BOARD_ITEM aParent) -> PCB_DIM_RADIAL"""
        _pcbnew.PCB_DIM_RADIAL_swiginit(self, _pcbnew.new_PCB_DIM_RADIAL(aParent))
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_DIM_RADIAL self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_DIM_RADIAL_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_DIM_RADIAL self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_DIM_RADIAL_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_RADIAL_ClassOf(aItem)
 
    def SetLeaderLength(self, aLength):
        r"""SetLeaderLength(PCB_DIM_RADIAL self, int aLength)"""
        return _pcbnew.PCB_DIM_RADIAL_SetLeaderLength(self, aLength)
 
    def GetLeaderLength(self):
        r"""GetLeaderLength(PCB_DIM_RADIAL self) -> int"""
        return _pcbnew.PCB_DIM_RADIAL_GetLeaderLength(self)
 
    def ChangeLeaderLength(self, aLength):
        r"""ChangeLeaderLength(PCB_DIM_RADIAL self, int aLength)"""
        return _pcbnew.PCB_DIM_RADIAL_ChangeLeaderLength(self, aLength)
 
    def GetKnee(self):
        r"""GetKnee(PCB_DIM_RADIAL self) -> VECTOR2I"""
        return _pcbnew.PCB_DIM_RADIAL_GetKnee(self)
 
    def GetClass(self):
        r"""GetClass(PCB_DIM_RADIAL self) -> wxString"""
        return _pcbnew.PCB_DIM_RADIAL_GetClass(self)
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_RADIAL
 
# Register PCB_DIM_RADIAL in _pcbnew:
_pcbnew.PCB_DIM_RADIAL_swigregister(PCB_DIM_RADIAL)
class PCB_DIM_LEADER(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_LEADER 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__(PCB_DIM_LEADER self, BOARD_ITEM aParent) -> PCB_DIM_LEADER"""
        _pcbnew.PCB_DIM_LEADER_swiginit(self, _pcbnew.new_PCB_DIM_LEADER(aParent))
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_DIM_LEADER self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_DIM_LEADER_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_DIM_LEADER self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_DIM_LEADER_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_LEADER_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_DIM_LEADER self) -> wxString"""
        return _pcbnew.PCB_DIM_LEADER_GetClass(self)
 
    def SetTextBorder(self, aBorder):
        r"""SetTextBorder(PCB_DIM_LEADER self, DIM_TEXT_BORDER aBorder)"""
        return _pcbnew.PCB_DIM_LEADER_SetTextBorder(self, aBorder)
 
    def GetTextBorder(self):
        r"""GetTextBorder(PCB_DIM_LEADER self) -> DIM_TEXT_BORDER"""
        return _pcbnew.PCB_DIM_LEADER_GetTextBorder(self)
 
    def ChangeTextBorder(self, aBorder):
        r"""ChangeTextBorder(PCB_DIM_LEADER self, DIM_TEXT_BORDER aBorder)"""
        return _pcbnew.PCB_DIM_LEADER_ChangeTextBorder(self, aBorder)
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_LEADER
 
# Register PCB_DIM_LEADER in _pcbnew:
_pcbnew.PCB_DIM_LEADER_swigregister(PCB_DIM_LEADER)
class PCB_DIM_CENTER(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_CENTER 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__(PCB_DIM_CENTER self, BOARD_ITEM aParent) -> PCB_DIM_CENTER"""
        _pcbnew.PCB_DIM_CENTER_swiginit(self, _pcbnew.new_PCB_DIM_CENTER(aParent))
 
    def Serialize(self, aContainer):
        r"""Serialize(PCB_DIM_CENTER self, google::protobuf::Any & aContainer)"""
        return _pcbnew.PCB_DIM_CENTER_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(PCB_DIM_CENTER self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.PCB_DIM_CENTER_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_CENTER_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_DIM_CENTER self) -> wxString"""
        return _pcbnew.PCB_DIM_CENTER_GetClass(self)
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_CENTER
 
# Register PCB_DIM_CENTER in _pcbnew:
_pcbnew.PCB_DIM_CENTER_swigregister(PCB_DIM_CENTER)
MARKER_SHAPE_POINT_COUNT = _pcbnew.MARKER_SHAPE_POINT_COUNT
 
class PCB_MARKER(BOARD_ITEM, MARKER_BASE):
    r"""Proxy of C++ PCB_MARKER 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, aItem, aPos, aLayer=F_Cu):
        r"""__init__(PCB_MARKER self, std::shared_ptr< RC_ITEM > aItem, VECTOR2I aPos, int aLayer=F_Cu) -> PCB_MARKER"""
        _pcbnew.PCB_MARKER_swiginit(self, _pcbnew.new_PCB_MARKER(aItem, aPos, aLayer))
    __swig_destroy__ = _pcbnew.delete_PCB_MARKER
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_MARKER_ClassOf(aItem)
 
    def SerializeToString(self):
        r"""SerializeToString(PCB_MARKER self) -> wxString"""
        return _pcbnew.PCB_MARKER_SerializeToString(self)
 
    @staticmethod
    def DeserializeFromString(data):
        r"""DeserializeFromString(wxString data) -> PCB_MARKER"""
        return _pcbnew.PCB_MARKER_DeserializeFromString(data)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_MARKER self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_MARKER self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_MARKER_HitTest(self, *args)
 
    def GetColorLayer(self):
        r"""GetColorLayer(PCB_MARKER self) -> GAL_LAYER_ID"""
        return _pcbnew.PCB_MARKER_GetColorLayer(self)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_MARKER self, PCB_LAYER_ID aLayer, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_MARKER_GetEffectiveShape(self, *args)
 
    def SetZoom(self, aZoomFactor):
        r"""SetZoom(PCB_MARKER self, double aZoomFactor)"""
        return _pcbnew.PCB_MARKER_SetZoom(self, aZoomFactor)
 
    def GetClass(self):
        r"""GetClass(PCB_MARKER self) -> wxString"""
        return _pcbnew.PCB_MARKER_GetClass(self)
 
    def GetShapes1(self):
        r"""GetShapes1(PCB_MARKER self) -> std::vector< PCB_SHAPE,std::allocator< PCB_SHAPE > >"""
        return _pcbnew.PCB_MARKER_GetShapes1(self)
 
    def GetShapes2(self):
        r"""GetShapes2(PCB_MARKER self) -> std::vector< PCB_SHAPE,std::allocator< PCB_SHAPE > >"""
        return _pcbnew.PCB_MARKER_GetShapes2(self)
 
    def SetShapes1(self, aShapes):
        r"""SetShapes1(PCB_MARKER self, std::vector< PCB_SHAPE,std::allocator< PCB_SHAPE > > const & aShapes)"""
        return _pcbnew.PCB_MARKER_SetShapes1(self, aShapes)
 
    def SetShapes2(self, aShapes):
        r"""SetShapes2(PCB_MARKER self, std::vector< PCB_SHAPE,std::allocator< PCB_SHAPE > > const & aShapes)"""
        return _pcbnew.PCB_MARKER_SetShapes2(self, aShapes)
 
# Register PCB_MARKER in _pcbnew:
_pcbnew.PCB_MARKER_swigregister(PCB_MARKER)
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, VECTOR2I 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 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 GetClass(self):
        r"""GetClass(PCB_TARGET self) -> wxString"""
        return _pcbnew.PCB_TARGET_GetClass(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_TARGET self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_TARGET self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TARGET_HitTest(self, *args)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_TARGET self, PCB_LAYER_ID aLayer, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TARGET_GetEffectiveShape(self, *args)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_TARGET self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PCB_TARGET_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, ignoreLineWidth)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_TARGET self, PCB_TARGET aOther) -> bool
        __eq__(PCB_TARGET self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_TARGET___eq__(self, *args)
 
# Register PCB_TARGET in _pcbnew:
_pcbnew.PCB_TARGET_swigregister(PCB_TARGET)
class PCB_TABLE(BOARD_ITEM_CONTAINER):
    r"""Proxy of C++ PCB_TABLE 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_TABLE self, BOARD_ITEM aParent, int aLineWidth) -> PCB_TABLE
        __init__(PCB_TABLE self, PCB_TABLE aTable) -> PCB_TABLE
        """
        _pcbnew.PCB_TABLE_swiginit(self, _pcbnew.new_PCB_TABLE(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_TABLE
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TABLE_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_TABLE self) -> wxString"""
        return _pcbnew.PCB_TABLE_GetClass(self)
 
    def SetStrokeExternal(self, aDoStroke):
        r"""SetStrokeExternal(PCB_TABLE self, bool aDoStroke)"""
        return _pcbnew.PCB_TABLE_SetStrokeExternal(self, aDoStroke)
 
    def StrokeExternal(self):
        r"""StrokeExternal(PCB_TABLE self) -> bool"""
        return _pcbnew.PCB_TABLE_StrokeExternal(self)
 
    def SetStrokeHeaderSeparator(self, aDoStroke):
        r"""SetStrokeHeaderSeparator(PCB_TABLE self, bool aDoStroke)"""
        return _pcbnew.PCB_TABLE_SetStrokeHeaderSeparator(self, aDoStroke)
 
    def StrokeHeaderSeparator(self):
        r"""StrokeHeaderSeparator(PCB_TABLE self) -> bool"""
        return _pcbnew.PCB_TABLE_StrokeHeaderSeparator(self)
 
    def SetBorderStroke(self, aParams):
        r"""SetBorderStroke(PCB_TABLE self, STROKE_PARAMS const & aParams)"""
        return _pcbnew.PCB_TABLE_SetBorderStroke(self, aParams)
 
    def GetBorderStroke(self):
        r"""GetBorderStroke(PCB_TABLE self) -> STROKE_PARAMS const &"""
        return _pcbnew.PCB_TABLE_GetBorderStroke(self)
 
    def SetBorderWidth(self, aWidth):
        r"""SetBorderWidth(PCB_TABLE self, int aWidth)"""
        return _pcbnew.PCB_TABLE_SetBorderWidth(self, aWidth)
 
    def GetBorderWidth(self):
        r"""GetBorderWidth(PCB_TABLE self) -> int"""
        return _pcbnew.PCB_TABLE_GetBorderWidth(self)
 
    def SetBorderStyle(self, aStyle):
        r"""SetBorderStyle(PCB_TABLE self, LINE_STYLE const aStyle)"""
        return _pcbnew.PCB_TABLE_SetBorderStyle(self, aStyle)
 
    def GetBorderStyle(self):
        r"""GetBorderStyle(PCB_TABLE self) -> LINE_STYLE"""
        return _pcbnew.PCB_TABLE_GetBorderStyle(self)
 
    def SetBorderColor(self, aColor):
        r"""SetBorderColor(PCB_TABLE self, COLOR4D aColor)"""
        return _pcbnew.PCB_TABLE_SetBorderColor(self, aColor)
 
    def GetBorderColor(self):
        r"""GetBorderColor(PCB_TABLE self) -> COLOR4D"""
        return _pcbnew.PCB_TABLE_GetBorderColor(self)
 
    def SetSeparatorsStroke(self, aParams):
        r"""SetSeparatorsStroke(PCB_TABLE self, STROKE_PARAMS const & aParams)"""
        return _pcbnew.PCB_TABLE_SetSeparatorsStroke(self, aParams)
 
    def GetSeparatorsStroke(self):
        r"""GetSeparatorsStroke(PCB_TABLE self) -> STROKE_PARAMS const &"""
        return _pcbnew.PCB_TABLE_GetSeparatorsStroke(self)
 
    def SetSeparatorsWidth(self, aWidth):
        r"""SetSeparatorsWidth(PCB_TABLE self, int aWidth)"""
        return _pcbnew.PCB_TABLE_SetSeparatorsWidth(self, aWidth)
 
    def GetSeparatorsWidth(self):
        r"""GetSeparatorsWidth(PCB_TABLE self) -> int"""
        return _pcbnew.PCB_TABLE_GetSeparatorsWidth(self)
 
    def SetSeparatorsStyle(self, aStyle):
        r"""SetSeparatorsStyle(PCB_TABLE self, LINE_STYLE const aStyle)"""
        return _pcbnew.PCB_TABLE_SetSeparatorsStyle(self, aStyle)
 
    def GetSeparatorsStyle(self):
        r"""GetSeparatorsStyle(PCB_TABLE self) -> LINE_STYLE"""
        return _pcbnew.PCB_TABLE_GetSeparatorsStyle(self)
 
    def SetSeparatorsColor(self, aColor):
        r"""SetSeparatorsColor(PCB_TABLE self, COLOR4D aColor)"""
        return _pcbnew.PCB_TABLE_SetSeparatorsColor(self, aColor)
 
    def GetSeparatorsColor(self):
        r"""GetSeparatorsColor(PCB_TABLE self) -> COLOR4D"""
        return _pcbnew.PCB_TABLE_GetSeparatorsColor(self)
 
    def SetStrokeColumns(self, aDoStroke):
        r"""SetStrokeColumns(PCB_TABLE self, bool aDoStroke)"""
        return _pcbnew.PCB_TABLE_SetStrokeColumns(self, aDoStroke)
 
    def StrokeColumns(self):
        r"""StrokeColumns(PCB_TABLE self) -> bool"""
        return _pcbnew.PCB_TABLE_StrokeColumns(self)
 
    def SetStrokeRows(self, aDoStroke):
        r"""SetStrokeRows(PCB_TABLE self, bool aDoStroke)"""
        return _pcbnew.PCB_TABLE_SetStrokeRows(self, aDoStroke)
 
    def StrokeRows(self):
        r"""StrokeRows(PCB_TABLE self) -> bool"""
        return _pcbnew.PCB_TABLE_StrokeRows(self)
 
    def RunOnDescendants(self, aFunction, aDepth=0):
        r"""RunOnDescendants(PCB_TABLE self, std::function< void (BOARD_ITEM *) > const & aFunction, int aDepth=0)"""
        return _pcbnew.PCB_TABLE_RunOnDescendants(self, aFunction, aDepth)
 
    def GetEnd(self):
        r"""GetEnd(PCB_TABLE self) -> VECTOR2I"""
        return _pcbnew.PCB_TABLE_GetEnd(self)
 
    def SetPositionX(self, x):
        r"""SetPositionX(PCB_TABLE self, int x)"""
        return _pcbnew.PCB_TABLE_SetPositionX(self, x)
 
    def SetPositionY(self, y):
        r"""SetPositionY(PCB_TABLE self, int y)"""
        return _pcbnew.PCB_TABLE_SetPositionY(self, y)
 
    def GetPositionX(self):
        r"""GetPositionX(PCB_TABLE self) -> int"""
        return _pcbnew.PCB_TABLE_GetPositionX(self)
 
    def GetPositionY(self):
        r"""GetPositionY(PCB_TABLE self) -> int"""
        return _pcbnew.PCB_TABLE_GetPositionY(self)
 
    def SetColCount(self, aCount):
        r"""SetColCount(PCB_TABLE self, int aCount)"""
        return _pcbnew.PCB_TABLE_SetColCount(self, aCount)
 
    def GetColCount(self):
        r"""GetColCount(PCB_TABLE self) -> int"""
        return _pcbnew.PCB_TABLE_GetColCount(self)
 
    def GetRowCount(self):
        r"""GetRowCount(PCB_TABLE self) -> int"""
        return _pcbnew.PCB_TABLE_GetRowCount(self)
 
    def SetColWidth(self, aCol, aWidth):
        r"""SetColWidth(PCB_TABLE self, int aCol, int aWidth)"""
        return _pcbnew.PCB_TABLE_SetColWidth(self, aCol, aWidth)
 
    def GetColWidth(self, aCol):
        r"""GetColWidth(PCB_TABLE self, int aCol) -> int"""
        return _pcbnew.PCB_TABLE_GetColWidth(self, aCol)
 
    def SetRowHeight(self, aRow, aHeight):
        r"""SetRowHeight(PCB_TABLE self, int aRow, int aHeight)"""
        return _pcbnew.PCB_TABLE_SetRowHeight(self, aRow, aHeight)
 
    def GetRowHeight(self, aRow):
        r"""GetRowHeight(PCB_TABLE self, int aRow) -> int"""
        return _pcbnew.PCB_TABLE_GetRowHeight(self, aRow)
 
    def GetCell(self, aRow, aCol):
        r"""GetCell(PCB_TABLE self, int aRow, int aCol) -> PCB_TABLECELL *"""
        return _pcbnew.PCB_TABLE_GetCell(self, aRow, aCol)
 
    def GetCells(self):
        r"""GetCells(PCB_TABLE self) -> std::vector< PCB_TABLECELL *,std::allocator< PCB_TABLECELL * > >"""
        return _pcbnew.PCB_TABLE_GetCells(self)
 
    def AddCell(self, aCell):
        r"""AddCell(PCB_TABLE self, PCB_TABLECELL * aCell)"""
        return _pcbnew.PCB_TABLE_AddCell(self, aCell)
 
    def InsertCell(self, aIdx, aCell):
        r"""InsertCell(PCB_TABLE self, int aIdx, PCB_TABLECELL * aCell)"""
        return _pcbnew.PCB_TABLE_InsertCell(self, aIdx, aCell)
 
    def ClearCells(self):
        r"""ClearCells(PCB_TABLE self)"""
        return _pcbnew.PCB_TABLE_ClearCells(self)
 
    def DeleteMarkedCells(self):
        r"""DeleteMarkedCells(PCB_TABLE self)"""
        return _pcbnew.PCB_TABLE_DeleteMarkedCells(self)
 
    def AddNative(self, *args):
        r"""AddNative(PCB_TABLE self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT, bool aSkipConnectivity=False)"""
        return _pcbnew.PCB_TABLE_AddNative(self, *args)
 
    def RemoveNative(self, *args):
        r"""RemoveNative(PCB_TABLE self, BOARD_ITEM aItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.PCB_TABLE_RemoveNative(self, *args)
 
    def DrawBorders(self, aCallback):
        r"""DrawBorders(PCB_TABLE self, std::function< void (VECTOR2I const &,VECTOR2I const &,STROKE_PARAMS const &) > const & aCallback)"""
        return _pcbnew.PCB_TABLE_DrawBorders(self, aCallback)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_TABLE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TABLE_GetEffectiveShape(self, *args)
 
    def TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aIgnoreLineWidth=False):
        r"""TransformShapeToPolygon(PCB_TABLE self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=False)"""
        return _pcbnew.PCB_TABLE_TransformShapeToPolygon(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aIgnoreLineWidth)
 
    def TransformGraphicItemsToPolySet(self, aBuffer, aMaxError, aErrorLoc, aRenderSettings):
        r"""TransformGraphicItemsToPolySet(PCB_TABLE self, SHAPE_POLY_SET aBuffer, int aMaxError, ERROR_LOC aErrorLoc, KIGFX::RENDER_SETTINGS * aRenderSettings)"""
        return _pcbnew.PCB_TABLE_TransformGraphicItemsToPolySet(self, aBuffer, aMaxError, aErrorLoc, aRenderSettings)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_TABLE self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_TABLE self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TABLE_HitTest(self, *args)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_TABLE self, PCB_TABLE aOther) -> bool
        __eq__(PCB_TABLE self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_TABLE___eq__(self, *args)
 
    @staticmethod
    def Compare(aTable, aOther):
        r"""Compare(PCB_TABLE aTable, PCB_TABLE aOther) -> int"""
        return _pcbnew.PCB_TABLE_Compare(aTable, aOther)
 
    def GetHash(self):
        r"""GetHash(PCB_TABLE self) -> size_t"""
        return _pcbnew.PCB_TABLE_GetHash(self)
 
# Register PCB_TABLE in _pcbnew:
_pcbnew.PCB_TABLE_swigregister(PCB_TABLE)
class PADS_VEC(object):
    r"""Proxy of C++ std::vector< 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(PADS_VEC self) -> SwigPyIterator"""
        return _pcbnew.PADS_VEC_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(PADS_VEC self) -> bool"""
        return _pcbnew.PADS_VEC___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(PADS_VEC self) -> bool"""
        return _pcbnew.PADS_VEC___bool__(self)
 
    def __len__(self):
        r"""__len__(PADS_VEC self) -> std::vector< PAD * >::size_type"""
        return _pcbnew.PADS_VEC___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j) -> PADS_VEC"""
        return _pcbnew.PADS_VEC___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j)
        __setslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j, PADS_VEC v)
        """
        return _pcbnew.PADS_VEC___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j)"""
        return _pcbnew.PADS_VEC___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(PADS_VEC self, std::vector< PAD * >::difference_type i)
        __delitem__(PADS_VEC self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.PADS_VEC___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(PADS_VEC self, SWIGPY_SLICEOBJECT * slice) -> PADS_VEC
        __getitem__(PADS_VEC self, std::vector< PAD * >::difference_type i) -> PAD
        """
        return _pcbnew.PADS_VEC___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(PADS_VEC self, SWIGPY_SLICEOBJECT * slice, PADS_VEC v)
        __setitem__(PADS_VEC self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(PADS_VEC self, std::vector< PAD * >::difference_type i, PAD x)
        """
        return _pcbnew.PADS_VEC___setitem__(self, *args)
 
    def pop(self):
        r"""pop(PADS_VEC self) -> PAD"""
        return _pcbnew.PADS_VEC_pop(self)
 
    def append(self, x):
        r"""append(PADS_VEC self, PAD x)"""
        return _pcbnew.PADS_VEC_append(self, x)
 
    def empty(self):
        r"""empty(PADS_VEC self) -> bool"""
        return _pcbnew.PADS_VEC_empty(self)
 
    def size(self):
        r"""size(PADS_VEC self) -> std::vector< PAD * >::size_type"""
        return _pcbnew.PADS_VEC_size(self)
 
    def swap(self, v):
        r"""swap(PADS_VEC self, PADS_VEC v)"""
        return _pcbnew.PADS_VEC_swap(self, v)
 
    def begin(self):
        r"""begin(PADS_VEC self) -> std::vector< PAD * >::iterator"""
        return _pcbnew.PADS_VEC_begin(self)
 
    def end(self):
        r"""end(PADS_VEC self) -> std::vector< PAD * >::iterator"""
        return _pcbnew.PADS_VEC_end(self)
 
    def rbegin(self):
        r"""rbegin(PADS_VEC self) -> std::vector< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_VEC_rbegin(self)
 
    def rend(self):
        r"""rend(PADS_VEC self) -> std::vector< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_VEC_rend(self)
 
    def clear(self):
        r"""clear(PADS_VEC self)"""
        return _pcbnew.PADS_VEC_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(PADS_VEC self) -> std::vector< PAD * >::allocator_type"""
        return _pcbnew.PADS_VEC_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(PADS_VEC self)"""
        return _pcbnew.PADS_VEC_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(PADS_VEC self, std::vector< PAD * >::iterator pos) -> std::vector< PAD * >::iterator
        erase(PADS_VEC self, std::vector< PAD * >::iterator first, std::vector< PAD * >::iterator last) -> std::vector< PAD * >::iterator
        """
        return _pcbnew.PADS_VEC_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(PADS_VEC self) -> PADS_VEC
        __init__(PADS_VEC self, PADS_VEC other) -> PADS_VEC
        __init__(PADS_VEC self, std::vector< PAD * >::size_type size) -> PADS_VEC
        __init__(PADS_VEC self, std::vector< PAD * >::size_type size, PAD value) -> PADS_VEC
        """
        _pcbnew.PADS_VEC_swiginit(self, _pcbnew.new_PADS_VEC(*args))
 
    def push_back(self, x):
        r"""push_back(PADS_VEC self, PAD x)"""
        return _pcbnew.PADS_VEC_push_back(self, x)
 
    def front(self):
        r"""front(PADS_VEC self) -> PAD"""
        return _pcbnew.PADS_VEC_front(self)
 
    def back(self):
        r"""back(PADS_VEC self) -> PAD"""
        return _pcbnew.PADS_VEC_back(self)
 
    def assign(self, n, x):
        r"""assign(PADS_VEC self, std::vector< PAD * >::size_type n, PAD x)"""
        return _pcbnew.PADS_VEC_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(PADS_VEC self, std::vector< PAD * >::size_type new_size)
        resize(PADS_VEC self, std::vector< PAD * >::size_type new_size, PAD x)
        """
        return _pcbnew.PADS_VEC_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(PADS_VEC self, std::vector< PAD * >::iterator pos, PAD x) -> std::vector< PAD * >::iterator
        insert(PADS_VEC self, std::vector< PAD * >::iterator pos, std::vector< PAD * >::size_type n, PAD x)
        """
        return _pcbnew.PADS_VEC_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(PADS_VEC self, std::vector< PAD * >::size_type n)"""
        return _pcbnew.PADS_VEC_reserve(self, n)
 
    def capacity(self):
        r"""capacity(PADS_VEC self) -> std::vector< PAD * >::size_type"""
        return _pcbnew.PADS_VEC_capacity(self)
    __swig_destroy__ = _pcbnew.delete_PADS_VEC
 
# Register PADS_VEC in _pcbnew:
_pcbnew.PADS_VEC_swigregister(PADS_VEC)
class TRACKS_VEC(object):
    r"""Proxy of C++ std::vector< PCB_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_VEC self) -> SwigPyIterator"""
        return _pcbnew.TRACKS_VEC_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(TRACKS_VEC self) -> bool"""
        return _pcbnew.TRACKS_VEC___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(TRACKS_VEC self) -> bool"""
        return _pcbnew.TRACKS_VEC___bool__(self)
 
    def __len__(self):
        r"""__len__(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_VEC___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j) -> TRACKS_VEC"""
        return _pcbnew.TRACKS_VEC___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j)
        __setslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j, TRACKS_VEC v)
        """
        return _pcbnew.TRACKS_VEC___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j)"""
        return _pcbnew.TRACKS_VEC___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i)
        __delitem__(TRACKS_VEC self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.TRACKS_VEC___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(TRACKS_VEC self, SWIGPY_SLICEOBJECT * slice) -> TRACKS_VEC
        __getitem__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i) -> PCB_TRACK
        """
        return _pcbnew.TRACKS_VEC___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(TRACKS_VEC self, SWIGPY_SLICEOBJECT * slice, TRACKS_VEC v)
        __setitem__(TRACKS_VEC self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_VEC___setitem__(self, *args)
 
    def pop(self):
        r"""pop(TRACKS_VEC self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_VEC_pop(self)
 
    def append(self, x):
        r"""append(TRACKS_VEC self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_VEC_append(self, x)
 
    def empty(self):
        r"""empty(TRACKS_VEC self) -> bool"""
        return _pcbnew.TRACKS_VEC_empty(self)
 
    def size(self):
        r"""size(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_VEC_size(self)
 
    def swap(self, v):
        r"""swap(TRACKS_VEC self, TRACKS_VEC v)"""
        return _pcbnew.TRACKS_VEC_swap(self, v)
 
    def begin(self):
        r"""begin(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_VEC_begin(self)
 
    def end(self):
        r"""end(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_VEC_end(self)
 
    def rbegin(self):
        r"""rbegin(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_VEC_rbegin(self)
 
    def rend(self):
        r"""rend(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_VEC_rend(self)
 
    def clear(self):
        r"""clear(TRACKS_VEC self)"""
        return _pcbnew.TRACKS_VEC_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::allocator_type"""
        return _pcbnew.TRACKS_VEC_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(TRACKS_VEC self)"""
        return _pcbnew.TRACKS_VEC_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator pos) -> std::vector< PCB_TRACK * >::iterator
        erase(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator first, std::vector< PCB_TRACK * >::iterator last) -> std::vector< PCB_TRACK * >::iterator
        """
        return _pcbnew.TRACKS_VEC_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(TRACKS_VEC self) -> TRACKS_VEC
        __init__(TRACKS_VEC self, TRACKS_VEC other) -> TRACKS_VEC
        __init__(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type size) -> TRACKS_VEC
        __init__(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type size, PCB_TRACK value) -> TRACKS_VEC
        """
        _pcbnew.TRACKS_VEC_swiginit(self, _pcbnew.new_TRACKS_VEC(*args))
 
    def push_back(self, x):
        r"""push_back(TRACKS_VEC self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_VEC_push_back(self, x)
 
    def front(self):
        r"""front(TRACKS_VEC self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_VEC_front(self)
 
    def back(self):
        r"""back(TRACKS_VEC self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_VEC_back(self)
 
    def assign(self, n, x):
        r"""assign(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type n, PCB_TRACK x)"""
        return _pcbnew.TRACKS_VEC_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type new_size)
        resize(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type new_size, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_VEC_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator pos, PCB_TRACK x) -> std::vector< PCB_TRACK * >::iterator
        insert(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator pos, std::vector< PCB_TRACK * >::size_type n, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_VEC_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type n)"""
        return _pcbnew.TRACKS_VEC_reserve(self, n)
 
    def capacity(self):
        r"""capacity(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_VEC_capacity(self)
    __swig_destroy__ = _pcbnew.delete_TRACKS_VEC
 
# Register TRACKS_VEC in _pcbnew:
_pcbnew.TRACKS_VEC_swigregister(TRACKS_VEC)
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 SetNetClass(self, aNetClass):
        r"""SetNetClass(NETINFO_ITEM self, std::shared_ptr< NETCLASS > const & aNetClass)"""
        return _pcbnew.NETINFO_ITEM_SetNetClass(self, aNetClass)
 
    def GetNetClass(self):
        r"""GetNetClass(NETINFO_ITEM self) -> NETCLASS"""
        return _pcbnew.NETINFO_ITEM_GetNetClass(self)
 
    def GetNetClassSlow(self):
        r"""GetNetClassSlow(NETINFO_ITEM self) -> std::shared_ptr< NETCLASS >"""
        return _pcbnew.NETINFO_ITEM_GetNetClassSlow(self)
 
    def GetNetCode(self):
        r"""GetNetCode(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetNetCode(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 GetDisplayNetname(self):
        r"""GetDisplayNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetDisplayNetname(self)
 
    def HasAutoGeneratedNetname(self):
        r"""HasAutoGeneratedNetname(NETINFO_ITEM self) -> bool"""
        return _pcbnew.NETINFO_ITEM_HasAutoGeneratedNetname(self)
 
    def SetNetname(self, aNewName):
        r"""SetNetname(NETINFO_ITEM self, wxString aNewName)"""
        return _pcbnew.NETINFO_ITEM_SetNetname(self, aNewName)
 
    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 Clear(self):
        r"""Clear(NETINFO_ITEM self)"""
        return _pcbnew.NETINFO_ITEM_Clear(self)
 
    def SetParent(self, aParent):
        r"""SetParent(NETINFO_ITEM self, BOARD aParent)"""
        return _pcbnew.NETINFO_ITEM_SetParent(self, aParent)
 
    def GetParent(self):
        r"""GetParent(NETINFO_ITEM self) -> BOARD"""
        return _pcbnew.NETINFO_ITEM_GetParent(self)
 
    def GetNetClassName(self):
        return self.GetNetClassSlow().GetName()
 
 
# Register NETINFO_ITEM in _pcbnew:
_pcbnew.NETINFO_ITEM_swigregister(NETINFO_ITEM)
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 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)
 
    def RebuildDisplayNetnames(self):
        r"""RebuildDisplayNetnames(NETINFO_LIST self)"""
        return _pcbnew.NETINFO_LIST_RebuildDisplayNetnames(self)
 
    @staticmethod
    def OrphanedItem():
        r"""OrphanedItem() -> NETINFO_ITEM"""
        return _pcbnew.NETINFO_LIST_OrphanedItem()
 
    def GetParent(self):
        r"""GetParent(NETINFO_LIST self) -> BOARD"""
        return _pcbnew.NETINFO_LIST_GetParent(self)
    m_DisplayNetnamesDirty = property(_pcbnew.NETINFO_LIST_m_DisplayNetnamesDirty_get, _pcbnew.NETINFO_LIST_m_DisplayNetnamesDirty_set, doc=r"""m_DisplayNetnamesDirty : bool""")
 
# 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
 
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 NETCLASS(object):
    r"""Proxy of C++ 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, aName, aInitWithDefaults=True):
        r"""__init__(NETCLASS self, wxString aName, bool aInitWithDefaults=True) -> NETCLASS"""
        _pcbnew.NETCLASS_swiginit(self, _pcbnew.new_NETCLASS(aName, aInitWithDefaults))
    __swig_destroy__ = _pcbnew.delete_NETCLASS
 
    def __eq__(self, other):
        r"""__eq__(NETCLASS self, NETCLASS other) -> bool"""
        return _pcbnew.NETCLASS___eq__(self, other)
 
    def GetClass(self):
        r"""GetClass(NETCLASS self) -> wxString"""
        return _pcbnew.NETCLASS_GetClass(self)
 
    def Serialize(self, aContainer):
        r"""Serialize(NETCLASS self, google::protobuf::Any & aContainer)"""
        return _pcbnew.NETCLASS_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(NETCLASS self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.NETCLASS_Deserialize(self, aContainer)
 
    def ResetParents(self):
        r"""ResetParents(NETCLASS self)"""
        return _pcbnew.NETCLASS_ResetParents(self)
 
    def ResetParameters(self):
        r"""ResetParameters(NETCLASS self)"""
        return _pcbnew.NETCLASS_ResetParameters(self)
 
    def GetConstituentNetclasses(self):
        r"""GetConstituentNetclasses(NETCLASS self) -> std::vector< NETCLASS *,std::allocator< NETCLASS * > > const &"""
        return _pcbnew.NETCLASS_GetConstituentNetclasses(self)
 
    def SetConstituentNetclasses(self, constituents):
        r"""SetConstituentNetclasses(NETCLASS self, std::vector< NETCLASS *,std::allocator< NETCLASS * > > && constituents)"""
        return _pcbnew.NETCLASS_SetConstituentNetclasses(self, constituents)
 
    def ContainsNetclassWithName(self, netclass):
        r"""ContainsNetclassWithName(NETCLASS self, wxString netclass) -> bool"""
        return _pcbnew.NETCLASS_ContainsNetclassWithName(self, netclass)
 
    def IsDefault(self):
        r"""IsDefault(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_IsDefault(self)
 
    def SetName(self, aName):
        r"""SetName(NETCLASS self, wxString aName)"""
        return _pcbnew.NETCLASS_SetName(self, aName)
 
    def GetName(self):
        r"""GetName(NETCLASS self) -> wxString"""
        return _pcbnew.NETCLASS_GetName(self)
 
    def GetHumanReadableName(self):
        r"""GetHumanReadableName(NETCLASS self) -> wxString"""
        return _pcbnew.NETCLASS_GetHumanReadableName(self)
 
    def GetDescription(self):
        r"""GetDescription(NETCLASS self) -> wxString"""
        return _pcbnew.NETCLASS_GetDescription(self)
 
    def SetDescription(self, aDesc):
        r"""SetDescription(NETCLASS self, wxString aDesc)"""
        return _pcbnew.NETCLASS_SetDescription(self, aDesc)
 
    def HasClearance(self):
        r"""HasClearance(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasClearance(self)
 
    def GetClearance(self):
        r"""GetClearance(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetClearance(self)
 
    def GetClearanceOpt(self):
        r"""GetClearanceOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetClearanceOpt(self)
 
    def SetClearance(self, aClearance):
        r"""SetClearance(NETCLASS self, int aClearance)"""
        return _pcbnew.NETCLASS_SetClearance(self, aClearance)
 
    def SetClearanceParent(self, parent):
        r"""SetClearanceParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetClearanceParent(self, parent)
 
    def GetClearanceParent(self):
        r"""GetClearanceParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetClearanceParent(self)
 
    def HasTrackWidth(self):
        r"""HasTrackWidth(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasTrackWidth(self)
 
    def GetTrackWidth(self):
        r"""GetTrackWidth(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetTrackWidth(self)
 
    def GetTrackWidthOpt(self):
        r"""GetTrackWidthOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetTrackWidthOpt(self)
 
    def SetTrackWidth(self, aWidth):
        r"""SetTrackWidth(NETCLASS self, int aWidth)"""
        return _pcbnew.NETCLASS_SetTrackWidth(self, aWidth)
 
    def SetTrackWidthParent(self, parent):
        r"""SetTrackWidthParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetTrackWidthParent(self, parent)
 
    def GetTrackWidthParent(self):
        r"""GetTrackWidthParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetTrackWidthParent(self)
 
    def HasViaDiameter(self):
        r"""HasViaDiameter(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasViaDiameter(self)
 
    def GetViaDiameter(self):
        r"""GetViaDiameter(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetViaDiameter(self)
 
    def GetViaDiameterOpt(self):
        r"""GetViaDiameterOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetViaDiameterOpt(self)
 
    def SetViaDiameter(self, aDia):
        r"""SetViaDiameter(NETCLASS self, int aDia)"""
        return _pcbnew.NETCLASS_SetViaDiameter(self, aDia)
 
    def SetViaDiameterParent(self, parent):
        r"""SetViaDiameterParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetViaDiameterParent(self, parent)
 
    def GetViaDiameterParent(self):
        r"""GetViaDiameterParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetViaDiameterParent(self)
 
    def HasViaDrill(self):
        r"""HasViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_HasViaDrill(self)
 
    def GetViaDrill(self):
        r"""GetViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetViaDrill(self)
 
    def GetViaDrillOpt(self):
        r"""GetViaDrillOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetViaDrillOpt(self)
 
    def SetViaDrill(self, aSize):
        r"""SetViaDrill(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetViaDrill(self, aSize)
 
    def SetViaDrillParent(self, parent):
        r"""SetViaDrillParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetViaDrillParent(self, parent)
 
    def GetViaDrillParent(self):
        r"""GetViaDrillParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetViaDrillParent(self)
 
    def HasuViaDiameter(self):
        r"""HasuViaDiameter(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasuViaDiameter(self)
 
    def GetuViaDiameter(self):
        r"""GetuViaDiameter(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetuViaDiameter(self)
 
    def GetuViaDiameterOpt(self):
        r"""GetuViaDiameterOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetuViaDiameterOpt(self)
 
    def SetuViaDiameter(self, aSize):
        r"""SetuViaDiameter(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetuViaDiameter(self, aSize)
 
    def SetuViaDiameterParent(self, parent):
        r"""SetuViaDiameterParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetuViaDiameterParent(self, parent)
 
    def GetuViaDiameterParent(self):
        r"""GetuViaDiameterParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetuViaDiameterParent(self)
 
    def HasuViaDrill(self):
        r"""HasuViaDrill(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasuViaDrill(self)
 
    def GetuViaDrill(self):
        r"""GetuViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetuViaDrill(self)
 
    def GetuViaDrillOpt(self):
        r"""GetuViaDrillOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetuViaDrillOpt(self)
 
    def SetuViaDrill(self, aSize):
        r"""SetuViaDrill(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetuViaDrill(self, aSize)
 
    def SetuViaDrillParent(self, parent):
        r"""SetuViaDrillParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetuViaDrillParent(self, parent)
 
    def GetuViaDrillParent(self):
        r"""GetuViaDrillParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetuViaDrillParent(self)
 
    def HasDiffPairWidth(self):
        r"""HasDiffPairWidth(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasDiffPairWidth(self)
 
    def GetDiffPairWidth(self):
        r"""GetDiffPairWidth(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetDiffPairWidth(self)
 
    def GetDiffPairWidthOpt(self):
        r"""GetDiffPairWidthOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetDiffPairWidthOpt(self)
 
    def SetDiffPairWidth(self, aSize):
        r"""SetDiffPairWidth(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetDiffPairWidth(self, aSize)
 
    def SetDiffPairWidthParent(self, parent):
        r"""SetDiffPairWidthParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetDiffPairWidthParent(self, parent)
 
    def GetDiffPairWidthParent(self):
        r"""GetDiffPairWidthParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetDiffPairWidthParent(self)
 
    def HasDiffPairGap(self):
        r"""HasDiffPairGap(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasDiffPairGap(self)
 
    def GetDiffPairGap(self):
        r"""GetDiffPairGap(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetDiffPairGap(self)
 
    def GetDiffPairGapOpt(self):
        r"""GetDiffPairGapOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetDiffPairGapOpt(self)
 
    def SetDiffPairGap(self, aSize):
        r"""SetDiffPairGap(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetDiffPairGap(self, aSize)
 
    def SetDiffPairGapParent(self, parent):
        r"""SetDiffPairGapParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetDiffPairGapParent(self, parent)
 
    def GetDiffPairGapParent(self):
        r"""GetDiffPairGapParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetDiffPairGapParent(self)
 
    def HasDiffPairViaGap(self):
        r"""HasDiffPairViaGap(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasDiffPairViaGap(self)
 
    def GetDiffPairViaGap(self):
        r"""GetDiffPairViaGap(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetDiffPairViaGap(self)
 
    def GetDiffPairViaGapOpt(self):
        r"""GetDiffPairViaGapOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetDiffPairViaGapOpt(self)
 
    def SetDiffPairViaGap(self, aSize):
        r"""SetDiffPairViaGap(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetDiffPairViaGap(self, aSize)
 
    def SetDiffPairViaGapParent(self, parent):
        r"""SetDiffPairViaGapParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetDiffPairViaGapParent(self, parent)
 
    def GetDiffPairViaGapParent(self):
        r"""GetDiffPairViaGapParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetDiffPairViaGapParent(self)
 
    def HasPcbColor(self):
        r"""HasPcbColor(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasPcbColor(self)
 
    def GetPcbColor(self, aIsForSave=False):
        r"""GetPcbColor(NETCLASS self, bool aIsForSave=False) -> COLOR4D"""
        return _pcbnew.NETCLASS_GetPcbColor(self, aIsForSave)
 
    def SetPcbColor(self, aColor):
        r"""SetPcbColor(NETCLASS self, COLOR4D aColor)"""
        return _pcbnew.NETCLASS_SetPcbColor(self, aColor)
 
    def SetPcbColorParent(self, parent):
        r"""SetPcbColorParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetPcbColorParent(self, parent)
 
    def GetPcbColorParent(self):
        r"""GetPcbColorParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetPcbColorParent(self)
 
    def HasWireWidth(self):
        r"""HasWireWidth(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasWireWidth(self)
 
    def GetWireWidth(self):
        r"""GetWireWidth(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetWireWidth(self)
 
    def GetWireWidthOpt(self):
        r"""GetWireWidthOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetWireWidthOpt(self)
 
    def SetWireWidth(self, aWidth):
        r"""SetWireWidth(NETCLASS self, int aWidth)"""
        return _pcbnew.NETCLASS_SetWireWidth(self, aWidth)
 
    def SetWireWidthParent(self, parent):
        r"""SetWireWidthParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetWireWidthParent(self, parent)
 
    def GetWireWidthParent(self):
        r"""GetWireWidthParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetWireWidthParent(self)
 
    def HasBusWidth(self):
        r"""HasBusWidth(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasBusWidth(self)
 
    def GetBusWidth(self):
        r"""GetBusWidth(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetBusWidth(self)
 
    def GetBusWidthOpt(self):
        r"""GetBusWidthOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetBusWidthOpt(self)
 
    def SetBusWidth(self, aWidth):
        r"""SetBusWidth(NETCLASS self, int aWidth)"""
        return _pcbnew.NETCLASS_SetBusWidth(self, aWidth)
 
    def SetBusWidthParent(self, parent):
        r"""SetBusWidthParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetBusWidthParent(self, parent)
 
    def GetBusWidthParent(self):
        r"""GetBusWidthParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetBusWidthParent(self)
 
    def GetSchematicColor(self, aIsForSave=False):
        r"""GetSchematicColor(NETCLASS self, bool aIsForSave=False) -> COLOR4D"""
        return _pcbnew.NETCLASS_GetSchematicColor(self, aIsForSave)
 
    def SetSchematicColor(self, aColor):
        r"""SetSchematicColor(NETCLASS self, COLOR4D aColor)"""
        return _pcbnew.NETCLASS_SetSchematicColor(self, aColor)
 
    def SetSchematicColorParent(self, parent):
        r"""SetSchematicColorParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetSchematicColorParent(self, parent)
 
    def GetSchematicColorParent(self):
        r"""GetSchematicColorParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetSchematicColorParent(self)
 
    def HasLineStyle(self):
        r"""HasLineStyle(NETCLASS self) -> bool"""
        return _pcbnew.NETCLASS_HasLineStyle(self)
 
    def GetLineStyle(self):
        r"""GetLineStyle(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetLineStyle(self)
 
    def GetLineStyleOpt(self):
        r"""GetLineStyleOpt(NETCLASS self) -> std::optional< int >"""
        return _pcbnew.NETCLASS_GetLineStyleOpt(self)
 
    def SetLineStyle(self, aStyle):
        r"""SetLineStyle(NETCLASS self, int aStyle)"""
        return _pcbnew.NETCLASS_SetLineStyle(self, aStyle)
 
    def SetLineStyleParent(self, parent):
        r"""SetLineStyleParent(NETCLASS self, NETCLASS parent)"""
        return _pcbnew.NETCLASS_SetLineStyleParent(self, parent)
 
    def GetLineStyleParent(self):
        r"""GetLineStyleParent(NETCLASS self) -> NETCLASS"""
        return _pcbnew.NETCLASS_GetLineStyleParent(self)
 
    def SetPriority(self, aPriority):
        r"""SetPriority(NETCLASS self, int aPriority)"""
        return _pcbnew.NETCLASS_SetPriority(self, aPriority)
 
    def GetPriority(self):
        r"""GetPriority(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetPriority(self)
 
# Register NETCLASS in _pcbnew:
_pcbnew.NETCLASS_swigregister(NETCLASS)
NETCLASS.Default = _pcbnew.cvar.NETCLASS_Default
 
class PCB_GROUP(BOARD_ITEM):
    r"""Proxy of C++ PCB_GROUP 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__(PCB_GROUP self, BOARD_ITEM aParent) -> PCB_GROUP"""
        _pcbnew.PCB_GROUP_swiginit(self, _pcbnew.new_PCB_GROUP(aParent))
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_GROUP_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_GROUP self) -> wxString"""
        return _pcbnew.PCB_GROUP_GetClass(self)
 
    def GetName(self):
        r"""GetName(PCB_GROUP self) -> wxString"""
        return _pcbnew.PCB_GROUP_GetName(self)
 
    def SetName(self, aName):
        r"""SetName(PCB_GROUP self, wxString aName)"""
        return _pcbnew.PCB_GROUP_SetName(self, aName)
 
    def GetItems(self, *args):
        r"""
        GetItems(PCB_GROUP self) -> std::unordered_set< BOARD_ITEM * >
        GetItems(PCB_GROUP self) -> std::unordered_set< BOARD_ITEM * > const &
        """
        return _pcbnew.PCB_GROUP_GetItems(self, *args)
 
    def AddItem(self, aItem):
        r"""AddItem(PCB_GROUP self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.PCB_GROUP_AddItem(self, aItem)
 
    def RemoveItem(self, aItem):
        r"""RemoveItem(PCB_GROUP self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.PCB_GROUP_RemoveItem(self, aItem)
 
    def RemoveAll(self):
        r"""RemoveAll(PCB_GROUP self)"""
        return _pcbnew.PCB_GROUP_RemoveAll(self)
 
    @staticmethod
    def TopLevelGroup(aItem, aScope, isFootprintEditor):
        r"""TopLevelGroup(BOARD_ITEM aItem, PCB_GROUP aScope, bool isFootprintEditor) -> PCB_GROUP"""
        return _pcbnew.PCB_GROUP_TopLevelGroup(aItem, aScope, isFootprintEditor)
 
    @staticmethod
    def WithinScope(aItem, aScope, isFootprintEditor):
        r"""WithinScope(BOARD_ITEM aItem, PCB_GROUP aScope, bool isFootprintEditor) -> bool"""
        return _pcbnew.PCB_GROUP_WithinScope(aItem, aScope, isFootprintEditor)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_GROUP self, PCB_GROUP aOther) -> bool
        __eq__(PCB_GROUP self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_GROUP___eq__(self, *args)
 
    def DeepClone(self):
        r"""DeepClone(PCB_GROUP self) -> PCB_GROUP"""
        return _pcbnew.PCB_GROUP_DeepClone(self)
 
    def DeepDuplicate(self):
        r"""DeepDuplicate(PCB_GROUP self) -> PCB_GROUP"""
        return _pcbnew.PCB_GROUP_DeepDuplicate(self)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_GROUP self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_GROUP self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_GROUP_HitTest(self, *args)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_GROUP self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_GROUP_GetEffectiveShape(self, *args)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_GROUP self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_GROUP_ViewGetLOD(self, aLayer, aView)
 
    def RunOnDescendants(self, aFunction, aDepth=0):
        r"""RunOnDescendants(PCB_GROUP self, std::function< void (BOARD_ITEM *) > const & aFunction, int aDepth=0)"""
        return _pcbnew.PCB_GROUP_RunOnDescendants(self, aFunction, aDepth)
 
    @staticmethod
    def IsGroupableType(aType):
        r"""IsGroupableType(KICAD_T aType) -> bool"""
        return _pcbnew.PCB_GROUP_IsGroupableType(aType)
 
    def GetItemsDeque(self):
        r"""GetItemsDeque(PCB_GROUP self) -> DRAWINGS"""
        return _pcbnew.PCB_GROUP_GetItemsDeque(self)
 
    def GetItems(self):
        return [item.Cast() for item in self.GetItemsDeque()]
 
    __swig_destroy__ = _pcbnew.delete_PCB_GROUP
 
# Register PCB_GROUP in _pcbnew:
_pcbnew.PCB_GROUP_swigregister(PCB_GROUP)
class PCB_REFERENCE_IMAGE(BOARD_ITEM):
    r"""Proxy of C++ PCB_REFERENCE_IMAGE 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_REFERENCE_IMAGE self, BOARD_ITEM aParent, VECTOR2I pos=VECTOR2I( 0, 0 ), PCB_LAYER_ID aLayer=F_Cu) -> PCB_REFERENCE_IMAGE
        __init__(PCB_REFERENCE_IMAGE self, PCB_REFERENCE_IMAGE aPcbBitmap) -> PCB_REFERENCE_IMAGE
        """
        _pcbnew.PCB_REFERENCE_IMAGE_swiginit(self, _pcbnew.new_PCB_REFERENCE_IMAGE(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_REFERENCE_IMAGE
 
    def GetReferenceImage(self, *args):
        r"""
        GetReferenceImage(PCB_REFERENCE_IMAGE self) -> REFERENCE_IMAGE
        GetReferenceImage(PCB_REFERENCE_IMAGE self) -> REFERENCE_IMAGE const &
        """
        return _pcbnew.PCB_REFERENCE_IMAGE_GetReferenceImage(self, *args)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_REFERENCE_IMAGE_ClassOf(aItem)
 
    def GetClass(self):
        r"""GetClass(PCB_REFERENCE_IMAGE self) -> wxString"""
        return _pcbnew.PCB_REFERENCE_IMAGE_GetClass(self)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(PCB_REFERENCE_IMAGE self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.PCB_REFERENCE_IMAGE_ViewGetLOD(self, aLayer, aView)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(PCB_REFERENCE_IMAGE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_REFERENCE_IMAGE_GetEffectiveShape(self, *args)
 
    def HitTest(self, *args):
        r"""
        HitTest(PCB_REFERENCE_IMAGE self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_REFERENCE_IMAGE self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_REFERENCE_IMAGE_HitTest(self, *args)
 
    def __eq__(self, *args):
        r"""
        __eq__(PCB_REFERENCE_IMAGE self, PCB_REFERENCE_IMAGE aOther) -> bool
        __eq__(PCB_REFERENCE_IMAGE self, BOARD_ITEM aBoardItem) -> bool
        """
        return _pcbnew.PCB_REFERENCE_IMAGE___eq__(self, *args)
 
# Register PCB_REFERENCE_IMAGE in _pcbnew:
_pcbnew.PCB_REFERENCE_IMAGE_swigregister(PCB_REFERENCE_IMAGE)
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, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.VIA_DIMENSION_Vector___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(VIA_DIMENSION_Vector self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, VIA_DIMENSION_Vector v)
        __setitem__(VIA_DIMENSION_Vector self, SWIGPY_SLICEOBJECT * 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)
DEFAULT_CHAINING_EPSILON_MM = _pcbnew.DEFAULT_CHAINING_EPSILON_MM
 
class PTR_PTR_CACHE_KEY(object):
    r"""Proxy of C++ PTR_PTR_CACHE_KEY class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    A = property(_pcbnew.PTR_PTR_CACHE_KEY_A_get, _pcbnew.PTR_PTR_CACHE_KEY_A_set, doc=r"""A : p.BOARD_ITEM""")
    B = property(_pcbnew.PTR_PTR_CACHE_KEY_B_get, _pcbnew.PTR_PTR_CACHE_KEY_B_set, doc=r"""B : p.BOARD_ITEM""")
 
    def __eq__(self, other):
        r"""__eq__(PTR_PTR_CACHE_KEY self, PTR_PTR_CACHE_KEY other) -> bool"""
        return _pcbnew.PTR_PTR_CACHE_KEY___eq__(self, other)
 
    def __init__(self):
        r"""__init__(PTR_PTR_CACHE_KEY self) -> PTR_PTR_CACHE_KEY"""
        _pcbnew.PTR_PTR_CACHE_KEY_swiginit(self, _pcbnew.new_PTR_PTR_CACHE_KEY())
    __swig_destroy__ = _pcbnew.delete_PTR_PTR_CACHE_KEY
 
# Register PTR_PTR_CACHE_KEY in _pcbnew:
_pcbnew.PTR_PTR_CACHE_KEY_swigregister(PTR_PTR_CACHE_KEY)
class PTR_LAYER_CACHE_KEY(object):
    r"""Proxy of C++ PTR_LAYER_CACHE_KEY class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    A = property(_pcbnew.PTR_LAYER_CACHE_KEY_A_get, _pcbnew.PTR_LAYER_CACHE_KEY_A_set, doc=r"""A : p.BOARD_ITEM""")
    Layer = property(_pcbnew.PTR_LAYER_CACHE_KEY_Layer_get, _pcbnew.PTR_LAYER_CACHE_KEY_Layer_set, doc=r"""Layer : PCB_LAYER_ID""")
 
    def __eq__(self, other):
        r"""__eq__(PTR_LAYER_CACHE_KEY self, PTR_LAYER_CACHE_KEY other) -> bool"""
        return _pcbnew.PTR_LAYER_CACHE_KEY___eq__(self, other)
 
    def __init__(self):
        r"""__init__(PTR_LAYER_CACHE_KEY self) -> PTR_LAYER_CACHE_KEY"""
        _pcbnew.PTR_LAYER_CACHE_KEY_swiginit(self, _pcbnew.new_PTR_LAYER_CACHE_KEY())
    __swig_destroy__ = _pcbnew.delete_PTR_LAYER_CACHE_KEY
 
# Register PTR_LAYER_CACHE_KEY in _pcbnew:
_pcbnew.PTR_LAYER_CACHE_KEY_swigregister(PTR_LAYER_CACHE_KEY)
class PTR_PTR_LAYER_CACHE_KEY(object):
    r"""Proxy of C++ PTR_PTR_LAYER_CACHE_KEY class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    A = property(_pcbnew.PTR_PTR_LAYER_CACHE_KEY_A_get, _pcbnew.PTR_PTR_LAYER_CACHE_KEY_A_set, doc=r"""A : p.BOARD_ITEM""")
    B = property(_pcbnew.PTR_PTR_LAYER_CACHE_KEY_B_get, _pcbnew.PTR_PTR_LAYER_CACHE_KEY_B_set, doc=r"""B : p.BOARD_ITEM""")
    Layer = property(_pcbnew.PTR_PTR_LAYER_CACHE_KEY_Layer_get, _pcbnew.PTR_PTR_LAYER_CACHE_KEY_Layer_set, doc=r"""Layer : PCB_LAYER_ID""")
 
    def __eq__(self, other):
        r"""__eq__(PTR_PTR_LAYER_CACHE_KEY self, PTR_PTR_LAYER_CACHE_KEY other) -> bool"""
        return _pcbnew.PTR_PTR_LAYER_CACHE_KEY___eq__(self, other)
 
    def __init__(self):
        r"""__init__(PTR_PTR_LAYER_CACHE_KEY self) -> PTR_PTR_LAYER_CACHE_KEY"""
        _pcbnew.PTR_PTR_LAYER_CACHE_KEY_swiginit(self, _pcbnew.new_PTR_PTR_LAYER_CACHE_KEY())
    __swig_destroy__ = _pcbnew.delete_PTR_PTR_LAYER_CACHE_KEY
 
# Register PTR_PTR_LAYER_CACHE_KEY in _pcbnew:
_pcbnew.PTR_PTR_LAYER_CACHE_KEY_swigregister(PTR_PTR_LAYER_CACHE_KEY)
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
 
LT_AUX = _pcbnew.LT_AUX
 
LT_FRONT = _pcbnew.LT_FRONT
 
LT_BACK = _pcbnew.LT_BACK
 
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_userName = property(_pcbnew.LAYER_m_userName_get, _pcbnew.LAYER_m_userName_set, doc=r"""m_userName : 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""")
    m_opposite = property(_pcbnew.LAYER_m_opposite_get, _pcbnew.LAYER_m_opposite_set, doc=r"""m_opposite : 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)
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 BOARD_LISTENER(object):
    r"""Proxy of C++ BOARD_LISTENER 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_BOARD_LISTENER
 
    def OnBoardItemAdded(self, aBoard, aBoardItem):
        r"""OnBoardItemAdded(BOARD_LISTENER self, BOARD aBoard, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemAdded(self, aBoard, aBoardItem)
 
    def OnBoardItemsAdded(self, aBoard, aBoardItems):
        r"""OnBoardItemsAdded(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aBoardItems)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemsAdded(self, aBoard, aBoardItems)
 
    def OnBoardItemRemoved(self, aBoard, aBoardItem):
        r"""OnBoardItemRemoved(BOARD_LISTENER self, BOARD aBoard, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemRemoved(self, aBoard, aBoardItem)
 
    def OnBoardItemsRemoved(self, aBoard, aBoardItems):
        r"""OnBoardItemsRemoved(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aBoardItems)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemsRemoved(self, aBoard, aBoardItems)
 
    def OnBoardNetSettingsChanged(self, aBoard):
        r"""OnBoardNetSettingsChanged(BOARD_LISTENER self, BOARD aBoard)"""
        return _pcbnew.BOARD_LISTENER_OnBoardNetSettingsChanged(self, aBoard)
 
    def OnBoardItemChanged(self, aBoard, aBoardItem):
        r"""OnBoardItemChanged(BOARD_LISTENER self, BOARD aBoard, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemChanged(self, aBoard, aBoardItem)
 
    def OnBoardItemsChanged(self, aBoard, aBoardItems):
        r"""OnBoardItemsChanged(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aBoardItems)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemsChanged(self, aBoard, aBoardItems)
 
    def OnBoardHighlightNetChanged(self, aBoard):
        r"""OnBoardHighlightNetChanged(BOARD_LISTENER self, BOARD aBoard)"""
        return _pcbnew.BOARD_LISTENER_OnBoardHighlightNetChanged(self, aBoard)
 
    def OnBoardRatsnestChanged(self, aBoard):
        r"""OnBoardRatsnestChanged(BOARD_LISTENER self, BOARD aBoard)"""
        return _pcbnew.BOARD_LISTENER_OnBoardRatsnestChanged(self, aBoard)
 
    def OnBoardCompositeUpdate(self, aBoard, aAddedItems, aRemovedItems, aChangedItems):
        r"""OnBoardCompositeUpdate(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aAddedItems, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aRemovedItems, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aChangedItems)"""
        return _pcbnew.BOARD_LISTENER_OnBoardCompositeUpdate(self, aBoard, aAddedItems, aRemovedItems, aChangedItems)
 
    def __init__(self):
        r"""__init__(BOARD_LISTENER self) -> BOARD_LISTENER"""
        _pcbnew.BOARD_LISTENER_swiginit(self, _pcbnew.new_BOARD_LISTENER())
 
# Register BOARD_LISTENER in _pcbnew:
_pcbnew.BOARD_LISTENER_swigregister(BOARD_LISTENER)
BOARD_USE_NORMAL = _pcbnew.BOARD_USE_NORMAL
 
BOARD_USE_FPHOLDER = _pcbnew.BOARD_USE_FPHOLDER
 
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")
 
    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_ClassOf(aItem)
 
    def SetBoardUse(self, aUse):
        r"""SetBoardUse(BOARD self, BOARD_USE aUse)"""
        return _pcbnew.BOARD_SetBoardUse(self, aUse)
 
    def GetBoardUse(self):
        r"""GetBoardUse(BOARD self) -> BOARD_USE"""
        return _pcbnew.BOARD_GetBoardUse(self)
 
    def IncrementTimeStamp(self):
        r"""IncrementTimeStamp(BOARD self)"""
        return _pcbnew.BOARD_IncrementTimeStamp(self)
 
    def GetTimeStamp(self):
        r"""GetTimeStamp(BOARD self) -> int"""
        return _pcbnew.BOARD_GetTimeStamp(self)
 
    def IsFootprintHolder(self):
        r"""IsFootprintHolder(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsFootprintHolder(self)
 
    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)
 
    def Footprints(self):
        r"""Footprints(BOARD self) -> FOOTPRINTS"""
        return _pcbnew.BOARD_Footprints(self)
 
    def Zones(self):
        r"""Zones(BOARD self) -> ZONES"""
        return _pcbnew.BOARD_Zones(self)
 
    def Generators(self):
        r"""Generators(BOARD self) -> GENERATORS"""
        return _pcbnew.BOARD_Generators(self)
 
    def Markers(self):
        r"""Markers(BOARD self) -> MARKERS"""
        return _pcbnew.BOARD_Markers(self)
 
    def Drawings(self, *args):
        r"""
        Drawings(BOARD self) -> DRAWINGS
        Drawings(BOARD self) -> DRAWINGS
        """
        return _pcbnew.BOARD_Drawings(self, *args)
 
    def Tracks(self, *args):
        r"""
        Tracks(BOARD self) -> TRACKS
        Tracks(BOARD self) -> TRACKS
        """
        return _pcbnew.BOARD_Tracks(self, *args)
 
    def GetItemSet(self):
        r"""GetItemSet(BOARD self) -> BOARD_ITEM_SET const"""
        return _pcbnew.BOARD_GetItemSet(self)
 
    def Groups(self):
        r"""Groups(BOARD self) -> GROUPS"""
        return _pcbnew.BOARD_Groups(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 GetProperties(self):
        r"""GetProperties(BOARD self) -> MAP_STRING_STRING"""
        return _pcbnew.BOARD_GetProperties(self)
 
    def SetProperties(self, aProps):
        r"""SetProperties(BOARD self, MAP_STRING_STRING aProps)"""
        return _pcbnew.BOARD_SetProperties(self, aProps)
 
    def GetContextualTextVars(self, aVars):
        r"""GetContextualTextVars(BOARD self, wxArrayString * aVars)"""
        return _pcbnew.BOARD_GetContextualTextVars(self, aVars)
 
    def ResolveTextVar(self, token, aDepth):
        r"""ResolveTextVar(BOARD self, wxString token, int aDepth) -> bool"""
        return _pcbnew.BOARD_ResolveTextVar(self, token, aDepth)
    m_LegacyVisibleLayers = property(_pcbnew.BOARD_m_LegacyVisibleLayers_get, _pcbnew.BOARD_m_LegacyVisibleLayers_set, doc=r"""m_LegacyVisibleLayers : LSET""")
    m_LegacyVisibleItems = property(_pcbnew.BOARD_m_LegacyVisibleItems_get, _pcbnew.BOARD_m_LegacyVisibleItems_set, doc=r"""m_LegacyVisibleItems : GAL_SET""")
    m_LegacyDesignSettingsLoaded = property(_pcbnew.BOARD_m_LegacyDesignSettingsLoaded_get, _pcbnew.BOARD_m_LegacyDesignSettingsLoaded_set, doc=r"""m_LegacyDesignSettingsLoaded : bool""")
    m_LegacyCopperEdgeClearanceLoaded = property(_pcbnew.BOARD_m_LegacyCopperEdgeClearanceLoaded_get, _pcbnew.BOARD_m_LegacyCopperEdgeClearanceLoaded_set, doc=r"""m_LegacyCopperEdgeClearanceLoaded : bool""")
    m_LegacyNetclassesLoaded = property(_pcbnew.BOARD_m_LegacyNetclassesLoaded_get, _pcbnew.BOARD_m_LegacyNetclassesLoaded_set, doc=r"""m_LegacyNetclassesLoaded : bool""")
    __swig_destroy__ = _pcbnew.delete_BOARD
 
    def IsEmpty(self):
        r"""IsEmpty(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsEmpty(self)
 
    def RunOnDescendants(self, aFunction, aDepth=0):
        r"""RunOnDescendants(BOARD self, std::function< void (BOARD_ITEM *) > const & aFunction, int aDepth=0)"""
        return _pcbnew.BOARD_RunOnDescendants(self, aFunction, aDepth)
 
    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 SetGenerator(self, aGenerator):
        r"""SetGenerator(BOARD self, wxString aGenerator)"""
        return _pcbnew.BOARD_SetGenerator(self, aGenerator)
 
    def GetGenerator(self):
        r"""GetGenerator(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetGenerator(self)
 
    def AddNative(self, *args):
        r"""AddNative(BOARD self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT, bool aSkipConnectivity=False)"""
        return _pcbnew.BOARD_AddNative(self, *args)
 
    def RemoveNative(self, *args):
        r"""RemoveNative(BOARD self, BOARD_ITEM aBoardItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.BOARD_RemoveNative(self, *args)
 
    def RemoveAll(self, *args):
        r"""
        RemoveAll(BOARD self, std::initializer_list< KICAD_T > aTypes={ PCB_NETINFO_T, PCB_MARKER_T,
                                                                      PCB_GROUP_T, PCB_ZONE_T,
                                                                      PCB_GENERATOR_T, PCB_FOOTPRINT_T,
                                                                      PCB_TRACE_T, PCB_SHAPE_T })
        """
        return _pcbnew.BOARD_RemoveAll(self, *args)
 
    def HasItemsOnLayer(self, aLayer):
        r"""HasItemsOnLayer(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_HasItemsOnLayer(self, aLayer)
 
    def RemoveAllItemsOnLayer(self, aLayer):
        r"""RemoveAllItemsOnLayer(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_RemoveAllItemsOnLayer(self, aLayer)
 
    def BulkRemoveStaleTeardrops(self, aCommit):
        r"""BulkRemoveStaleTeardrops(BOARD self, BOARD_COMMIT & aCommit)"""
        return _pcbnew.BOARD_BulkRemoveStaleTeardrops(self, aCommit)
 
    def FinalizeBulkAdd(self, aNewItems):
        r"""FinalizeBulkAdd(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aNewItems)"""
        return _pcbnew.BOARD_FinalizeBulkAdd(self, aNewItems)
 
    def FinalizeBulkRemove(self, aRemovedItems):
        r"""FinalizeBulkRemove(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aRemovedItems)"""
        return _pcbnew.BOARD_FinalizeBulkRemove(self, aRemovedItems)
 
    def FixupEmbeddedData(self):
        r"""FixupEmbeddedData(BOARD self)"""
        return _pcbnew.BOARD_FixupEmbeddedData(self)
 
    def RunOnNestedEmbeddedFiles(self, aFunction):
        r"""RunOnNestedEmbeddedFiles(BOARD self, std::function< void (EMBEDDED_FILES *) > const & aFunction)"""
        return _pcbnew.BOARD_RunOnNestedEmbeddedFiles(self, aFunction)
 
    def CacheTriangulation(self, *args):
        r"""CacheTriangulation(BOARD self, PROGRESS_REPORTER * aReporter=None, ZONES aZones={})"""
        return _pcbnew.BOARD_CacheTriangulation(self, *args)
 
    def GetFirstFootprint(self):
        r"""GetFirstFootprint(BOARD self) -> FOOTPRINT"""
        return _pcbnew.BOARD_GetFirstFootprint(self)
 
    def DeleteAllFootprints(self):
        r"""DeleteAllFootprints(BOARD self)"""
        return _pcbnew.BOARD_DeleteAllFootprints(self)
 
    def DetachAllFootprints(self):
        r"""DetachAllFootprints(BOARD self)"""
        return _pcbnew.BOARD_DetachAllFootprints(self)
 
    def GetItem(self, aID):
        r"""GetItem(BOARD self, KIID aID) -> BOARD_ITEM"""
        return _pcbnew.BOARD_GetItem(self, aID)
 
    def FillItemMap(self, aMap):
        r"""FillItemMap(BOARD self, std::map< KIID,EDA_ITEM *,std::less< KIID >,std::allocator< std::pair< KIID const,EDA_ITEM * > > > & aMap)"""
        return _pcbnew.BOARD_FillItemMap(self, aMap)
 
    def ConvertCrossReferencesToKIIDs(self, aSource):
        r"""ConvertCrossReferencesToKIIDs(BOARD self, wxString aSource) -> wxString"""
        return _pcbnew.BOARD_ConvertCrossReferencesToKIIDs(self, aSource)
 
    def ConvertKIIDsToCrossReferences(self, aSource):
        r"""ConvertKIIDsToCrossReferences(BOARD self, wxString aSource) -> wxString"""
        return _pcbnew.BOARD_ConvertKIIDsToCrossReferences(self, aSource)
 
    def GetConnectivity(self):
        r"""GetConnectivity(BOARD self) -> std::shared_ptr< CONNECTIVITY_DATA >"""
        return _pcbnew.BOARD_GetConnectivity(self)
 
    def BuildConnectivity(self, aReporter=None):
        r"""BuildConnectivity(BOARD self, PROGRESS_REPORTER * aReporter=None) -> bool"""
        return _pcbnew.BOARD_BuildConnectivity(self, aReporter)
 
    def DeleteMARKERs(self, *args):
        r"""
        DeleteMARKERs(BOARD self)
        DeleteMARKERs(BOARD self, bool aWarningsAndErrors, bool aExclusions)
        """
        return _pcbnew.BOARD_DeleteMARKERs(self, *args)
 
    def GetProject(self):
        r"""GetProject(BOARD self) -> PROJECT *"""
        return _pcbnew.BOARD_GetProject(self)
 
    def SetProject(self, aProject, aReferenceOnly=False):
        r"""SetProject(BOARD self, PROJECT * aProject, bool aReferenceOnly=False)"""
        return _pcbnew.BOARD_SetProject(self, aProject, aReferenceOnly)
 
    def ClearProject(self):
        r"""ClearProject(BOARD self)"""
        return _pcbnew.BOARD_ClearProject(self)
 
    def ResolveDRCExclusions(self, aCreateMarkers):
        r"""ResolveDRCExclusions(BOARD self, bool aCreateMarkers) -> MARKERS"""
        return _pcbnew.BOARD_ResolveDRCExclusions(self, aCreateMarkers)
 
    def RecordDRCExclusions(self):
        r"""RecordDRCExclusions(BOARD self)"""
        return _pcbnew.BOARD_RecordDRCExclusions(self)
 
    def UpdateRatsnestExclusions(self):
        r"""UpdateRatsnestExclusions(BOARD self)"""
        return _pcbnew.BOARD_UpdateRatsnestExclusions(self)
 
    def ResetNetHighLight(self):
        r"""ResetNetHighLight(BOARD self)"""
        return _pcbnew.BOARD_ResetNetHighLight(self)
 
    def GetHighLightNetCodes(self):
        r"""GetHighLightNetCodes(BOARD self) -> std::set< int,std::less< int >,std::allocator< int > > const &"""
        return _pcbnew.BOARD_GetHighLightNetCodes(self)
 
    def SetHighLightNet(self, aNetCode, aMulti=False):
        r"""SetHighLightNet(BOARD self, int aNetCode, bool aMulti=False)"""
        return _pcbnew.BOARD_SetHighLightNet(self, aNetCode, aMulti)
 
    def IsHighLightNetON(self):
        r"""IsHighLightNetON(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsHighLightNetON(self)
 
    def HighLightON(self, aValue=True):
        r"""HighLightON(BOARD self, bool aValue=True)"""
        return _pcbnew.BOARD_HighLightON(self, aValue)
 
    def HighLightOFF(self):
        r"""HighLightOFF(BOARD self)"""
        return _pcbnew.BOARD_HighLightOFF(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 GetUserDefinedLayerCount(self):
        r"""GetUserDefinedLayerCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetUserDefinedLayerCount(self)
 
    def SetUserDefinedLayerCount(self, aCount):
        r"""SetUserDefinedLayerCount(BOARD self, int aCount)"""
        return _pcbnew.BOARD_SetUserDefinedLayerCount(self, aCount)
 
    def GetCopperLayerStackMaxId(self):
        r"""GetCopperLayerStackMaxId(BOARD self) -> PCB_LAYER_ID"""
        return _pcbnew.BOARD_GetCopperLayerStackMaxId(self)
 
    def FlipLayer(self, aLayer):
        r"""FlipLayer(BOARD self, PCB_LAYER_ID aLayer) -> PCB_LAYER_ID"""
        return _pcbnew.BOARD_FlipLayer(self, aLayer)
 
    def LayerDepth(self, aStartLayer, aEndLayer):
        r"""LayerDepth(BOARD self, PCB_LAYER_ID aStartLayer, PCB_LAYER_ID aEndLayer) -> int"""
        return _pcbnew.BOARD_LayerDepth(self, aStartLayer, aEndLayer)
 
    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) -> GAL_SET"""
        return _pcbnew.BOARD_GetVisibleElements(self)
 
    def SetVisibleElements(self, aMask):
        r"""SetVisibleElements(BOARD self, GAL_SET 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 IsFootprintLayerVisible(self, aLayer):
        r"""IsFootprintLayerVisible(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsFootprintLayerVisible(self, aLayer)
 
    def GetDesignSettings(self):
        r"""GetDesignSettings(BOARD self) -> BOARD_DESIGN_SETTINGS"""
        return _pcbnew.BOARD_GetDesignSettings(self)
 
    def InvalidateClearanceCache(self, aUuid):
        r"""InvalidateClearanceCache(BOARD self, KIID aUuid)"""
        return _pcbnew.BOARD_InvalidateClearanceCache(self, aUuid)
 
    def InitializeClearanceCache(self):
        r"""InitializeClearanceCache(BOARD self)"""
        return _pcbnew.BOARD_InitializeClearanceCache(self)
 
    def GetStackupOrDefault(self):
        r"""GetStackupOrDefault(BOARD self) -> BOARD_STACKUP"""
        return _pcbnew.BOARD_GetStackupOrDefault(self)
 
    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, *args):
        r"""
        GetTitleBlock(BOARD self) -> TITLE_BLOCK
        GetTitleBlock(BOARD self) -> TITLE_BLOCK
        """
        return _pcbnew.BOARD_GetTitleBlock(self, *args)
 
    def SetTitleBlock(self, aTitleBlock):
        r"""SetTitleBlock(BOARD self, TITLE_BLOCK aTitleBlock)"""
        return _pcbnew.BOARD_SetTitleBlock(self, aTitleBlock)
 
    def GetUserUnits(self):
        r"""GetUserUnits(BOARD self) -> EDA_UNITS"""
        return _pcbnew.BOARD_GetUserUnits(self)
 
    def SetUserUnits(self, aUnits):
        r"""SetUserUnits(BOARD self, EDA_UNITS aUnits)"""
        return _pcbnew.BOARD_SetUserUnits(self, aUnits)
 
    def UpdateUserUnits(self, aItem, aView):
        r"""UpdateUserUnits(BOARD self, BOARD_ITEM aItem, KIGFX::VIEW * aView)"""
        return _pcbnew.BOARD_UpdateUserUnits(self, aItem, aView)
 
    def GetBoardPolygonOutlines(self, aOutlines, aErrorHandler=None, aAllowUseArcsInPolygons=False, aIncludeNPTHAsOutlines=False):
        r"""GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET aOutlines, OUTLINE_ERROR_HANDLER * aErrorHandler=None, bool aAllowUseArcsInPolygons=False, bool aIncludeNPTHAsOutlines=False) -> bool"""
        return _pcbnew.BOARD_GetBoardPolygonOutlines(self, aOutlines, aErrorHandler, aAllowUseArcsInPolygons, aIncludeNPTHAsOutlines)
 
    def GetOutlinesChainingEpsilon(self):
        r"""GetOutlinesChainingEpsilon(BOARD self) -> int"""
        return _pcbnew.BOARD_GetOutlinesChainingEpsilon(self)
 
    def SetOutlinesChainingEpsilon(self, aValue):
        r"""SetOutlinesChainingEpsilon(BOARD self, int aValue)"""
        return _pcbnew.BOARD_SetOutlinesChainingEpsilon(self, aValue)
 
    def ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines, aRenderSettings=None):
        r"""ConvertBrdLayerToPolygonalContours(BOARD self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aOutlines, KIGFX::RENDER_SETTINGS * aRenderSettings=None)"""
        return _pcbnew.BOARD_ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines, aRenderSettings)
 
    def GetLayerID(self, aLayerName):
        r"""GetLayerID(BOARD self, wxString aLayerName) -> PCB_LAYER_ID"""
        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 IsFrontLayer(self, aLayer):
        r"""IsFrontLayer(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsFrontLayer(self, aLayer)
 
    def IsBackLayer(self, aLayer):
        r"""IsBackLayer(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsBackLayer(self, 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 GetNodesCount(self, aNet=-1):
        r"""GetNodesCount(BOARD self, int aNet=-1) -> unsigned int"""
        return _pcbnew.BOARD_GetNodesCount(self, aNet)
 
    def GetPads(self):
        r"""GetPads(BOARD self) -> PADS_VEC"""
        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 MatchDpSuffix(self, aNetName, aComplementNet):
        r"""MatchDpSuffix(BOARD self, wxString aNetName, wxString aComplementNet) -> int"""
        return _pcbnew.BOARD_MatchDpSuffix(self, aNetName, aComplementNet)
 
    def DpCoupledNet(self, aNet):
        r"""DpCoupledNet(BOARD self, NETINFO_ITEM aNet) -> NETINFO_ITEM"""
        return _pcbnew.BOARD_DpCoupledNet(self, aNet)
 
    def GetNetInfo(self):
        r"""GetNetInfo(BOARD self) -> NETINFO_LIST"""
        return _pcbnew.BOARD_GetNetInfo(self)
 
    def RemoveUnusedNets(self, aCommit):
        r"""RemoveUnusedNets(BOARD self, BOARD_COMMIT * aCommit)"""
        return _pcbnew.BOARD_RemoveUnusedNets(self, aCommit)
 
    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) -> BOX2I"""
        return _pcbnew.BOARD_ComputeBoundingBox(self, aBoardEdgesOnly)
 
    def GetBoardEdgesBoundingBox(self):
        r"""GetBoardEdgesBoundingBox(BOARD self) -> BOX2I"""
        return _pcbnew.BOARD_GetBoardEdgesBoundingBox(self)
 
    def FindFootprintByReference(self, aReference):
        r"""FindFootprintByReference(BOARD self, wxString aReference) -> FOOTPRINT"""
        return _pcbnew.BOARD_FindFootprintByReference(self, aReference)
 
    def FindFootprintByPath(self, aPath):
        r"""FindFootprintByPath(BOARD self, KIID_PATH aPath) -> FOOTPRINT"""
        return _pcbnew.BOARD_FindFootprintByPath(self, aPath)
 
    def GetNetClassAssignmentCandidates(self):
        r"""GetNetClassAssignmentCandidates(BOARD self) -> STRINGSET"""
        return _pcbnew.BOARD_GetNetClassAssignmentCandidates(self)
 
    def SynchronizeNetsAndNetClasses(self, aResetTrackAndViaSizes):
        r"""SynchronizeNetsAndNetClasses(BOARD self, bool aResetTrackAndViaSizes)"""
        return _pcbnew.BOARD_SynchronizeNetsAndNetClasses(self, aResetTrackAndViaSizes)
 
    def SynchronizeProperties(self):
        r"""SynchronizeProperties(BOARD self)"""
        return _pcbnew.BOARD_SynchronizeProperties(self)
 
    def GetClass(self):
        r"""GetClass(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetClass(self)
 
    def SetAreasNetCodesFromNetNames(self):
        r"""SetAreasNetCodesFromNetNames(BOARD self) -> int"""
        return _pcbnew.BOARD_SetAreasNetCodesFromNetNames(self)
 
    def GetArea(self, index):
        r"""GetArea(BOARD self, int index) -> ZONE"""
        return _pcbnew.BOARD_GetArea(self, index)
 
    def GetZoneList(self, aIncludeZonesInFootprints=False):
        r"""GetZoneList(BOARD self, bool aIncludeZonesInFootprints=False) -> std::list< ZONE *,std::allocator< ZONE * > >"""
        return _pcbnew.BOARD_GetZoneList(self, aIncludeZonesInFootprints)
 
    def GetAreaCount(self):
        r"""GetAreaCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetAreaCount(self)
 
    def TestZoneIntersection(self, aZone1, aZone2):
        r"""TestZoneIntersection(BOARD self, ZONE aZone1, ZONE aZone2) -> bool"""
        return _pcbnew.BOARD_TestZoneIntersection(self, aZone1, aZone2)
 
    def GetPad(self, *args):
        r"""
        GetPad(BOARD self, VECTOR2I aPosition, LSET aLayerMask) -> PAD
        GetPad(BOARD self, VECTOR2I aPosition) -> PAD
        GetPad(BOARD self, PCB_TRACK aTrace, ENDPOINT_T aEndPoint) -> PAD
        GetPad(BOARD self, PADS_VEC aPadList, VECTOR2I aPosition, LSET aLayerMask) -> PAD
        """
        return _pcbnew.BOARD_GetPad(self, *args)
 
    def GetSortedPadListByXthenYCoord(self, aVector, aNetCode=-1):
        r"""GetSortedPadListByXthenYCoord(BOARD self, PADS_VEC aVector, int aNetCode=-1)"""
        return _pcbnew.BOARD_GetSortedPadListByXthenYCoord(self, aVector, aNetCode)
 
    def GetTrackLength(self, aTrack):
        r"""GetTrackLength(BOARD self, PCB_TRACK aTrack) -> std::tuple< int,double,double >"""
        return _pcbnew.BOARD_GetTrackLength(self, aTrack)
 
    def TracksInNet(self, aNetCode):
        r"""TracksInNet(BOARD self, int aNetCode) -> TRACKS"""
        return _pcbnew.BOARD_TracksInNet(self, aNetCode)
 
    def GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked=False):
        r"""GetFootprint(BOARD self, VECTOR2I aPosition, PCB_LAYER_ID aActiveLayer, bool aVisibleOnly, bool aIgnoreLocked=False) -> FOOTPRINT"""
        return _pcbnew.BOARD_GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked)
 
    def GetMaxClearanceValue(self):
        r"""GetMaxClearanceValue(BOARD self) -> int"""
        return _pcbnew.BOARD_GetMaxClearanceValue(self)
 
    def MapNets(self, aDestBoard):
        r"""MapNets(BOARD self, BOARD aDestBoard)"""
        return _pcbnew.BOARD_MapNets(self, aDestBoard)
 
    def SanitizeNetcodes(self):
        r"""SanitizeNetcodes(BOARD self)"""
        return _pcbnew.BOARD_SanitizeNetcodes(self)
 
    def AddListener(self, aListener):
        r"""AddListener(BOARD self, BOARD_LISTENER aListener)"""
        return _pcbnew.BOARD_AddListener(self, aListener)
 
    def RemoveListener(self, aListener):
        r"""RemoveListener(BOARD self, BOARD_LISTENER aListener)"""
        return _pcbnew.BOARD_RemoveListener(self, aListener)
 
    def RemoveAllListeners(self):
        r"""RemoveAllListeners(BOARD self)"""
        return _pcbnew.BOARD_RemoveAllListeners(self)
 
    def OnItemChanged(self, aItem):
        r"""OnItemChanged(BOARD self, BOARD_ITEM aItem)"""
        return _pcbnew.BOARD_OnItemChanged(self, aItem)
 
    def OnItemsChanged(self, aItems):
        r"""OnItemsChanged(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aItems)"""
        return _pcbnew.BOARD_OnItemsChanged(self, aItems)
 
    def OnItemsCompositeUpdate(self, aAddedItems, aRemovedItems, aChangedItems):
        r"""OnItemsCompositeUpdate(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aAddedItems, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aRemovedItems, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aChangedItems)"""
        return _pcbnew.BOARD_OnItemsCompositeUpdate(self, aAddedItems, aRemovedItems, aChangedItems)
 
    def OnRatsnestChanged(self):
        r"""OnRatsnestChanged(BOARD self)"""
        return _pcbnew.BOARD_OnRatsnestChanged(self)
 
    def GroupsSanityCheck(self, repair=False):
        r"""GroupsSanityCheck(BOARD self, bool repair=False) -> wxString"""
        return _pcbnew.BOARD_GroupsSanityCheck(self, repair)
 
    def GroupsSanityCheckInternal(self, repair):
        r"""GroupsSanityCheckInternal(BOARD self, bool repair) -> wxString"""
        return _pcbnew.BOARD_GroupsSanityCheckInternal(self, repair)
 
    def GroupLegalOps(self, selection):
        r"""GroupLegalOps(BOARD self, PCB_SELECTION const & selection) -> BOARD::GroupLegalOpsField"""
        return _pcbnew.BOARD_GroupLegalOps(self, selection)
 
    def LegacyTeardrops(self):
        r"""LegacyTeardrops(BOARD self) -> bool"""
        return _pcbnew.BOARD_LegacyTeardrops(self)
 
    def SetLegacyTeardrops(self, aFlag):
        r"""SetLegacyTeardrops(BOARD self, bool aFlag)"""
        return _pcbnew.BOARD_SetLegacyTeardrops(self, aFlag)
 
    def GetEmbeddedFiles(self, *args):
        r"""
        GetEmbeddedFiles(BOARD self) -> EMBEDDED_FILES
        GetEmbeddedFiles(BOARD self) -> EMBEDDED_FILES const *
        """
        return _pcbnew.BOARD_GetEmbeddedFiles(self, *args)
 
    def SetEmbeddedFilesDelegate(self, aDelegate):
        r"""SetEmbeddedFilesDelegate(BOARD self, EMBEDDED_FILES * aDelegate)"""
        return _pcbnew.BOARD_SetEmbeddedFilesDelegate(self, aDelegate)
 
    def GetFonts(self):
        r"""GetFonts(BOARD self) -> std::set< KIFONT::OUTLINE_FONT *,std::less< KIFONT::OUTLINE_FONT * >,std::allocator< KIFONT::OUTLINE_FONT * > >"""
        return _pcbnew.BOARD_GetFonts(self)
 
    def EmbedFonts(self):
        r"""EmbedFonts(BOARD self)"""
        return _pcbnew.BOARD_EmbedFonts(self)
 
    def GetComponentClassManager(self):
        r"""GetComponentClassManager(BOARD self) -> COMPONENT_CLASS_MANAGER &"""
        return _pcbnew.BOARD_GetComponentClassManager(self)
    m_ZoneBBoxCache = property(_pcbnew.BOARD_m_ZoneBBoxCache_get, _pcbnew.BOARD_m_ZoneBBoxCache_set, doc=r"""m_ZoneBBoxCache : std::unordered_map<(p.q(const).ZONE,BOX2I)>""")
    m_maxClearanceValue = property(_pcbnew.BOARD_m_maxClearanceValue_get, _pcbnew.BOARD_m_maxClearanceValue_set, doc=r"""m_maxClearanceValue : std::optional<(int)>""")
    m_SolderMaskBridges = property(_pcbnew.BOARD_m_SolderMaskBridges_get, _pcbnew.BOARD_m_SolderMaskBridges_set, doc=r"""m_SolderMaskBridges : p.ZONE""")
    m_ZoneIsolatedIslandsMap = property(_pcbnew.BOARD_m_ZoneIsolatedIslandsMap_get, _pcbnew.BOARD_m_ZoneIsolatedIslandsMap_set, doc=r"""m_ZoneIsolatedIslandsMap : std::map<(p.ZONE,std::map<(PCB_LAYER_ID,ISOLATED_ISLANDS,std::less<(PCB_LAYER_ID)>,std::allocator<(std::pair<(q(const).PCB_LAYER_ID,ISOLATED_ISLANDS)>)>)>,std::less<(p.ZONE)>,std::allocator<(std::pair<(q(const).p.ZONE,std::map<(PCB_LAYER_ID,ISOLATED_ISLANDS,std::less<(PCB_LAYER_ID)>,std::allocator<(std::pair<(q(const).PCB_LAYER_ID,ISOLATED_ISLANDS)>)>)>)>)>)>""")
 
    def __init__(self, *args):
        this = CreateEmptyBoard()
 
        try:
            self.this.append(this)
        except:
            self.this = this
 
    # Convert these to lists to keep users from using them to delete
    # items in the iterable while looping over it
    def GetFootprints(self):          return list(self.Footprints())
    def GetDrawings(self):            return list(self.Drawings())
    def GetTracks(self):              return list(self.Tracks())
 
    def Save(self,filename):
        return SaveBoard(filename,self)
 
    def GetNetClasses(self):
        return self.GetDesignSettings().m_NetSettings.GetNetclasses()
 
    def GetCurrentNetClassName(self):
        return self.GetDesignSettings().GetCurrentNetClassName()
 
    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.GetNetCode()
 
    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.
        """
 
    # Copy the NETCLASS_MAP so the one in the BOARD isn't modified
    # when we add the Default net class.
        netclassmap = {k:v for k,v in self.GetNetClasses().items()}
        netclassmap['Default'] = self.GetDesignSettings().m_NetSettings.GetDefaultNetclass()
        return netclassmap
 
 
# Register BOARD in _pcbnew:
_pcbnew.BOARD_swigregister(BOARD)
class MAP_STRING_STRING(object):
    r"""Proxy of C++ std::map< wxString,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(MAP_STRING_STRING self) -> SwigPyIterator"""
        return _pcbnew.MAP_STRING_STRING_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(MAP_STRING_STRING self) -> bool"""
        return _pcbnew.MAP_STRING_STRING___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(MAP_STRING_STRING self) -> bool"""
        return _pcbnew.MAP_STRING_STRING___bool__(self)
 
    def __len__(self):
        r"""__len__(MAP_STRING_STRING self) -> std::map< wxString,wxString >::size_type"""
        return _pcbnew.MAP_STRING_STRING___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__(MAP_STRING_STRING self, wxString key) -> wxString"""
        return _pcbnew.MAP_STRING_STRING___getitem__(self, key)
 
    def __delitem__(self, key):
        r"""__delitem__(MAP_STRING_STRING self, wxString key)"""
        return _pcbnew.MAP_STRING_STRING___delitem__(self, key)
 
    def has_key(self, key):
        r"""has_key(MAP_STRING_STRING self, wxString key) -> bool"""
        return _pcbnew.MAP_STRING_STRING_has_key(self, key)
 
    def keys(self):
        r"""keys(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_keys(self)
 
    def values(self):
        r"""values(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_values(self)
 
    def items(self):
        r"""items(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_items(self)
 
    def __contains__(self, key):
        r"""__contains__(MAP_STRING_STRING self, wxString key) -> bool"""
        return _pcbnew.MAP_STRING_STRING___contains__(self, key)
 
    def key_iterator(self):
        r"""key_iterator(MAP_STRING_STRING self) -> SwigPyIterator"""
        return _pcbnew.MAP_STRING_STRING_key_iterator(self)
 
    def value_iterator(self):
        r"""value_iterator(MAP_STRING_STRING self) -> SwigPyIterator"""
        return _pcbnew.MAP_STRING_STRING_value_iterator(self)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(MAP_STRING_STRING self, wxString key)
        __setitem__(MAP_STRING_STRING self, wxString key, wxString x)
        """
        return _pcbnew.MAP_STRING_STRING___setitem__(self, *args)
 
    def asdict(self):
        r"""asdict(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_asdict(self)
 
    def __init__(self, *args):
        r"""
        __init__(MAP_STRING_STRING self, std::less< wxString > const & other) -> MAP_STRING_STRING
        __init__(MAP_STRING_STRING self) -> MAP_STRING_STRING
        __init__(MAP_STRING_STRING self, MAP_STRING_STRING other) -> MAP_STRING_STRING
        """
        _pcbnew.MAP_STRING_STRING_swiginit(self, _pcbnew.new_MAP_STRING_STRING(*args))
 
    def empty(self):
        r"""empty(MAP_STRING_STRING self) -> bool"""
        return _pcbnew.MAP_STRING_STRING_empty(self)
 
    def size(self):
        r"""size(MAP_STRING_STRING self) -> std::map< wxString,wxString >::size_type"""
        return _pcbnew.MAP_STRING_STRING_size(self)
 
    def swap(self, v):
        r"""swap(MAP_STRING_STRING self, MAP_STRING_STRING v)"""
        return _pcbnew.MAP_STRING_STRING_swap(self, v)
 
    def begin(self):
        r"""begin(MAP_STRING_STRING self) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_begin(self)
 
    def end(self):
        r"""end(MAP_STRING_STRING self) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_end(self)
 
    def rbegin(self):
        r"""rbegin(MAP_STRING_STRING self) -> std::map< wxString,wxString >::reverse_iterator"""
        return _pcbnew.MAP_STRING_STRING_rbegin(self)
 
    def rend(self):
        r"""rend(MAP_STRING_STRING self) -> std::map< wxString,wxString >::reverse_iterator"""
        return _pcbnew.MAP_STRING_STRING_rend(self)
 
    def clear(self):
        r"""clear(MAP_STRING_STRING self)"""
        return _pcbnew.MAP_STRING_STRING_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(MAP_STRING_STRING self) -> std::map< wxString,wxString >::allocator_type"""
        return _pcbnew.MAP_STRING_STRING_get_allocator(self)
 
    def count(self, x):
        r"""count(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::size_type"""
        return _pcbnew.MAP_STRING_STRING_count(self, x)
 
    def erase(self, *args):
        r"""
        erase(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::size_type
        erase(MAP_STRING_STRING self, std::map< wxString,wxString >::iterator position)
        erase(MAP_STRING_STRING self, std::map< wxString,wxString >::iterator first, std::map< wxString,wxString >::iterator last)
        """
        return _pcbnew.MAP_STRING_STRING_erase(self, *args)
 
    def find(self, x):
        r"""find(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_find(self, x)
 
    def lower_bound(self, x):
        r"""lower_bound(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_lower_bound(self, x)
 
    def upper_bound(self, x):
        r"""upper_bound(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_MAP_STRING_STRING
 
# Register MAP_STRING_STRING in _pcbnew:
_pcbnew.MAP_STRING_STRING_swigregister(MAP_STRING_STRING)
DO_NOT_INCLUDE_NPTH = _pcbnew.DO_NOT_INCLUDE_NPTH
 
INCLUDE_NPTH = _pcbnew.INCLUDE_NPTH
 
FP_THROUGH_HOLE = _pcbnew.FP_THROUGH_HOLE
 
FP_SMD = _pcbnew.FP_SMD
 
FP_EXCLUDE_FROM_POS_FILES = _pcbnew.FP_EXCLUDE_FROM_POS_FILES
 
FP_EXCLUDE_FROM_BOM = _pcbnew.FP_EXCLUDE_FROM_BOM
 
FP_BOARD_ONLY = _pcbnew.FP_BOARD_ONLY
 
FP_JUST_ADDED = _pcbnew.FP_JUST_ADDED
 
FP_ALLOW_SOLDERMASK_BRIDGES = _pcbnew.FP_ALLOW_SOLDERMASK_BRIDGES
 
FP_ALLOW_MISSING_COURTYARD = _pcbnew.FP_ALLOW_MISSING_COURTYARD
 
FP_DNP = _pcbnew.FP_DNP
 
class FP_3DMODEL(object):
    r"""Proxy of C++ FP_3DMODEL 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__(FP_3DMODEL self) -> FP_3DMODEL"""
        _pcbnew.FP_3DMODEL_swiginit(self, _pcbnew.new_FP_3DMODEL())
    m_Scale = property(_pcbnew.FP_3DMODEL_m_Scale_get, _pcbnew.FP_3DMODEL_m_Scale_set, doc=r"""m_Scale : VECTOR3D""")
    m_Rotation = property(_pcbnew.FP_3DMODEL_m_Rotation_get, _pcbnew.FP_3DMODEL_m_Rotation_set, doc=r"""m_Rotation : VECTOR3D""")
    m_Offset = property(_pcbnew.FP_3DMODEL_m_Offset_get, _pcbnew.FP_3DMODEL_m_Offset_set, doc=r"""m_Offset : VECTOR3D""")
    m_Opacity = property(_pcbnew.FP_3DMODEL_m_Opacity_get, _pcbnew.FP_3DMODEL_m_Opacity_set, doc=r"""m_Opacity : double""")
    m_Filename = property(_pcbnew.FP_3DMODEL_m_Filename_get, _pcbnew.FP_3DMODEL_m_Filename_set, doc=r"""m_Filename : wxString""")
    m_Show = property(_pcbnew.FP_3DMODEL_m_Show_get, _pcbnew.FP_3DMODEL_m_Show_set, doc=r"""m_Show : bool""")
 
    def __eq__(self, aOther):
        r"""__eq__(FP_3DMODEL self, FP_3DMODEL aOther) -> bool"""
        return _pcbnew.FP_3DMODEL___eq__(self, aOther)
    __swig_destroy__ = _pcbnew.delete_FP_3DMODEL
 
# Register FP_3DMODEL in _pcbnew:
_pcbnew.FP_3DMODEL_swigregister(FP_3DMODEL)
class FOOTPRINT(BOARD_ITEM_CONTAINER):
    r"""Proxy of C++ FOOTPRINT 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__(FOOTPRINT self, BOARD parent) -> FOOTPRINT
        __init__(FOOTPRINT self, FOOTPRINT aFootprint) -> FOOTPRINT
        __init__(FOOTPRINT self, FOOTPRINT aFootprint) -> FOOTPRINT
        """
        _pcbnew.FOOTPRINT_swiginit(self, _pcbnew.new_FOOTPRINT(*args))
    __swig_destroy__ = _pcbnew.delete_FOOTPRINT
 
    def Serialize(self, aContainer):
        r"""Serialize(FOOTPRINT self, google::protobuf::Any & aContainer)"""
        return _pcbnew.FOOTPRINT_Serialize(self, aContainer)
 
    def Deserialize(self, aContainer):
        r"""Deserialize(FOOTPRINT self, google::protobuf::Any const & aContainer) -> bool"""
        return _pcbnew.FOOTPRINT_Deserialize(self, aContainer)
 
    @staticmethod
    def ClassOf(aItem):
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.FOOTPRINT_ClassOf(aItem)
 
    def InvalidateGeometryCaches(self):
        r"""InvalidateGeometryCaches(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_InvalidateGeometryCaches(self)
 
    def GetPrivateLayers(self):
        r"""GetPrivateLayers(FOOTPRINT self) -> LSET"""
        return _pcbnew.FOOTPRINT_GetPrivateLayers(self)
 
    def SetPrivateLayers(self, aLayers):
        r"""SetPrivateLayers(FOOTPRINT self, LSET aLayers)"""
        return _pcbnew.FOOTPRINT_SetPrivateLayers(self, aLayers)
 
    def AddNative(self, *args):
        r"""AddNative(FOOTPRINT self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT, bool aSkipConnectivity=False)"""
        return _pcbnew.FOOTPRINT_AddNative(self, *args)
 
    def RemoveNative(self, *args):
        r"""RemoveNative(FOOTPRINT self, BOARD_ITEM aItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.FOOTPRINT_RemoveNative(self, *args)
 
    def ClearAllNets(self):
        r"""ClearAllNets(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_ClearAllNets(self)
 
    def FixUuids(self):
        r"""FixUuids(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_FixUuids(self)
 
    def GetFpPadsLocalBbox(self):
        r"""GetFpPadsLocalBbox(FOOTPRINT self) -> BOX2I"""
        return _pcbnew.FOOTPRINT_GetFpPadsLocalBbox(self)
 
    def GetBoundingHull(self):
        r"""GetBoundingHull(FOOTPRINT self) -> SHAPE_POLY_SET"""
        return _pcbnew.FOOTPRINT_GetBoundingHull(self)
 
    def TextOnly(self):
        r"""TextOnly(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_TextOnly(self)
 
    def GetLayerBoundingBox(self, aLayers):
        r"""GetLayerBoundingBox(FOOTPRINT self, LSET aLayers) -> BOX2I"""
        return _pcbnew.FOOTPRINT_GetLayerBoundingBox(self, aLayers)
 
    def Pads(self, *args):
        r"""
        Pads(FOOTPRINT self) -> PADS
        Pads(FOOTPRINT self) -> PADS
        """
        return _pcbnew.FOOTPRINT_Pads(self, *args)
 
    def GraphicalItems(self, *args):
        r"""
        GraphicalItems(FOOTPRINT self) -> DRAWINGS
        GraphicalItems(FOOTPRINT self) -> DRAWINGS
        """
        return _pcbnew.FOOTPRINT_GraphicalItems(self, *args)
 
    def Zones(self, *args):
        r"""
        Zones(FOOTPRINT self) -> ZONES
        Zones(FOOTPRINT self) -> ZONES
        """
        return _pcbnew.FOOTPRINT_Zones(self, *args)
 
    def Groups(self, *args):
        r"""
        Groups(FOOTPRINT self) -> GROUPS
        Groups(FOOTPRINT self) -> GROUPS
        """
        return _pcbnew.FOOTPRINT_Groups(self, *args)
 
    def HasThroughHolePads(self):
        r"""HasThroughHolePads(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_HasThroughHolePads(self)
 
    def Models(self, *args):
        r"""
        Models(FOOTPRINT self) -> VECTOR_FP_3DMODEL
        Models(FOOTPRINT self) -> VECTOR_FP_3DMODEL
        """
        return _pcbnew.FOOTPRINT_Models(self, *args)
 
    def SetOrientation(self, aNewAngle):
        r"""SetOrientation(FOOTPRINT self, EDA_ANGLE aNewAngle)"""
        return _pcbnew.FOOTPRINT_SetOrientation(self, aNewAngle)
 
    def GetOrientation(self):
        r"""GetOrientation(FOOTPRINT self) -> EDA_ANGLE"""
        return _pcbnew.FOOTPRINT_GetOrientation(self)
 
    def SetLayerAndFlip(self, aLayer):
        r"""SetLayerAndFlip(FOOTPRINT self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.FOOTPRINT_SetLayerAndFlip(self, aLayer)
 
    def SetOrientationDegrees(self, aOrientation):
        r"""SetOrientationDegrees(FOOTPRINT self, double aOrientation)"""
        return _pcbnew.FOOTPRINT_SetOrientationDegrees(self, aOrientation)
 
    def GetOrientationDegrees(self):
        r"""GetOrientationDegrees(FOOTPRINT self) -> double"""
        return _pcbnew.FOOTPRINT_GetOrientationDegrees(self)
 
    def GetFPID(self):
        r"""GetFPID(FOOTPRINT self) -> LIB_ID"""
        return _pcbnew.FOOTPRINT_GetFPID(self)
 
    def SetFPID(self, aFPID):
        r"""SetFPID(FOOTPRINT self, LIB_ID aFPID)"""
        return _pcbnew.FOOTPRINT_SetFPID(self, aFPID)
 
    def GetFPIDAsString(self):
        r"""GetFPIDAsString(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetFPIDAsString(self)
 
    def SetFPIDAsString(self, aFPID):
        r"""SetFPIDAsString(FOOTPRINT self, wxString aFPID)"""
        return _pcbnew.FOOTPRINT_SetFPIDAsString(self, aFPID)
 
    def GetLibDescription(self):
        r"""GetLibDescription(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetLibDescription(self)
 
    def SetLibDescription(self, aDesc):
        r"""SetLibDescription(FOOTPRINT self, wxString aDesc)"""
        return _pcbnew.FOOTPRINT_SetLibDescription(self, aDesc)
 
    def GetKeywords(self):
        r"""GetKeywords(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetKeywords(self)
 
    def SetKeywords(self, aKeywords):
        r"""SetKeywords(FOOTPRINT self, wxString aKeywords)"""
        return _pcbnew.FOOTPRINT_SetKeywords(self, aKeywords)
 
    def GetPath(self):
        r"""GetPath(FOOTPRINT self) -> KIID_PATH"""
        return _pcbnew.FOOTPRINT_GetPath(self)
 
    def SetPath(self, aPath):
        r"""SetPath(FOOTPRINT self, KIID_PATH aPath)"""
        return _pcbnew.FOOTPRINT_SetPath(self, aPath)
 
    def GetSheetname(self):
        r"""GetSheetname(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetSheetname(self)
 
    def SetSheetname(self, aSheetname):
        r"""SetSheetname(FOOTPRINT self, wxString aSheetname)"""
        return _pcbnew.FOOTPRINT_SetSheetname(self, aSheetname)
 
    def GetSheetfile(self):
        r"""GetSheetfile(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetSheetfile(self)
 
    def SetSheetfile(self, aSheetfile):
        r"""SetSheetfile(FOOTPRINT self, wxString aSheetfile)"""
        return _pcbnew.FOOTPRINT_SetSheetfile(self, aSheetfile)
 
    def GetFilters(self):
        r"""GetFilters(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetFilters(self)
 
    def SetFilters(self, aFilters):
        r"""SetFilters(FOOTPRINT self, wxString aFilters)"""
        return _pcbnew.FOOTPRINT_SetFilters(self, aFilters)
 
    def SetLocalClearance(self, aClearance):
        r"""SetLocalClearance(FOOTPRINT self, std::optional< int > aClearance)"""
        return _pcbnew.FOOTPRINT_SetLocalClearance(self, aClearance)
 
    def GetLocalSolderMaskMargin(self):
        r"""GetLocalSolderMaskMargin(FOOTPRINT self) -> std::optional< int >"""
        return _pcbnew.FOOTPRINT_GetLocalSolderMaskMargin(self)
 
    def SetLocalSolderMaskMargin(self, aMargin):
        r"""SetLocalSolderMaskMargin(FOOTPRINT self, std::optional< int > aMargin)"""
        return _pcbnew.FOOTPRINT_SetLocalSolderMaskMargin(self, aMargin)
 
    def GetLocalSolderPasteMargin(self):
        r"""GetLocalSolderPasteMargin(FOOTPRINT self) -> std::optional< int >"""
        return _pcbnew.FOOTPRINT_GetLocalSolderPasteMargin(self)
 
    def SetLocalSolderPasteMargin(self, aMargin):
        r"""SetLocalSolderPasteMargin(FOOTPRINT self, std::optional< int > aMargin)"""
        return _pcbnew.FOOTPRINT_SetLocalSolderPasteMargin(self, aMargin)
 
    def GetLocalSolderPasteMarginRatio(self):
        r"""GetLocalSolderPasteMarginRatio(FOOTPRINT self) -> std::optional< double >"""
        return _pcbnew.FOOTPRINT_GetLocalSolderPasteMarginRatio(self)
 
    def SetLocalSolderPasteMarginRatio(self, aRatio):
        r"""SetLocalSolderPasteMarginRatio(FOOTPRINT self, std::optional< double > aRatio)"""
        return _pcbnew.FOOTPRINT_SetLocalSolderPasteMarginRatio(self, aRatio)
 
    def SetLocalZoneConnection(self, aType):
        r"""SetLocalZoneConnection(FOOTPRINT self, ZONE_CONNECTION aType)"""
        return _pcbnew.FOOTPRINT_SetLocalZoneConnection(self, aType)
 
    def GetLocalZoneConnection(self):
        r"""GetLocalZoneConnection(FOOTPRINT self) -> ZONE_CONNECTION"""
        return _pcbnew.FOOTPRINT_GetLocalZoneConnection(self)
 
    def GetAttributes(self):
        r"""GetAttributes(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetAttributes(self)
 
    def SetAttributes(self, aAttributes):
        r"""SetAttributes(FOOTPRINT self, int aAttributes)"""
        return _pcbnew.FOOTPRINT_SetAttributes(self, aAttributes)
 
    def SetFlag(self, aFlag):
        r"""SetFlag(FOOTPRINT self, int aFlag)"""
        return _pcbnew.FOOTPRINT_SetFlag(self, aFlag)
 
    def IncrementFlag(self):
        r"""IncrementFlag(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_IncrementFlag(self)
 
    def GetFlag(self):
        r"""GetFlag(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetFlag(self)
 
    def IsNetTie(self):
        r"""IsNetTie(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsNetTie(self)
 
    def GetLocalClearance(self, *args):
        r"""
        GetLocalClearance(FOOTPRINT self) -> std::optional< int >
        GetLocalClearance(FOOTPRINT self, wxString aSource) -> std::optional< int >
        """
        return _pcbnew.FOOTPRINT_GetLocalClearance(self, *args)
 
    def GetClearanceOverrides(self, aSource):
        r"""GetClearanceOverrides(FOOTPRINT self, wxString aSource) -> std::optional< int >"""
        return _pcbnew.FOOTPRINT_GetClearanceOverrides(self, aSource)
 
    def GetZoneConnectionOverrides(self, aSource):
        r"""GetZoneConnectionOverrides(FOOTPRINT self, wxString aSource) -> ZONE_CONNECTION"""
        return _pcbnew.FOOTPRINT_GetZoneConnectionOverrides(self, aSource)
 
    def GetNetTiePadGroups(self):
        r"""GetNetTiePadGroups(FOOTPRINT self) -> std::vector< wxString,std::allocator< wxString > > const &"""
        return _pcbnew.FOOTPRINT_GetNetTiePadGroups(self)
 
    def ClearNetTiePadGroups(self):
        r"""ClearNetTiePadGroups(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_ClearNetTiePadGroups(self)
 
    def AddNetTiePadGroup(self, aGroup):
        r"""AddNetTiePadGroup(FOOTPRINT self, wxString aGroup)"""
        return _pcbnew.FOOTPRINT_AddNetTiePadGroup(self, aGroup)
 
    def MapPadNumbersToNetTieGroups(self):
        r"""MapPadNumbersToNetTieGroups(FOOTPRINT self) -> std::map< wxString,int,std::less< wxString >,std::allocator< std::pair< wxString const,int > > >"""
        return _pcbnew.FOOTPRINT_MapPadNumbersToNetTieGroups(self)
 
    def GetNetTiePads(self, aPad):
        r"""GetNetTiePads(FOOTPRINT self, PAD aPad) -> PADS_VEC"""
        return _pcbnew.FOOTPRINT_GetNetTiePads(self, aPad)
 
    def GetLikelyAttribute(self):
        r"""GetLikelyAttribute(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetLikelyAttribute(self)
 
    def MoveAnchorPosition(self, aMoveVector):
        r"""MoveAnchorPosition(FOOTPRINT self, VECTOR2I aMoveVector)"""
        return _pcbnew.FOOTPRINT_MoveAnchorPosition(self, aMoveVector)
 
    def IsFlipped(self):
        r"""IsFlipped(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsFlipped(self)
 
    def GetSide(self):
        r"""GetSide(FOOTPRINT self) -> PCB_LAYER_ID"""
        return _pcbnew.FOOTPRINT_GetSide(self)
 
    def IsConflicting(self):
        r"""IsConflicting(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsConflicting(self)
 
    def IsPlaced(self):
        r"""IsPlaced(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsPlaced(self)
 
    def SetIsPlaced(self, isPlaced):
        r"""SetIsPlaced(FOOTPRINT self, bool isPlaced)"""
        return _pcbnew.FOOTPRINT_SetIsPlaced(self, isPlaced)
 
    def NeedsPlaced(self):
        r"""NeedsPlaced(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_NeedsPlaced(self)
 
    def SetNeedsPlaced(self, needsPlaced):
        r"""SetNeedsPlaced(FOOTPRINT self, bool needsPlaced)"""
        return _pcbnew.FOOTPRINT_SetNeedsPlaced(self, needsPlaced)
 
    def LegacyPadsLocked(self):
        r"""LegacyPadsLocked(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_LegacyPadsLocked(self)
 
    def CheckFootprintAttributes(self, aErrorHandler):
        r"""CheckFootprintAttributes(FOOTPRINT self, std::function< void (wxString const &) > const & aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckFootprintAttributes(self, aErrorHandler)
 
    def CheckPads(self, aUnitsProvider, aErrorHandler):
        r"""CheckPads(FOOTPRINT self, UNITS_PROVIDER aUnitsProvider, std::function< void (PAD const *,int,wxString const &) > const & aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckPads(self, aUnitsProvider, aErrorHandler)
 
    def CheckShortingPads(self, aErrorHandler):
        r"""CheckShortingPads(FOOTPRINT self, std::function< void (PAD const *,PAD const *,int,VECTOR2I const &) > const & aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckShortingPads(self, aErrorHandler)
 
    def CheckNetTies(self, aErrorHandler):
        r"""CheckNetTies(FOOTPRINT self, std::function< void (BOARD_ITEM const *,BOARD_ITEM const *,BOARD_ITEM const *,VECTOR2I const &) > const & aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckNetTies(self, aErrorHandler)
 
    def CheckNetTiePadGroups(self, aErrorHandler):
        r"""CheckNetTiePadGroups(FOOTPRINT self, std::function< void (wxString const &) > const & aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckNetTiePadGroups(self, aErrorHandler)
 
    def CheckClippedSilk(self, aErrorHandler):
        r"""CheckClippedSilk(FOOTPRINT self, std::function< void (BOARD_ITEM *,BOARD_ITEM *,VECTOR2I const &) > const & aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckClippedSilk(self, aErrorHandler)
 
    def BuildNetTieCache(self):
        r"""BuildNetTieCache(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_BuildNetTieCache(self)
 
    def GetNetTieCache(self, aItem):
        r"""GetNetTieCache(FOOTPRINT self, BOARD_ITEM aItem) -> std::set< int,std::less< int >,std::allocator< int > > const &"""
        return _pcbnew.FOOTPRINT_GetNetTieCache(self, aItem)
 
    def TransformPadsToPolySet(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aSkipNPTHPadsWihNoCopper=False):
        r"""TransformPadsToPolySet(FOOTPRINT self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aSkipNPTHPadsWihNoCopper=False)"""
        return _pcbnew.FOOTPRINT_TransformPadsToPolySet(self, aBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aSkipNPTHPadsWihNoCopper)
 
    def TransformFPShapesToPolySet(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, aIncludeText=True, aIncludeShapes=True, aIncludePrivateItems=False):
        r"""TransformFPShapesToPolySet(FOOTPRINT self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool aIncludeText=True, bool aIncludeShapes=True, bool aIncludePrivateItems=False)"""
        return _pcbnew.FOOTPRINT_TransformFPShapesToPolySet(self, aBuffer, aLayer, aClearance, aError, aErrorLoc, aIncludeText, aIncludeShapes, aIncludePrivateItems)
 
    def TransformFPTextToPolySet(self, aBuffer, aLayer, aClearance, aError, aErrorLoc):
        r"""TransformFPTextToPolySet(FOOTPRINT self, SHAPE_POLY_SET aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.FOOTPRINT_TransformFPTextToPolySet(self, aBuffer, aLayer, aClearance, aError, aErrorLoc)
 
    def GetContextualTextVars(self, aVars):
        r"""GetContextualTextVars(FOOTPRINT self, wxArrayString * aVars)"""
        return _pcbnew.FOOTPRINT_GetContextualTextVars(self, aVars)
 
    def ResolveTextVar(self, token, aDepth=0):
        r"""ResolveTextVar(FOOTPRINT self, wxString token, int aDepth=0) -> bool"""
        return _pcbnew.FOOTPRINT_ResolveTextVar(self, token, aDepth)
 
    def HitTestAccurate(self, aPosition, aAccuracy=0):
        r"""HitTestAccurate(FOOTPRINT self, VECTOR2I aPosition, int aAccuracy=0) -> bool"""
        return _pcbnew.FOOTPRINT_HitTestAccurate(self, aPosition, aAccuracy)
 
    def HitTest(self, *args):
        r"""
        HitTest(FOOTPRINT self, VECTOR2I aPosition, int aAccuracy=0) -> bool
        HitTest(FOOTPRINT self, BOX2I aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.FOOTPRINT_HitTest(self, *args)
 
    def HitTestOnLayer(self, *args):
        r"""
        HitTestOnLayer(FOOTPRINT self, VECTOR2I aPosition, PCB_LAYER_ID aLayer, int aAccuracy=0) -> bool
        HitTestOnLayer(FOOTPRINT self, BOX2I aRect, bool aContained, PCB_LAYER_ID aLayer, int aAccuracy=0) -> bool
        """
        return _pcbnew.FOOTPRINT_HitTestOnLayer(self, *args)
 
    def GetReference(self):
        r"""GetReference(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetReference(self)
 
    def SetReference(self, aReference):
        r"""SetReference(FOOTPRINT self, wxString aReference)"""
        return _pcbnew.FOOTPRINT_SetReference(self, aReference)
 
    def GetReferenceAsString(self):
        r"""GetReferenceAsString(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetReferenceAsString(self)
 
    def IncrementReference(self, aDelta):
        r"""IncrementReference(FOOTPRINT self, int aDelta)"""
        return _pcbnew.FOOTPRINT_IncrementReference(self, aDelta)
 
    def GetValue(self):
        r"""GetValue(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetValue(self)
 
    def SetValue(self, aValue):
        r"""SetValue(FOOTPRINT self, wxString aValue)"""
        return _pcbnew.FOOTPRINT_SetValue(self, aValue)
 
    def GetValueAsString(self):
        r"""GetValueAsString(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetValueAsString(self)
 
    def Value(self, *args):
        r"""
        Value(FOOTPRINT self) -> PCB_FIELD
        Value(FOOTPRINT self) -> PCB_FIELD
        """
        return _pcbnew.FOOTPRINT_Value(self, *args)
 
    def Reference(self, *args):
        r"""
        Reference(FOOTPRINT self) -> PCB_FIELD
        Reference(FOOTPRINT self) -> PCB_FIELD
        """
        return _pcbnew.FOOTPRINT_Reference(self, *args)
 
    def GetField(self, *args):
        r"""
        GetField(FOOTPRINT self, MANDATORY_FIELD_T aFieldType) -> PCB_FIELD
        GetField(FOOTPRINT self, MANDATORY_FIELD_T aFieldNdx) -> PCB_FIELD
        """
        return _pcbnew.FOOTPRINT_GetField(self, *args)
 
    def GetFieldById(self, aFieldId):
        r"""GetFieldById(FOOTPRINT self, int aFieldId) -> PCB_FIELD"""
        return _pcbnew.FOOTPRINT_GetFieldById(self, aFieldId)
 
    def GetFieldByName(self, aFieldName):
        r"""GetFieldByName(FOOTPRINT self, wxString aFieldName) -> PCB_FIELD"""
        return _pcbnew.FOOTPRINT_GetFieldByName(self, aFieldName)
 
    def HasFieldByName(self, aFieldName):
        r"""HasFieldByName(FOOTPRINT self, wxString aFieldName) -> bool"""
        return _pcbnew.FOOTPRINT_HasFieldByName(self, aFieldName)
 
    def GetFieldText(self, aFieldName):
        r"""GetFieldText(FOOTPRINT self, wxString aFieldName) -> wxString"""
        return _pcbnew.FOOTPRINT_GetFieldText(self, aFieldName)
 
    def GetFields(self, *args):
        r"""
        GetFields(FOOTPRINT self, PCB_FIELD_VEC aVector, bool aVisibleOnly)
        GetFields(FOOTPRINT self, bool aVisibleOnly=False) -> PCB_FIELD_VEC
        """
        return _pcbnew.FOOTPRINT_GetFields(self, *args)
 
    def ClearFields(self):
        r"""ClearFields(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_ClearFields(self)
 
    def AddField(self, aField):
        r"""AddField(FOOTPRINT self, PCB_FIELD aField) -> PCB_FIELD"""
        return _pcbnew.FOOTPRINT_AddField(self, aField)
 
    def RemoveField(self, aFieldName):
        r"""RemoveField(FOOTPRINT self, wxString aFieldName)"""
        return _pcbnew.FOOTPRINT_RemoveField(self, aFieldName)
 
    def GetNextFieldId(self):
        r"""GetNextFieldId(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetNextFieldId(self)
 
    def ApplyDefaultSettings(self, board, aStyleFields, aStyleText, aStyleShapes):
        r"""ApplyDefaultSettings(FOOTPRINT self, BOARD board, bool aStyleFields, bool aStyleText, bool aStyleShapes)"""
        return _pcbnew.FOOTPRINT_ApplyDefaultSettings(self, board, aStyleFields, aStyleText, aStyleShapes)
 
    def IsBoardOnly(self):
        r"""IsBoardOnly(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsBoardOnly(self)
 
    def SetBoardOnly(self, aIsBoardOnly=True):
        r"""SetBoardOnly(FOOTPRINT self, bool aIsBoardOnly=True)"""
        return _pcbnew.FOOTPRINT_SetBoardOnly(self, aIsBoardOnly)
 
    def IsExcludedFromPosFiles(self):
        r"""IsExcludedFromPosFiles(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsExcludedFromPosFiles(self)
 
    def SetExcludedFromPosFiles(self, aExclude=True):
        r"""SetExcludedFromPosFiles(FOOTPRINT self, bool aExclude=True)"""
        return _pcbnew.FOOTPRINT_SetExcludedFromPosFiles(self, aExclude)
 
    def IsExcludedFromBOM(self):
        r"""IsExcludedFromBOM(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsExcludedFromBOM(self)
 
    def SetExcludedFromBOM(self, aExclude=True):
        r"""SetExcludedFromBOM(FOOTPRINT self, bool aExclude=True)"""
        return _pcbnew.FOOTPRINT_SetExcludedFromBOM(self, aExclude)
 
    def AllowMissingCourtyard(self):
        r"""AllowMissingCourtyard(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_AllowMissingCourtyard(self)
 
    def SetAllowMissingCourtyard(self, aAllow=True):
        r"""SetAllowMissingCourtyard(FOOTPRINT self, bool aAllow=True)"""
        return _pcbnew.FOOTPRINT_SetAllowMissingCourtyard(self, aAllow)
 
    def IsDNP(self):
        r"""IsDNP(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsDNP(self)
 
    def SetDNP(self, aDNP=True):
        r"""SetDNP(FOOTPRINT self, bool aDNP=True)"""
        return _pcbnew.FOOTPRINT_SetDNP(self, aDNP)
 
    def SetFileFormatVersionAtLoad(self, aVersion):
        r"""SetFileFormatVersionAtLoad(FOOTPRINT self, int aVersion)"""
        return _pcbnew.FOOTPRINT_SetFileFormatVersionAtLoad(self, aVersion)
 
    def GetFileFormatVersionAtLoad(self):
        r"""GetFileFormatVersionAtLoad(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetFileFormatVersionAtLoad(self)
 
    def FindPadByNumber(self, aPadNumber, aSearchAfterMe=None):
        r"""FindPadByNumber(FOOTPRINT self, wxString aPadNumber, PAD aSearchAfterMe=None) -> PAD"""
        return _pcbnew.FOOTPRINT_FindPadByNumber(self, aPadNumber, aSearchAfterMe)
 
    def GetPad(self, *args):
        r"""GetPad(FOOTPRINT self, VECTOR2I aPosition, LSET aLayerMask=LSET::AllLayersMask()) -> PAD"""
        return _pcbnew.FOOTPRINT_GetPad(self, *args)
 
    def GetPads(self, aPadNumber, aIgnore=None):
        r"""GetPads(FOOTPRINT self, wxString aPadNumber, PAD aIgnore=None) -> std::vector< PAD const *,std::allocator< PAD const * > >"""
        return _pcbnew.FOOTPRINT_GetPads(self, aPadNumber, aIgnore)
 
    def GetPadCount(self, *args):
        r"""GetPadCount(FOOTPRINT self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.FOOTPRINT_GetPadCount(self, *args)
 
    def GetUniquePadCount(self, *args):
        r"""GetUniquePadCount(FOOTPRINT self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.FOOTPRINT_GetUniquePadCount(self, *args)
 
    def GetUniquePadNumbers(self, *args):
        r"""GetUniquePadNumbers(FOOTPRINT self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> STRINGSET"""
        return _pcbnew.FOOTPRINT_GetUniquePadNumbers(self, *args)
 
    def GetNextPadNumber(self, aLastPadName):
        r"""GetNextPadNumber(FOOTPRINT self, wxString aLastPadName) -> wxString"""
        return _pcbnew.FOOTPRINT_GetNextPadNumber(self, aLastPadName)
 
    def AutoPositionFields(self):
        r"""AutoPositionFields(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_AutoPositionFields(self)
 
    def GetTypeName(self):
        r"""GetTypeName(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetTypeName(self)
 
    def GetArea(self, aPadding=0):
        r"""GetArea(FOOTPRINT self, int aPadding=0) -> double"""
        return _pcbnew.FOOTPRINT_GetArea(self, aPadding)
 
    def GetLink(self):
        r"""GetLink(FOOTPRINT self) -> KIID"""
        return _pcbnew.FOOTPRINT_GetLink(self)
 
    def SetLink(self, aLink):
        r"""SetLink(FOOTPRINT self, KIID aLink)"""
        return _pcbnew.FOOTPRINT_SetLink(self, aLink)
 
    def DuplicateItem(self, aItem, aAddToFootprint=False):
        r"""DuplicateItem(FOOTPRINT self, BOARD_ITEM aItem, bool aAddToFootprint=False) -> BOARD_ITEM"""
        return _pcbnew.FOOTPRINT_DuplicateItem(self, aItem, aAddToFootprint)
 
    def Add3DModel(self, a3DModel):
        r"""Add3DModel(FOOTPRINT self, FP_3DMODEL a3DModel)"""
        return _pcbnew.FOOTPRINT_Add3DModel(self, a3DModel)
 
    def GetClass(self):
        r"""GetClass(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetClass(self)
 
    def RunOnDescendants(self, aFunction, aDepth=0):
        r"""RunOnDescendants(FOOTPRINT self, std::function< void (BOARD_ITEM *) > const & aFunction, int aDepth=0)"""
        return _pcbnew.FOOTPRINT_RunOnDescendants(self, aFunction, aDepth)
 
    def ViewGetLOD(self, aLayer, aView):
        r"""ViewGetLOD(FOOTPRINT self, int aLayer, KIGFX::VIEW const * aView) -> double"""
        return _pcbnew.FOOTPRINT_ViewGetLOD(self, aLayer, aView)
 
    @staticmethod
    def IsLibNameValid(aName):
        r"""IsLibNameValid(wxString aName) -> bool"""
        return _pcbnew.FOOTPRINT_IsLibNameValid(aName)
 
    @staticmethod
    def StringLibNameInvalidChars(aUserReadable):
        r"""StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
        return _pcbnew.FOOTPRINT_StringLibNameInvalidChars(aUserReadable)
 
    def FootprintNeedsUpdate(self, aLibFP, aCompareFlags=0, aReporter=None):
        r"""FootprintNeedsUpdate(FOOTPRINT self, FOOTPRINT aLibFP, int aCompareFlags=0, REPORTER * aReporter=None) -> bool"""
        return _pcbnew.FOOTPRINT_FootprintNeedsUpdate(self, aLibFP, aCompareFlags, aReporter)
 
    def SetInitialComments(self, aInitialComments):
        r"""SetInitialComments(FOOTPRINT self, wxArrayString * aInitialComments)"""
        return _pcbnew.FOOTPRINT_SetInitialComments(self, aInitialComments)
 
    def CoverageRatio(self, aCollector):
        r"""CoverageRatio(FOOTPRINT self, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.FOOTPRINT_CoverageRatio(self, aCollector)
 
    @staticmethod
    def GetCoverageArea(aItem, aCollector):
        r"""GetCoverageArea(BOARD_ITEM aItem, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.FOOTPRINT_GetCoverageArea(aItem, aCollector)
 
    def GetInitialComments(self):
        r"""GetInitialComments(FOOTPRINT self) -> wxArrayString const *"""
        return _pcbnew.FOOTPRINT_GetInitialComments(self)
 
    def GetCourtyard(self, aLayer):
        r"""GetCourtyard(FOOTPRINT self, PCB_LAYER_ID aLayer) -> SHAPE_POLY_SET"""
        return _pcbnew.FOOTPRINT_GetCourtyard(self, aLayer)
 
    def GetCachedCourtyard(self, aLayer):
        r"""GetCachedCourtyard(FOOTPRINT self, PCB_LAYER_ID aLayer) -> SHAPE_POLY_SET"""
        return _pcbnew.FOOTPRINT_GetCachedCourtyard(self, aLayer)
 
    def BuildCourtyardCaches(self, aErrorHandler=None):
        r"""BuildCourtyardCaches(FOOTPRINT self, OUTLINE_ERROR_HANDLER * aErrorHandler=None)"""
        return _pcbnew.FOOTPRINT_BuildCourtyardCaches(self, aErrorHandler)
 
    def GetEffectiveShape(self, *args):
        r"""GetEffectiveShape(FOOTPRINT self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.FOOTPRINT_GetEffectiveShape(self, *args)
 
    def GetEmbeddedFiles(self, *args):
        r"""
        GetEmbeddedFiles(FOOTPRINT self) -> EMBEDDED_FILES
        GetEmbeddedFiles(FOOTPRINT self) -> EMBEDDED_FILES const *
        """
        return _pcbnew.FOOTPRINT_GetEmbeddedFiles(self, *args)
 
    def GetFonts(self):
        r"""GetFonts(FOOTPRINT self) -> std::set< KIFONT::OUTLINE_FONT *,std::less< KIFONT::OUTLINE_FONT * >,std::allocator< KIFONT::OUTLINE_FONT * > >"""
        return _pcbnew.FOOTPRINT_GetFonts(self)
 
    def EmbedFonts(self):
        r"""EmbedFonts(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_EmbedFonts(self)
 
    def SetComponentClass(self, aClass):
        r"""SetComponentClass(FOOTPRINT self, COMPONENT_CLASS const * aClass)"""
        return _pcbnew.FOOTPRINT_SetComponentClass(self, aClass)
 
    def SetTransientComponentClassNames(self, classNames):
        r"""SetTransientComponentClassNames(FOOTPRINT self, std::unordered_set< wxString > const & classNames)"""
        return _pcbnew.FOOTPRINT_SetTransientComponentClassNames(self, classNames)
 
    def GetTransientComponentClassNames(self):
        r"""GetTransientComponentClassNames(FOOTPRINT self) -> std::unordered_set< wxString > const &"""
        return _pcbnew.FOOTPRINT_GetTransientComponentClassNames(self)
 
    def ClearTransientComponentClassNames(self):
        r"""ClearTransientComponentClassNames(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_ClearTransientComponentClassNames(self)
 
    def ResolveComponentClassNames(self, aBoard, aComponentClassNames):
        r"""ResolveComponentClassNames(FOOTPRINT self, BOARD aBoard, std::unordered_set< wxString > const & aComponentClassNames)"""
        return _pcbnew.FOOTPRINT_ResolveComponentClassNames(self, aBoard, aComponentClassNames)
 
    def GetComponentClass(self):
        r"""GetComponentClass(FOOTPRINT self) -> COMPONENT_CLASS const *"""
        return _pcbnew.FOOTPRINT_GetComponentClass(self)
 
    def GetComponentClassAsString(self):
        r"""GetComponentClassAsString(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetComponentClassAsString(self)
 
    def FixUpPadsForBoard(self, aBoard):
        r"""FixUpPadsForBoard(FOOTPRINT self, BOARD aBoard)"""
        return _pcbnew.FOOTPRINT_FixUpPadsForBoard(self, aBoard)
 
    def __eq__(self, *args):
        r"""
        __eq__(FOOTPRINT self, BOARD_ITEM aOther) -> bool
        __eq__(FOOTPRINT self, FOOTPRINT aOther) -> bool
        """
        return _pcbnew.FOOTPRINT___eq__(self, *args)
 
 
        #def SaveToLibrary(self,filename):
        #  return SaveFootprintToLibrary(filename,self)
 
        #
        # add function, clears the thisown to avoid python from deleting
        # the object in the garbage collector
        #
 
    def GetFieldsText(self):
      """ Returns footprint fields name to text map. """
      fields = self.GetFields()
      return {str(field.GetName()): str(field.GetText()) for field in fields}
 
    def GetFieldsShownText(self):
      """ Returns footprint fields name to shown text map. """
      fields = self.GetFields()
      return {str(field.GetName()): str(field.GetShownText(False)) for field in fields}
 
    def GetFieldText(self, key):
      """ Returns Field text with a given key if it exists, throws KeyError otherwise. """
      if self.HasFieldByName(key):
        return self.GetFieldByName(key).GetText()
      else:
        raise KeyError("Field not found: " + key)
 
    def GetFieldShownText(self, key):
      """ Returns Field shown text with a given key if it exists, throws KeyError otherwise. """
      if self.HasFieldByName(key):
        return self.GetFieldByName(key).GetShownText(False)
      else:
        raise KeyError("Field not found: " + key)
 
    def SetField(self, key, value):
      if self.HasFieldByName(key):
        self.GetFieldByName(key).SetText(value)
      else:
        field = PCB_FIELD(self, self.GetNextFieldId(), key)
        field.SetText(value)
        self.AddField(field)
 
    def HasField(self, key):
      return self.HasFieldByName(key)
 
    def SetFields(self, fields):
      """ Sets footprint fields map. """
      for k, v in fields.items():
        self.SetField(k, v)
 
 
    def GetBoundingBox(self, *args):
        r"""
        GetBoundingBox(FOOTPRINT self) -> BOX2I
        GetBoundingBox(FOOTPRINT self, bool aIncludeText) -> BOX2I
        GetBoundingBox(FOOTPRINT self, bool aIncludeText, bool includeHiddenText) -> BOX2I
        """
        return _pcbnew.FOOTPRINT_GetBoundingBox(self, *args)
 
# Register FOOTPRINT in _pcbnew:
_pcbnew.FOOTPRINT_swigregister(FOOTPRINT)
FP_is_LOCKED = _pcbnew.FP_is_LOCKED
 
FP_is_PLACED = _pcbnew.FP_is_PLACED
 
FP_to_PLACE = _pcbnew.FP_to_PLACE
 
FP_PADS_are_LOCKED = _pcbnew.FP_PADS_are_LOCKED
 
 
class cmp_drawings(object):
    r"""Proxy of C++ FOOTPRINT::cmp_drawings class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __call__(self, itemA, itemB):
        r"""__call__(cmp_drawings self, BOARD_ITEM itemA, BOARD_ITEM itemB) -> bool"""
        return _pcbnew.cmp_drawings___call__(self, itemA, itemB)
 
    def __init__(self):
        r"""__init__(cmp_drawings self) -> cmp_drawings"""
        _pcbnew.cmp_drawings_swiginit(self, _pcbnew.new_cmp_drawings())
    __swig_destroy__ = _pcbnew.delete_cmp_drawings
 
# Register cmp_drawings in _pcbnew:
_pcbnew.cmp_drawings_swigregister(cmp_drawings)
class cmp_pads(object):
    r"""Proxy of C++ FOOTPRINT::cmp_pads class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __call__(self, aFirst, aSecond):
        r"""__call__(cmp_pads self, PAD aFirst, PAD aSecond) -> bool"""
        return _pcbnew.cmp_pads___call__(self, aFirst, aSecond)
 
    def __init__(self):
        r"""__init__(cmp_pads self) -> cmp_pads"""
        _pcbnew.cmp_pads_swiginit(self, _pcbnew.new_cmp_pads())
    __swig_destroy__ = _pcbnew.delete_cmp_pads
 
# Register cmp_pads in _pcbnew:
_pcbnew.cmp_pads_swigregister(cmp_pads)
class cmp_zones(object):
    r"""Proxy of C++ FOOTPRINT::cmp_zones class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __call__(self, aFirst, aSecond):
        r"""__call__(cmp_zones self, ZONE aFirst, ZONE aSecond) -> bool"""
        return _pcbnew.cmp_zones___call__(self, aFirst, aSecond)
 
    def __init__(self):
        r"""__init__(cmp_zones self) -> cmp_zones"""
        _pcbnew.cmp_zones_swiginit(self, _pcbnew.new_cmp_zones())
    __swig_destroy__ = _pcbnew.delete_cmp_zones
 
# Register cmp_zones in _pcbnew:
_pcbnew.cmp_zones_swigregister(cmp_zones)
class VECTOR_FP_3DMODEL(object):
    r"""Proxy of C++ std::vector< FP_3DMODEL > 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(VECTOR_FP_3DMODEL self) -> SwigPyIterator"""
        return _pcbnew.VECTOR_FP_3DMODEL_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __nonzero__(self):
        r"""__nonzero__(VECTOR_FP_3DMODEL self) -> bool"""
        return _pcbnew.VECTOR_FP_3DMODEL___nonzero__(self)
 
    def __bool__(self):
        r"""__bool__(VECTOR_FP_3DMODEL self) -> bool"""
        return _pcbnew.VECTOR_FP_3DMODEL___bool__(self)
 
    def __len__(self):
        r"""__len__(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::size_type"""
        return _pcbnew.VECTOR_FP_3DMODEL___len__(self)
 
    def __getslice__(self, i, j):
        r"""__getslice__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i, std::vector< FP_3DMODEL >::difference_type j) -> VECTOR_FP_3DMODEL"""
        return _pcbnew.VECTOR_FP_3DMODEL___getslice__(self, i, j)
 
    def __setslice__(self, *args):
        r"""
        __setslice__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i, std::vector< FP_3DMODEL >::difference_type j)
        __setslice__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i, std::vector< FP_3DMODEL >::difference_type j, VECTOR_FP_3DMODEL v)
        """
        return _pcbnew.VECTOR_FP_3DMODEL___setslice__(self, *args)
 
    def __delslice__(self, i, j):
        r"""__delslice__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i, std::vector< FP_3DMODEL >::difference_type j)"""
        return _pcbnew.VECTOR_FP_3DMODEL___delslice__(self, i, j)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i)
        __delitem__(VECTOR_FP_3DMODEL self, SWIGPY_SLICEOBJECT * slice)
        """
        return _pcbnew.VECTOR_FP_3DMODEL___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(VECTOR_FP_3DMODEL self, SWIGPY_SLICEOBJECT * slice) -> VECTOR_FP_3DMODEL
        __getitem__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i) -> FP_3DMODEL
        """
        return _pcbnew.VECTOR_FP_3DMODEL___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(VECTOR_FP_3DMODEL self, SWIGPY_SLICEOBJECT * slice, VECTOR_FP_3DMODEL v)
        __setitem__(VECTOR_FP_3DMODEL self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::difference_type i, FP_3DMODEL x)
        """
        return _pcbnew.VECTOR_FP_3DMODEL___setitem__(self, *args)
 
    def pop(self):
        r"""pop(VECTOR_FP_3DMODEL self) -> FP_3DMODEL"""
        return _pcbnew.VECTOR_FP_3DMODEL_pop(self)
 
    def append(self, x):
        r"""append(VECTOR_FP_3DMODEL self, FP_3DMODEL x)"""
        return _pcbnew.VECTOR_FP_3DMODEL_append(self, x)
 
    def empty(self):
        r"""empty(VECTOR_FP_3DMODEL self) -> bool"""
        return _pcbnew.VECTOR_FP_3DMODEL_empty(self)
 
    def size(self):
        r"""size(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::size_type"""
        return _pcbnew.VECTOR_FP_3DMODEL_size(self)
 
    def swap(self, v):
        r"""swap(VECTOR_FP_3DMODEL self, VECTOR_FP_3DMODEL v)"""
        return _pcbnew.VECTOR_FP_3DMODEL_swap(self, v)
 
    def begin(self):
        r"""begin(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::iterator"""
        return _pcbnew.VECTOR_FP_3DMODEL_begin(self)
 
    def end(self):
        r"""end(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::iterator"""
        return _pcbnew.VECTOR_FP_3DMODEL_end(self)
 
    def rbegin(self):
        r"""rbegin(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::reverse_iterator"""
        return _pcbnew.VECTOR_FP_3DMODEL_rbegin(self)
 
    def rend(self):
        r"""rend(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::reverse_iterator"""
        return _pcbnew.VECTOR_FP_3DMODEL_rend(self)
 
    def clear(self):
        r"""clear(VECTOR_FP_3DMODEL self)"""
        return _pcbnew.VECTOR_FP_3DMODEL_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::allocator_type"""
        return _pcbnew.VECTOR_FP_3DMODEL_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(VECTOR_FP_3DMODEL self)"""
        return _pcbnew.VECTOR_FP_3DMODEL_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::iterator pos) -> std::vector< FP_3DMODEL >::iterator
        erase(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::iterator first, std::vector< FP_3DMODEL >::iterator last) -> std::vector< FP_3DMODEL >::iterator
        """
        return _pcbnew.VECTOR_FP_3DMODEL_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(VECTOR_FP_3DMODEL self) -> VECTOR_FP_3DMODEL
        __init__(VECTOR_FP_3DMODEL self, VECTOR_FP_3DMODEL other) -> VECTOR_FP_3DMODEL
        __init__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::size_type size) -> VECTOR_FP_3DMODEL
        __init__(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::size_type size, FP_3DMODEL value) -> VECTOR_FP_3DMODEL
        """
        _pcbnew.VECTOR_FP_3DMODEL_swiginit(self, _pcbnew.new_VECTOR_FP_3DMODEL(*args))
 
    def push_back(self, x):
        r"""push_back(VECTOR_FP_3DMODEL self, FP_3DMODEL x)"""
        return _pcbnew.VECTOR_FP_3DMODEL_push_back(self, x)
 
    def front(self):
        r"""front(VECTOR_FP_3DMODEL self) -> FP_3DMODEL"""
        return _pcbnew.VECTOR_FP_3DMODEL_front(self)
 
    def back(self):
        r"""back(VECTOR_FP_3DMODEL self) -> FP_3DMODEL"""
        return _pcbnew.VECTOR_FP_3DMODEL_back(self)
 
    def assign(self, n, x):
        r"""assign(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::size_type n, FP_3DMODEL x)"""
        return _pcbnew.VECTOR_FP_3DMODEL_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::size_type new_size)
        resize(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::size_type new_size, FP_3DMODEL x)
        """
        return _pcbnew.VECTOR_FP_3DMODEL_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::iterator pos, FP_3DMODEL x) -> std::vector< FP_3DMODEL >::iterator
        insert(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::iterator pos, std::vector< FP_3DMODEL >::size_type n, FP_3DMODEL x)
        """
        return _pcbnew.VECTOR_FP_3DMODEL_insert(self, *args)
 
    def reserve(self, n):
        r"""reserve(VECTOR_FP_3DMODEL self, std::vector< FP_3DMODEL >::size_type n)"""
        return _pcbnew.VECTOR_FP_3DMODEL_reserve(self, n)
 
    def capacity(self):
        r"""capacity(VECTOR_FP_3DMODEL self) -> std::vector< FP_3DMODEL >::size_type"""
        return _pcbnew.VECTOR_FP_3DMODEL_capacity(self)
    __swig_destroy__ = _pcbnew.delete_VECTOR_FP_3DMODEL
 
# Register VECTOR_FP_3DMODEL in _pcbnew:
_pcbnew.VECTOR_FP_3DMODEL_swigregister(VECTOR_FP_3DMODEL)
 
def GetPluginForPath(libname):
    plugin_type = PCB_IO_MGR.GuessPluginTypeFromLibPath( libname );
    return PCB_IO_MGR.PluginFind(plugin_type)
 
def FootprintEnumerate(libname):
    plug = GetPluginForPath(libname)
    return plug.FootprintEnumerate(libname)
 
def FootprintLoad(libname,name,preserveUUID=False):
    plug = GetPluginForPath(libname)
    return plug.FootprintLoad(libname,name,preserveUUID)
 
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.CreateLibrary(libname)
 
def FootprintLibDelete(libname):
    plug = GetPluginForPath(libname)
    plug.DeleteLibrary(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)
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 ToMM(iu):
    if type(iu) in [int,float]:
        return float(iu) / float(pcbIUScale.IU_PER_MM)
    elif type(iu) in [wxPoint,wxSize,VECTOR2I,VECTOR2L]:
        return tuple(map(ToMM,iu))
    else:
        raise TypeError("ToMM() expects int, float, wxPoint, wxSize, VECTOR2I or VECTOR2L, instead got type " + str(type(iu)))
 
def FromMM(mm):
    if type(mm) in [int,float]:
        return int(float(mm) * float(pcbIUScale.IU_PER_MM))
    elif type(mm) in [wxPoint,wxSize,VECTOR2I,VECTOR2L]:
        return tuple(map(FromMM,mm))
    else:
        raise TypeError("FromMM() expects int, float, wxPoint, wxSize, VECTOR2I or VECTOR2L, instead got type " + str(type(mm)))
 
def ToMils(iu):
    if type(iu) in [int,float]:
        return float(iu) / float(pcbIUScale.IU_PER_MILS)
    elif type(iu) in [wxPoint,wxSize,VECTOR2I,VECTOR2L]:
        return tuple(map(ToMils,iu))
    else:
        raise TypeError("ToMils() expects int, float, wxPoint, wxSize, VECTOR2I or VECTOR2L, instead got type " + str(type(iu)))
 
def FromMils(mils):
    if type(mils) in [int,float]:
        return int(float(mils)*float(pcbIUScale.IU_PER_MILS))
    elif type(mils) in [wxPoint,wxSize,VECTOR2I,VECTOR2L]:
        return tuple(map(FromMils,mils))
    else:
        raise TypeError("FromMils() expects int, float, wxPoint, wxSize, VECTOR2I or VECTOR2L, instead got type " + str(type(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 VECTOR2I_MM(mmx,mmy):
    return VECTOR2I(FromMM(mmx),FromMM(mmy))
 
def VECTOR2I_Mils(mmx,mmy):
    return VECTOR2I(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)
 
 
def Version():
    """Return the semantic version of KiCad"""
    return GetSemanticVersion()
 
def FullVersion():
    """Return the full, git-based version of KiCad"""
    return GetBuildVersion()