pcbnew.py

Go to the documentation of this file.

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
 
from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
 raise RuntimeError("Python 2.7 or later required")
 
# Import the low-level C/C++ module
if __package__ or "." in __name__:
 from . import _pcbnew
else:
 import _pcbnew
 
try:
 import builtins as __builtin__
except ImportError:
 import __builtin__
 
def _swig_repr(self):
 try:
 strthis = "proxy of " + self.this.__repr__()
 except __builtin__.Exception:
 strthis = ""
 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
 
def _swig_setattr_nondynamic_instance_variable(set):
 def set_instance_attr(self, name, value):
 if name == "thisown":
 self.this.own(value)
 elif name == "this":
 set(self, name, value)
 elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
 set(self, name, value)
 else:
 raise AttributeError("You cannot add instance attributes to %s" % self)
 return set_instance_attr
 
 
def _swig_setattr_nondynamic_class_variable(set):
 def set_class_attr(cls, name, value):
 if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
 set(cls, name, value)
 else:
 raise AttributeError("You cannot add class attributes to %s" % cls)
 return set_class_attr
 
 
def _swig_add_metaclass(metaclass):
 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
 def wrapper(cls):
 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
 return wrapper
 
 
class _SwigNonDynamicMeta(type):
 """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
 
 
class SwigPyIterator(object):
 r"""Proxy of C++ swig::SwigPyIterator class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
 def __init__(self, *args, **kwargs):
 raise AttributeError("No constructor defined - class is abstract")
 __repr__ = _swig_repr
 __swig_destroy__ = _pcbnew.delete_SwigPyIterator
 
 def value(self) -> "PyObject *":
 r"""value(SwigPyIterator self) -> PyObject *"""
 return _pcbnew.SwigPyIterator_value(self)
 
 def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
 r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator_incr(self, n)
 
 def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
 r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator_decr(self, n)
 
 def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
 r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
 return _pcbnew.SwigPyIterator_distance(self, x)
 
 def equal(self, x: "SwigPyIterator") -> "bool":
 r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
 return _pcbnew.SwigPyIterator_equal(self, x)
 
 def copy(self) -> "swig::SwigPyIterator *":
 r"""copy(SwigPyIterator self) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator_copy(self)
 
 def next(self) -> "PyObject *":
 r"""next(SwigPyIterator self) -> PyObject *"""
 return _pcbnew.SwigPyIterator_next(self)
 
 def __next__(self) -> "PyObject *":
 r"""__next__(SwigPyIterator self) -> PyObject *"""
 return _pcbnew.SwigPyIterator___next__(self)
 
 def previous(self) -> "PyObject *":
 r"""previous(SwigPyIterator self) -> PyObject *"""
 return _pcbnew.SwigPyIterator_previous(self)
 
 def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
 r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator_advance(self, n)
 
 def __eq__(self, x: "SwigPyIterator") -> "bool":
 r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
 return _pcbnew.SwigPyIterator___eq__(self, x)
 
 def __ne__(self, x: "SwigPyIterator") -> "bool":
 r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
 return _pcbnew.SwigPyIterator___ne__(self, x)
 
 def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
 r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator___iadd__(self, n)
 
 def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
 r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator___isub__(self, n)
 
 def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
 r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
 return _pcbnew.SwigPyIterator___add__(self, n)
 
 def __sub__(self, *args) -> "ptrdiff_t":
 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) -> "std::basic_string< char >::size_type":
 r"""length(string self) -> std::basic_string< char >::size_type"""
 return _pcbnew.string_length(self)
 
 def max_size(self) -> "std::basic_string< char >::size_type":
 r"""max_size(string self) -> std::basic_string< char >::size_type"""
 return _pcbnew.string_max_size(self)
 
 def capacity(self) -> "std::basic_string< char >::size_type":
 r"""capacity(string self) -> std::basic_string< char >::size_type"""
 return _pcbnew.string_capacity(self)
 
 def reserve(self, __res_arg: "std::basic_string< char >::size_type"=0) -> "void":
 r"""reserve(string self, std::basic_string< char >::size_type __res_arg=0)"""
 return _pcbnew.string_reserve(self, __res_arg)
 
 def copy(self, __s: "char *", __n: "std::basic_string< char >::size_type", __pos: "std::basic_string< char >::size_type"=0) -> "std::basic_string< char >::size_type":
 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) -> "char const *":
 r"""c_str(string self) -> char const *"""
 return _pcbnew.string_c_str(self)
 
 def find(self, *args) -> "std::basic_string< char >::size_type":
 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) -> "std::basic_string< char >::size_type":
 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) -> "std::basic_string< char >::size_type":
 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) -> "std::basic_string< char >::size_type":
 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) -> "std::basic_string< char >::size_type":
 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) -> "std::basic_string< char >::size_type":
 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) -> "std::basic_string< char >":
 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) -> "bool":
 r"""empty(string self) -> bool"""
 return _pcbnew.string_empty(self)
 
 def size(self) -> "std::basic_string< char >::size_type":
 r"""size(string self) -> std::basic_string< char >::size_type"""
 return _pcbnew.string_size(self)
 
 def swap(self, v: "string") -> "void":
 r"""swap(string self, string v)"""
 return _pcbnew.string_swap(self, v)
 
 def begin(self) -> "std::basic_string< char >::iterator":
 r"""begin(string self) -> std::basic_string< char >::iterator"""
 return _pcbnew.string_begin(self)
 
 def end(self) -> "std::basic_string< char >::iterator":
 r"""end(string self) -> std::basic_string< char >::iterator"""
 return _pcbnew.string_end(self)
 
 def rbegin(self) -> "std::basic_string< char >::reverse_iterator":
 r"""rbegin(string self) -> std::basic_string< char >::reverse_iterator"""
 return _pcbnew.string_rbegin(self)
 
 def rend(self) -> "std::basic_string< char >::reverse_iterator":
 r"""rend(string self) -> std::basic_string< char >::reverse_iterator"""
 return _pcbnew.string_rend(self)
 
 def get_allocator(self) -> "std::basic_string< char >::allocator_type":
 r"""get_allocator(string self) -> std::basic_string< char >::allocator_type"""
 return _pcbnew.string_get_allocator(self)
 
 def erase(self, *args) -> "std::basic_string< char >::iterator":
 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) -> "void":
 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) -> "void":
 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) -> "swig::SwigPyIterator *":
 r"""iterator(string self) -> SwigPyIterator"""
 return _pcbnew.string_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(string self) -> bool"""
 return _pcbnew.string___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(string self) -> bool"""
 return _pcbnew.string___bool__(self)
 
 def __len__(self) -> "std::basic_string< char >::size_type":
 r"""__len__(string self) -> std::basic_string< char >::size_type"""
 return _pcbnew.string___len__(self)
 
 def __getslice__(self, i: "std::basic_string< char >::difference_type", j: "std::basic_string< char >::difference_type") -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
 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) -> "void":
 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: "std::basic_string< char >::difference_type", j: "std::basic_string< char >::difference_type") -> "void":
 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) -> "void":
 r"""
 __delitem__(string self, std::basic_string< char >::difference_type i)
 __delitem__(string self, PySliceObject * slice)
 """
 return _pcbnew.string___delitem__(self, *args)
 
 def __getitem__(self, *args) -> "std::basic_string< char >::value_type":
 r"""
 __getitem__(string self, PySliceObject * slice) -> string
 __getitem__(string self, std::basic_string< char >::difference_type i) -> std::basic_string< char >::value_type
 """
 return _pcbnew.string___getitem__(self, *args)
 
 def __setitem__(self, *args) -> "void":
 r"""
 __setitem__(string self, PySliceObject * slice, string v)
 __setitem__(string self, PySliceObject * slice)
 __setitem__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::value_type x)
 """
 return _pcbnew.string___setitem__(self, *args)
 
 def insert(self, *args) -> "void":
 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) -> "std::basic_string< char > &":
 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: "string") -> "std::basic_string< char > &":
 r"""__iadd__(string self, string v) -> string"""
 return _pcbnew.string___iadd__(self, v)
 
 def __add__(self, v: "string") -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
 r"""__add__(string self, string v) -> string"""
 return _pcbnew.string___add__(self, v)
 
 def __radd__(self, v: "string") -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
 r"""__radd__(string self, string v) -> string"""
 return _pcbnew.string___radd__(self, v)
 
 def __str__(self) -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > >":
 r"""__str__(string self) -> string"""
 return _pcbnew.string___str__(self)
 
 def __rlshift__(self, out: "std::basic_ostream< char,std::char_traits< char > > &") -> "std::basic_ostream< char,std::char_traits< char > > &":
 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: "string") -> "bool":
 r"""__eq__(string self, string v) -> bool"""
 return _pcbnew.string___eq__(self, v)
 
 def __ne__(self, v: "string") -> "bool":
 r"""__ne__(string self, string v) -> bool"""
 return _pcbnew.string___ne__(self, v)
 
 def __gt__(self, v: "string") -> "bool":
 r"""__gt__(string self, string v) -> bool"""
 return _pcbnew.string___gt__(self, v)
 
 def __lt__(self, v: "string") -> "bool":
 r"""__lt__(string self, string v) -> bool"""
 return _pcbnew.string___lt__(self, v)
 
 def __ge__(self, v: "string") -> "bool":
 r"""__ge__(string self, string v) -> bool"""
 return _pcbnew.string___ge__(self, v)
 
 def __le__(self, v: "string") -> "bool":
 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) -> "wxString const":
 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: "wxString", aThrowersFile: "char const *", aThrowersFunction: "char const *", aThrowersLineNumber: "int") -> "void":
 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) -> "wxString const":
 r"""Problem(IO_ERROR self) -> wxString"""
 return _pcbnew.IO_ERROR_Problem(self)
 
 def Where(self) -> "wxString const":
 r"""Where(IO_ERROR self) -> wxString"""
 return _pcbnew.IO_ERROR_Where(self)
 
 def What(self) -> "wxString const":
 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: "char const *") -> "void":
 r"""wxSetDefaultPyEncoding(char const * encoding)"""
 return _pcbnew.wxSetDefaultPyEncoding(encoding)
 
def wxGetDefaultPyEncoding() -> "char const *":
 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) -> "int":
 r"""GetX(wxRect self) -> int"""
 return _pcbnew.wxRect_GetX(self)
 
 def SetX(self, xx: "int") -> "void":
 r"""SetX(wxRect self, int xx)"""
 return _pcbnew.wxRect_SetX(self, xx)
 
 def GetY(self) -> "int":
 r"""GetY(wxRect self) -> int"""
 return _pcbnew.wxRect_GetY(self)
 
 def SetY(self, yy: "int") -> "void":
 r"""SetY(wxRect self, int yy)"""
 return _pcbnew.wxRect_SetY(self, yy)
 
 def GetWidth(self) -> "int":
 r"""GetWidth(wxRect self) -> int"""
 return _pcbnew.wxRect_GetWidth(self)
 
 def SetWidth(self, w: "int") -> "void":
 r"""SetWidth(wxRect self, int w)"""
 return _pcbnew.wxRect_SetWidth(self, w)
 
 def GetHeight(self) -> "int":
 r"""GetHeight(wxRect self) -> int"""
 return _pcbnew.wxRect_GetHeight(self)
 
 def SetHeight(self, h: "int") -> "void":
 r"""SetHeight(wxRect self, int h)"""
 return _pcbnew.wxRect_SetHeight(self, h)
 
 def GetPosition(self) -> "wxPoint":
 r"""GetPosition(wxRect self) -> wxPoint"""
 return _pcbnew.wxRect_GetPosition(self)
 
 def SetPosition(self, p: "wxPoint") -> "void":
 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) -> "PyObject *":
 r"""Get(wxRect self) -> PyObject *"""
 return _pcbnew.wxRect_Get(self)
 
 
 def __eq__(self,other):
 return self.x==other.x and self.y==other.y and self.width==other.width and self.height==other.height
 def __str__(self): return str(self.Get())
 def __repr__(self): return 'wxRect'+str(self.Get())
 def __len__(self): return len(self.Get())
 def __getitem__(self, index): return self.Get()[index]
 def __setitem__(self, index, val):
 if index == 0: self.SetX(val)
 elif index == 1: self.SetY(val)
 elif index == 2: self.SetWidth(val)
 elif index == 3: self.SetHeight(val)
 else: raise IndexError
 def __nonzero__(self): return self.Get() != (0,0,0,0)
 __safe_for_unpickling__ = True
 
 __swig_destroy__ = _pcbnew.delete_wxRect
 
# Register wxRect in _pcbnew:
_pcbnew.wxRect_swigregister(wxRect)
 
class wxSize(object):
 r"""Proxy of C++ wxSize class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 x = property(_pcbnew.wxSize_x_get, _pcbnew.wxSize_x_set, doc=r"""x : int""")
 y = property(_pcbnew.wxSize_y_get, _pcbnew.wxSize_y_set, doc=r"""y : int""")
 
 def __init__(self, *args):
 r"""
 __init__(wxSize self, int xx, int yy) -> wxSize
 __init__(wxSize self, double xx, double yy) -> wxSize
 """
 _pcbnew.wxSize_swiginit(self, _pcbnew.new_wxSize(*args))
 
 def Get(self) -> "PyObject *":
 r"""Get(wxSize self) -> PyObject *"""
 return _pcbnew.wxSize_Get(self)
 __swig_destroy__ = _pcbnew.delete_wxSize
 
 def SetWidth(self, w: "int") -> "void":
 r"""SetWidth(wxSize self, int w)"""
 return _pcbnew.wxSize_SetWidth(self, w)
 
 def SetHeight(self, h: "int") -> "void":
 r"""SetHeight(wxSize self, int h)"""
 return _pcbnew.wxSize_SetHeight(self, h)
 
 def GetWidth(self) -> "int":
 r"""GetWidth(wxSize self) -> int"""
 return _pcbnew.wxSize_GetWidth(self)
 
 def GetHeight(self) -> "int":
 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: "wxPoint") -> "wxPoint":
 r"""__add__(wxPoint self, wxPoint pt) -> wxPoint"""
 return _pcbnew.wxPoint___add__(self, pt)
 
 def __sub__(self, pt: "wxPoint") -> "wxPoint":
 r"""__sub__(wxPoint self, wxPoint pt) -> wxPoint"""
 return _pcbnew.wxPoint___sub__(self, pt)
 
 def Set(self, x: "long", y: "long") -> "void":
 r"""Set(wxPoint self, long x, long y)"""
 return _pcbnew.wxPoint_Set(self, x, y)
 
 def Get(self) -> "PyObject *":
 r"""Get(wxPoint self) -> PyObject *"""
 return _pcbnew.wxPoint_Get(self)
 
 def __eq__(self,other): return (self.x==other.x and self.y==other.y)
 def __ne__(self,other): return not (self==other)
 def __str__(self): return str(self.Get())
 def __repr__(self): return 'wxPoint'+str(self.Get())
 def __len__(self): return len(self.Get())
 def __getitem__(self, index): return self.Get()[index]
 def __setitem__(self, index, val):
 if index == 0:
 self.x = val
 elif index == 1:
 self.y = val
 else:
 raise IndexError
 def __nonzero__(self): return self.Get() != (0,0)
 
 
 
# Register wxPoint in _pcbnew:
_pcbnew.wxPoint_swigregister(wxPoint)
 
class wxString(object):
 r"""Proxy of C++ wxString class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 __swig_destroy__ = _pcbnew.delete_wxString
 
 def __str__(self) -> "PyObject *":
 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) -> "swig::SwigPyIterator *":
 r"""iterator(wxPoint_Vector self) -> SwigPyIterator"""
 return _pcbnew.wxPoint_Vector_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(wxPoint_Vector self) -> bool"""
 return _pcbnew.wxPoint_Vector___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(wxPoint_Vector self) -> bool"""
 return _pcbnew.wxPoint_Vector___bool__(self)
 
 def __len__(self) -> "std::vector< wxPoint >::size_type":
 r"""__len__(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
 return _pcbnew.wxPoint_Vector___len__(self)
 
 def __getslice__(self, i: "std::vector< wxPoint >::difference_type", j: "std::vector< wxPoint >::difference_type") -> "std::vector< wxPoint,std::allocator< wxPoint > > *":
 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) -> "void":
 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: "std::vector< wxPoint >::difference_type", j: "std::vector< wxPoint >::difference_type") -> "void":
 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) -> "void":
 r"""
 __delitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i)
 __delitem__(wxPoint_Vector self, PySliceObject * slice)
 """
 return _pcbnew.wxPoint_Vector___delitem__(self, *args)
 
 def __getitem__(self, *args) -> "std::vector< wxPoint >::value_type const &":
 r"""
 __getitem__(wxPoint_Vector self, PySliceObject * slice) -> wxPoint_Vector
 __getitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i) -> wxPoint
 """
 return _pcbnew.wxPoint_Vector___getitem__(self, *args)
 
 def __setitem__(self, *args) -> "void":
 r"""
 __setitem__(wxPoint_Vector self, PySliceObject * slice, wxPoint_Vector v)
 __setitem__(wxPoint_Vector self, PySliceObject * slice)
 __setitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, wxPoint x)
 """
 return _pcbnew.wxPoint_Vector___setitem__(self, *args)
 
 def pop(self) -> "std::vector< wxPoint >::value_type":
 r"""pop(wxPoint_Vector self) -> wxPoint"""
 return _pcbnew.wxPoint_Vector_pop(self)
 
 def append(self, x: "wxPoint") -> "void":
 r"""append(wxPoint_Vector self, wxPoint x)"""
 return _pcbnew.wxPoint_Vector_append(self, x)
 
 def empty(self) -> "bool":
 r"""empty(wxPoint_Vector self) -> bool"""
 return _pcbnew.wxPoint_Vector_empty(self)
 
 def size(self) -> "std::vector< wxPoint >::size_type":
 r"""size(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
 return _pcbnew.wxPoint_Vector_size(self)
 
 def swap(self, v: "wxPoint_Vector") -> "void":
 r"""swap(wxPoint_Vector self, wxPoint_Vector v)"""
 return _pcbnew.wxPoint_Vector_swap(self, v)
 
 def begin(self) -> "std::vector< wxPoint >::iterator":
 r"""begin(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
 return _pcbnew.wxPoint_Vector_begin(self)
 
 def end(self) -> "std::vector< wxPoint >::iterator":
 r"""end(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
 return _pcbnew.wxPoint_Vector_end(self)
 
 def rbegin(self) -> "std::vector< wxPoint >::reverse_iterator":
 r"""rbegin(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
 return _pcbnew.wxPoint_Vector_rbegin(self)
 
 def rend(self) -> "std::vector< wxPoint >::reverse_iterator":
 r"""rend(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
 return _pcbnew.wxPoint_Vector_rend(self)
 
 def clear(self) -> "void":
 r"""clear(wxPoint_Vector self)"""
 return _pcbnew.wxPoint_Vector_clear(self)
 
 def get_allocator(self) -> "std::vector< wxPoint >::allocator_type":
 r"""get_allocator(wxPoint_Vector self) -> std::vector< wxPoint >::allocator_type"""
 return _pcbnew.wxPoint_Vector_get_allocator(self)
 
 def pop_back(self) -> "void":
 r"""pop_back(wxPoint_Vector self)"""
 return _pcbnew.wxPoint_Vector_pop_back(self)
 
 def erase(self, *args) -> "std::vector< wxPoint >::iterator":
 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: "wxPoint") -> "void":
 r"""push_back(wxPoint_Vector self, wxPoint x)"""
 return _pcbnew.wxPoint_Vector_push_back(self, x)
 
 def front(self) -> "std::vector< wxPoint >::value_type const &":
 r"""front(wxPoint_Vector self) -> wxPoint"""
 return _pcbnew.wxPoint_Vector_front(self)
 
 def back(self) -> "std::vector< wxPoint >::value_type const &":
 r"""back(wxPoint_Vector self) -> wxPoint"""
 return _pcbnew.wxPoint_Vector_back(self)
 
 def assign(self, n: "std::vector< wxPoint >::size_type", x: "wxPoint") -> "void":
 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) -> "void":
 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) -> "void":
 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: "std::vector< wxPoint >::size_type") -> "void":
 r"""reserve(wxPoint_Vector self, std::vector< wxPoint >::size_type n)"""
 return _pcbnew.wxPoint_Vector_reserve(self, n)
 
 def capacity(self) -> "std::vector< wxPoint >::size_type":
 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, wxString aString) -> KIID
 __init__(KIID self, timestamp_t aTimestamp) -> KIID
 """
 _pcbnew.KIID_swiginit(self, _pcbnew.new_KIID(*args))
 
 def Clone(self, aUUID: "KIID") -> "void":
 r"""Clone(KIID self, KIID aUUID)"""
 return _pcbnew.KIID_Clone(self, aUUID)
 
 def Hash(self) -> "size_t":
 r"""Hash(KIID self) -> size_t"""
 return _pcbnew.KIID_Hash(self)
 
 def IsLegacyTimestamp(self) -> "bool":
 r"""IsLegacyTimestamp(KIID self) -> bool"""
 return _pcbnew.KIID_IsLegacyTimestamp(self)
 
 def AsLegacyTimestamp(self) -> "timestamp_t":
 r"""AsLegacyTimestamp(KIID self) -> timestamp_t"""
 return _pcbnew.KIID_AsLegacyTimestamp(self)
 
 def AsString(self) -> "wxString":
 r"""AsString(KIID self) -> wxString"""
 return _pcbnew.KIID_AsString(self)
 
 def AsLegacyTimestampString(self) -> "wxString":
 r"""AsLegacyTimestampString(KIID self) -> wxString"""
 return _pcbnew.KIID_AsLegacyTimestampString(self)
 
 @staticmethod
 def SniffTest(aCandidate: "wxString") -> "bool":
 r"""SniffTest(wxString aCandidate) -> bool"""
 return _pcbnew.KIID_SniffTest(aCandidate)
 
 @staticmethod
 def CreateNilUuids(aNil: "bool"=True) -> "void":
 r"""CreateNilUuids(bool aNil=True)"""
 return _pcbnew.KIID_CreateNilUuids(aNil)
 
 @staticmethod
 def SeedGenerator(aSeed: "unsigned int") -> "void":
 r"""SeedGenerator(unsigned int aSeed)"""
 return _pcbnew.KIID_SeedGenerator(aSeed)
 
 def ConvertTimestampToUuid(self) -> "void":
 r"""ConvertTimestampToUuid(KIID self)"""
 return _pcbnew.KIID_ConvertTimestampToUuid(self)
 
 def Increment(self) -> "void":
 r"""Increment(KIID self)"""
 return _pcbnew.KIID_Increment(self)
 
 def __eq__(self, rhs: "KIID") -> "bool":
 r"""__eq__(KIID self, KIID rhs) -> bool"""
 return _pcbnew.KIID___eq__(self, rhs)
 
 def __ne__(self, rhs: "KIID") -> "bool":
 r"""__ne__(KIID self, KIID rhs) -> bool"""
 return _pcbnew.KIID___ne__(self, rhs)
 
 def __lt__(self, rhs: "KIID") -> "bool":
 r"""__lt__(KIID self, KIID rhs) -> bool"""
 return _pcbnew.KIID___lt__(self, rhs)
 
 def __gt__(self, rhs: "KIID") -> "bool":
 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 KIID_SniffTest(aCandidate: "wxString") -> "bool":
 r"""KIID_SniffTest(wxString aCandidate) -> bool"""
 return _pcbnew.KIID_SniffTest(aCandidate)
 
def KIID_CreateNilUuids(aNil: "bool"=True) -> "void":
 r"""KIID_CreateNilUuids(bool aNil=True)"""
 return _pcbnew.KIID_CreateNilUuids(aNil)
 
def KIID_SeedGenerator(aSeed: "unsigned int") -> "void":
 r"""KIID_SeedGenerator(unsigned int aSeed)"""
 return _pcbnew.KIID_SeedGenerator(aSeed)
 
 
def NilUuid() -> "KIID &":
 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) -> "swig::SwigPyIterator *":
 r"""iterator(KIID_VECT_LIST self) -> SwigPyIterator"""
 return _pcbnew.KIID_VECT_LIST_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(KIID_VECT_LIST self) -> bool"""
 return _pcbnew.KIID_VECT_LIST___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(KIID_VECT_LIST self) -> bool"""
 return _pcbnew.KIID_VECT_LIST___bool__(self)
 
 def __len__(self) -> "std::vector< KIID >::size_type":
 r"""__len__(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
 return _pcbnew.KIID_VECT_LIST___len__(self)
 
 def __getslice__(self, i: "std::vector< KIID >::difference_type", j: "std::vector< KIID >::difference_type") -> "std::vector< KIID,std::allocator< KIID > > *":
 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) -> "void":
 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: "std::vector< KIID >::difference_type", j: "std::vector< KIID >::difference_type") -> "void":
 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) -> "void":
 r"""
 __delitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i)
 __delitem__(KIID_VECT_LIST self, PySliceObject * slice)
 """
 return _pcbnew.KIID_VECT_LIST___delitem__(self, *args)
 
 def __getitem__(self, *args) -> "std::vector< KIID >::value_type const &":
 r"""
 __getitem__(KIID_VECT_LIST self, PySliceObject * 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) -> "void":
 r"""
 __setitem__(KIID_VECT_LIST self, PySliceObject * slice, KIID_VECT_LIST v)
 __setitem__(KIID_VECT_LIST self, PySliceObject * 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) -> "std::vector< KIID >::value_type":
 r"""pop(KIID_VECT_LIST self) -> KIID"""
 return _pcbnew.KIID_VECT_LIST_pop(self)
 
 def append(self, x: "KIID") -> "void":
 r"""append(KIID_VECT_LIST self, KIID x)"""
 return _pcbnew.KIID_VECT_LIST_append(self, x)
 
 def empty(self) -> "bool":
 r"""empty(KIID_VECT_LIST self) -> bool"""
 return _pcbnew.KIID_VECT_LIST_empty(self)
 
 def size(self) -> "std::vector< KIID >::size_type":
 r"""size(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
 return _pcbnew.KIID_VECT_LIST_size(self)
 
 def swap(self, v: "KIID_VECT_LIST") -> "void":
 r"""swap(KIID_VECT_LIST self, KIID_VECT_LIST v)"""
 return _pcbnew.KIID_VECT_LIST_swap(self, v)
 
 def begin(self) -> "std::vector< KIID >::iterator":
 r"""begin(KIID_VECT_LIST self) -> std::vector< KIID >::iterator"""
 return _pcbnew.KIID_VECT_LIST_begin(self)
 
 def end(self) -> "std::vector< KIID >::iterator":
 r"""end(KIID_VECT_LIST self) -> std::vector< KIID >::iterator"""
 return _pcbnew.KIID_VECT_LIST_end(self)
 
 def rbegin(self) -> "std::vector< KIID >::reverse_iterator":
 r"""rbegin(KIID_VECT_LIST self) -> std::vector< KIID >::reverse_iterator"""
 return _pcbnew.KIID_VECT_LIST_rbegin(self)
 
 def rend(self) -> "std::vector< KIID >::reverse_iterator":
 r"""rend(KIID_VECT_LIST self) -> std::vector< KIID >::reverse_iterator"""
 return _pcbnew.KIID_VECT_LIST_rend(self)
 
 def clear(self) -> "void":
 r"""clear(KIID_VECT_LIST self)"""
 return _pcbnew.KIID_VECT_LIST_clear(self)
 
 def get_allocator(self) -> "std::vector< KIID >::allocator_type":
 r"""get_allocator(KIID_VECT_LIST self) -> std::vector< KIID >::allocator_type"""
 return _pcbnew.KIID_VECT_LIST_get_allocator(self)
 
 def pop_back(self) -> "void":
 r"""pop_back(KIID_VECT_LIST self)"""
 return _pcbnew.KIID_VECT_LIST_pop_back(self)
 
 def erase(self, *args) -> "std::vector< KIID >::iterator":
 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: "KIID") -> "void":
 r"""push_back(KIID_VECT_LIST self, KIID x)"""
 return _pcbnew.KIID_VECT_LIST_push_back(self, x)
 
 def front(self) -> "std::vector< KIID >::value_type const &":
 r"""front(KIID_VECT_LIST self) -> KIID"""
 return _pcbnew.KIID_VECT_LIST_front(self)
 
 def back(self) -> "std::vector< KIID >::value_type const &":
 r"""back(KIID_VECT_LIST self) -> KIID"""
 return _pcbnew.KIID_VECT_LIST_back(self)
 
 def assign(self, n: "std::vector< KIID >::size_type", x: "KIID") -> "void":
 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) -> "void":
 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) -> "void":
 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: "std::vector< KIID >::size_type") -> "void":
 r"""reserve(KIID_VECT_LIST self, std::vector< KIID >::size_type n)"""
 return _pcbnew.KIID_VECT_LIST_reserve(self, n)
 
 def capacity(self) -> "std::vector< KIID >::size_type":
 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: "KIID_PATH") -> "bool":
 r"""MakeRelativeTo(KIID_PATH self, KIID_PATH aPath) -> bool"""
 return _pcbnew.KIID_PATH_MakeRelativeTo(self, aPath)
 
 def AsString(self) -> "wxString":
 r"""AsString(KIID_PATH self) -> wxString"""
 return _pcbnew.KIID_PATH_AsString(self)
 
 def __eq__(self, rhs: "KIID_PATH") -> "bool":
 r"""__eq__(KIID_PATH self, KIID_PATH rhs) -> bool"""
 return _pcbnew.KIID_PATH___eq__(self, rhs)
 
 def __lt__(self, rhs: "KIID_PATH") -> "bool":
 r"""__lt__(KIID_PATH self, KIID_PATH rhs) -> bool"""
 return _pcbnew.KIID_PATH___lt__(self, rhs)
 __swig_destroy__ = _pcbnew.delete_KIID_PATH
 
# Register KIID_PATH in _pcbnew:
_pcbnew.KIID_PATH_swigregister(KIID_PATH)
 
NOT_USED = _pcbnew.NOT_USED
 
EOT = _pcbnew.EOT
 
TYPE_NOT_INIT = _pcbnew.TYPE_NOT_INIT
 
PCB_T = _pcbnew.PCB_T
 
SCREEN_T = _pcbnew.SCREEN_T
 
PCB_FOOTPRINT_T = _pcbnew.PCB_FOOTPRINT_T
 
PCB_PAD_T = _pcbnew.PCB_PAD_T
 
PCB_SHAPE_T = _pcbnew.PCB_SHAPE_T
 
PCB_TEXT_T = _pcbnew.PCB_TEXT_T
 
PCB_FP_TEXT_T = _pcbnew.PCB_FP_TEXT_T
 
PCB_FP_SHAPE_T = _pcbnew.PCB_FP_SHAPE_T
 
PCB_FP_ZONE_T = _pcbnew.PCB_FP_ZONE_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_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_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_GRAPHIC_T = _pcbnew.PCB_LOCATE_GRAPHIC_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
 
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_TEXT_T = _pcbnew.SCH_TEXT_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_FIELD_T = _pcbnew.SCH_FIELD_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_PIN_T = _pcbnew.SCH_PIN_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_LINE_LOCATE_WIRE_T = _pcbnew.SCH_LINE_LOCATE_WIRE_T
 
SCH_LINE_LOCATE_BUS_T = _pcbnew.SCH_LINE_LOCATE_BUS_T
 
SCH_LINE_LOCATE_GRAPHIC_LINE_T = _pcbnew.SCH_LINE_LOCATE_GRAPHIC_LINE_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
 
LIB_SYMBOL_T = _pcbnew.LIB_SYMBOL_T
 
LIB_ALIAS_T = _pcbnew.LIB_ALIAS_T
 
LIB_SHAPE_T = _pcbnew.LIB_SHAPE_T
 
LIB_TEXT_T = _pcbnew.LIB_TEXT_T
 
LIB_PIN_T = _pcbnew.LIB_PIN_T
 
LIB_FIELD_T = _pcbnew.LIB_FIELD_T
 
GERBER_LAYOUT_T = _pcbnew.GERBER_LAYOUT_T
 
GERBER_DRAW_ITEM_T = _pcbnew.GERBER_DRAW_ITEM_T
 
GERBER_IMAGE_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
 
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: "KICAD_T const") -> "KICAD_T":
 r"""BaseType(KICAD_T const aType) -> KICAD_T"""
 return _pcbnew.BaseType(aType)
 
def IsNullType(aType: "KICAD_T const") -> "bool":
 r"""IsNullType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsNullType(aType)
 
def IsInstantiableType(aType: "KICAD_T const") -> "bool":
 r"""IsInstantiableType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsInstantiableType(aType)
 
def IsEeschemaType(aType: "KICAD_T const") -> "bool":
 r"""IsEeschemaType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsEeschemaType(aType)
 
def IsPcbnewType(aType: "KICAD_T const") -> "bool":
 r"""IsPcbnewType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsPcbnewType(aType)
 
def IsGerbviewType(aType: "KICAD_T const") -> "bool":
 r"""IsGerbviewType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsGerbviewType(aType)
 
def IsPageLayoutEditorType(aType: "KICAD_T const") -> "bool":
 r"""IsPageLayoutEditorType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsPageLayoutEditorType(aType)
 
def IsMiscType(aType: "KICAD_T const") -> "bool":
 r"""IsMiscType(KICAD_T const aType) -> bool"""
 return _pcbnew.IsMiscType(aType)
 
def IsTypeCorrect(aType: "KICAD_T") -> "bool":
 r"""IsTypeCorrect(KICAD_T aType) -> bool"""
 return _pcbnew.IsTypeCorrect(aType)
 
def IsTypeAvailable(aType: "KICAD_T") -> "bool":
 r"""IsTypeAvailable(KICAD_T aType) -> bool"""
 return _pcbnew.IsTypeAvailable(aType)
SEARCH_RESULT_QUIT = _pcbnew.SEARCH_RESULT_QUIT
 
SEARCH_RESULT_CONTINUE = _pcbnew.SEARCH_RESULT_CONTINUE
 
FR_CURRENT_SHEET_ONLY = _pcbnew.FR_CURRENT_SHEET_ONLY
 
FR_SEARCH_ALL_FIELDS = _pcbnew.FR_SEARCH_ALL_FIELDS
 
FR_SEARCH_ALL_PINS = _pcbnew.FR_SEARCH_ALL_PINS
 
FR_MATCH_WILDCARD = _pcbnew.FR_MATCH_WILDCARD
 
FR_SEARCH_WRAP = _pcbnew.FR_SEARCH_WRAP
 
FR_SEARCH_REPLACE = _pcbnew.FR_SEARCH_REPLACE
 
FR_REPLACE_ITEM_FOUND = _pcbnew.FR_REPLACE_ITEM_FOUND
 
FR_REPLACE_REFERENCES = _pcbnew.FR_REPLACE_REFERENCES
 
class EDA_ITEM(object):
 r"""Proxy of C++ EDA_ITEM class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
 def __init__(self, *args, **kwargs):
 raise AttributeError("No constructor defined - class is abstract")
 __repr__ = _swig_repr
 __swig_destroy__ = _pcbnew.delete_EDA_ITEM
 
 def Type(self) -> "KICAD_T":
 r"""Type(EDA_ITEM self) -> KICAD_T"""
 return _pcbnew.EDA_ITEM_Type(self)
 
 def GetParent(self) -> "EDA_ITEM *":
 r"""GetParent(EDA_ITEM self) -> EDA_ITEM"""
 return _pcbnew.EDA_ITEM_GetParent(self)
 
 def SetParent(self, aParent: "EDA_ITEM") -> "void":
 r"""SetParent(EDA_ITEM self, EDA_ITEM aParent)"""
 return _pcbnew.EDA_ITEM_SetParent(self, aParent)
 
 def IsModified(self) -> "bool":
 r"""IsModified(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsModified(self)
 
 def IsNew(self) -> "bool":
 r"""IsNew(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsNew(self)
 
 def IsMoving(self) -> "bool":
 r"""IsMoving(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsMoving(self)
 
 def IsDragging(self) -> "bool":
 r"""IsDragging(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsDragging(self)
 
 def IsWireImage(self) -> "bool":
 r"""IsWireImage(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsWireImage(self)
 
 def IsSelected(self) -> "bool":
 r"""IsSelected(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsSelected(self)
 
 def IsEntered(self) -> "bool":
 r"""IsEntered(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsEntered(self)
 
 def IsResized(self) -> "bool":
 r"""IsResized(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsResized(self)
 
 def IsBrightened(self) -> "bool":
 r"""IsBrightened(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsBrightened(self)
 
 def SetWireImage(self) -> "void":
 r"""SetWireImage(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_SetWireImage(self)
 
 def SetSelected(self) -> "void":
 r"""SetSelected(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_SetSelected(self)
 
 def SetBrightened(self) -> "void":
 r"""SetBrightened(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_SetBrightened(self)
 
 def ClearSelected(self) -> "void":
 r"""ClearSelected(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_ClearSelected(self)
 
 def ClearBrightened(self) -> "void":
 r"""ClearBrightened(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_ClearBrightened(self)
 
 def SetModified(self) -> "void":
 r"""SetModified(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_SetModified(self)
 
 def GetState(self, type: "EDA_ITEM_FLAGS") -> "int":
 r"""GetState(EDA_ITEM self, EDA_ITEM_FLAGS type) -> int"""
 return _pcbnew.EDA_ITEM_GetState(self, type)
 
 def SetState(self, type: "EDA_ITEM_FLAGS", state: "bool") -> "void":
 r"""SetState(EDA_ITEM self, EDA_ITEM_FLAGS type, bool state)"""
 return _pcbnew.EDA_ITEM_SetState(self, type, state)
 
 def GetStatus(self) -> "EDA_ITEM_FLAGS":
 r"""GetStatus(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
 return _pcbnew.EDA_ITEM_GetStatus(self)
 
 def SetStatus(self, aStatus: "EDA_ITEM_FLAGS") -> "void":
 r"""SetStatus(EDA_ITEM self, EDA_ITEM_FLAGS aStatus)"""
 return _pcbnew.EDA_ITEM_SetStatus(self, aStatus)
 
 def SetFlags(self, aMask: "EDA_ITEM_FLAGS") -> "void":
 r"""SetFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask)"""
 return _pcbnew.EDA_ITEM_SetFlags(self, aMask)
 
 def ClearFlags(self, *args) -> "void":
 r"""ClearFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)"""
 return _pcbnew.EDA_ITEM_ClearFlags(self, *args)
 
 def GetFlags(self) -> "EDA_ITEM_FLAGS":
 r"""GetFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
 return _pcbnew.EDA_ITEM_GetFlags(self)
 
 def HasFlag(self, aFlag: "EDA_ITEM_FLAGS") -> "bool":
 r"""HasFlag(EDA_ITEM self, EDA_ITEM_FLAGS aFlag) -> bool"""
 return _pcbnew.EDA_ITEM_HasFlag(self, aFlag)
 
 def GetEditFlags(self) -> "EDA_ITEM_FLAGS":
 r"""GetEditFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
 return _pcbnew.EDA_ITEM_GetEditFlags(self)
 
 def ClearTempFlags(self) -> "void":
 r"""ClearTempFlags(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_ClearTempFlags(self)
 
 def ClearEditFlags(self) -> "void":
 r"""ClearEditFlags(EDA_ITEM self)"""
 return _pcbnew.EDA_ITEM_ClearEditFlags(self)
 
 def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
 r"""IsType(EDA_ITEM self, KICAD_T const [] aScanTypes) -> bool"""
 return _pcbnew.EDA_ITEM_IsType(self, aScanTypes)
 
 def SetForceVisible(self, aEnable: "bool") -> "void":
 r"""SetForceVisible(EDA_ITEM self, bool aEnable)"""
 return _pcbnew.EDA_ITEM_SetForceVisible(self, aEnable)
 
 def IsForceVisible(self) -> "bool":
 r"""IsForceVisible(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsForceVisible(self)
 
 def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
 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 HitTest(self, *args) -> "bool":
 r"""
 HitTest(EDA_ITEM self, wxPoint aPosition, int aAccuracy=0) -> bool
 HitTest(EDA_ITEM self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
 """
 return _pcbnew.EDA_ITEM_HitTest(self, *args)
 
 def GetBoundingBox(self) -> "EDA_RECT const":
 r"""GetBoundingBox(EDA_ITEM self) -> EDA_RECT"""
 return _pcbnew.EDA_ITEM_GetBoundingBox(self)
 
 def GetPosition(self) -> "wxPoint":
 r"""GetPosition(EDA_ITEM self) -> wxPoint"""
 return _pcbnew.EDA_ITEM_GetPosition(self)
 
 def SetPosition(self, aPos: "wxPoint") -> "void":
 r"""SetPosition(EDA_ITEM self, wxPoint aPos)"""
 return _pcbnew.EDA_ITEM_SetPosition(self, aPos)
 
 def GetFocusPosition(self) -> "wxPoint const":
 r"""GetFocusPosition(EDA_ITEM self) -> wxPoint"""
 return _pcbnew.EDA_ITEM_GetFocusPosition(self)
 
 def Clone(self) -> "EDA_ITEM *":
 r"""Clone(EDA_ITEM self) -> EDA_ITEM"""
 return _pcbnew.EDA_ITEM_Clone(self)
 
 def Visit(self, inspector: "INSPECTOR", testData: "void *", scanTypes: "KICAD_T const []") -> "SEARCH_RESULT":
 r"""Visit(EDA_ITEM self, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
 return _pcbnew.EDA_ITEM_Visit(self, inspector, testData, scanTypes)
 
 def GetClass(self) -> "wxString":
 r"""GetClass(EDA_ITEM self) -> wxString"""
 return _pcbnew.EDA_ITEM_GetClass(self)
 
 def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
 r"""GetSelectMenuText(EDA_ITEM self, EDA_UNITS aUnits) -> wxString"""
 return _pcbnew.EDA_ITEM_GetSelectMenuText(self, aUnits)
 
 def GetMenuImage(self) -> "BITMAPS":
 r"""GetMenuImage(EDA_ITEM self) -> BITMAPS"""
 return _pcbnew.EDA_ITEM_GetMenuImage(self)
 
 def Matches(self, aSearchData: "wxFindReplaceData const &", aAuxData: "void *") -> "bool":
 r"""Matches(EDA_ITEM self, wxFindReplaceData const & aSearchData, void * aAuxData) -> bool"""
 return _pcbnew.EDA_ITEM_Matches(self, aSearchData, aAuxData)
 
 def Replace(self, *args) -> "bool":
 r"""
 Replace(EDA_ITEM self, wxFindReplaceData const & aSearchData, wxString aText) -> bool
 Replace(EDA_ITEM self, wxFindReplaceData const & aSearchData, void * aAuxData=None) -> bool
 """
 return _pcbnew.EDA_ITEM_Replace(self, *args)
 
 def IsReplaceable(self) -> "bool":
 r"""IsReplaceable(EDA_ITEM self) -> bool"""
 return _pcbnew.EDA_ITEM_IsReplaceable(self)
 
 def __lt__(self, aItem: "EDA_ITEM") -> "bool":
 r"""__lt__(EDA_ITEM self, EDA_ITEM aItem) -> bool"""
 return _pcbnew.EDA_ITEM___lt__(self, aItem)
 
 @staticmethod
 def Sort(aLeft: "EDA_ITEM", aRight: "EDA_ITEM") -> "bool":
 r"""Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
 return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)
 
 def ViewBBox(self) -> "BOX2I const":
 r"""ViewBBox(EDA_ITEM self) -> BOX2I const"""
 return _pcbnew.EDA_ITEM_ViewBBox(self)
 
 def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
 r"""ViewGetLayers(EDA_ITEM self, int [] aLayers, int & aCount)"""
 return _pcbnew.EDA_ITEM_ViewGetLayers(self, aLayers, aCount)
 m_Uuid = property(_pcbnew.EDA_ITEM_m_Uuid_get, doc=r"""m_Uuid : q(const).KIID""")
 
# Register EDA_ITEM in _pcbnew:
_pcbnew.EDA_ITEM_swigregister(EDA_ITEM)
 
def EDA_ITEM_Sort(aLeft: "EDA_ITEM", aRight: "EDA_ITEM") -> "bool":
 r"""EDA_ITEM_Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
 return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)
 
 
def new_clone(aItem: "EDA_ITEM") -> "EDA_ITEM *":
 r"""new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
 return _pcbnew.new_clone(aItem)
class EDA_RECT(object):
 r"""Proxy of C++ EDA_RECT class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 
 def __init__(self, *args):
 r"""
 __init__(EDA_RECT self) -> EDA_RECT
 __init__(EDA_RECT self, wxPoint aPos, wxSize aSize) -> EDA_RECT
 """
 _pcbnew.EDA_RECT_swiginit(self, _pcbnew.new_EDA_RECT(*args))
 __swig_destroy__ = _pcbnew.delete_EDA_RECT
 
 def Centre(self) -> "wxPoint":
 r"""Centre(EDA_RECT self) -> wxPoint"""
 return _pcbnew.EDA_RECT_Centre(self)
 
 def Move(self, aMoveVector: "wxPoint") -> "void":
 r"""Move(EDA_RECT self, wxPoint aMoveVector)"""
 return _pcbnew.EDA_RECT_Move(self, aMoveVector)
 
 def Normalize(self) -> "void":
 r"""Normalize(EDA_RECT self)"""
 return _pcbnew.EDA_RECT_Normalize(self)
 
 def Contains(self, *args) -> "bool":
 r"""
 Contains(EDA_RECT self, wxPoint aPoint) -> bool
 Contains(EDA_RECT self, int x, int y) -> bool
 Contains(EDA_RECT self, EDA_RECT aRect) -> bool
 """
 return _pcbnew.EDA_RECT_Contains(self, *args)
 
 def GetSize(self) -> "wxSize const":
 r"""GetSize(EDA_RECT self) -> wxSize"""
 return _pcbnew.EDA_RECT_GetSize(self)
 
 def GetSizeMax(self) -> "int":
 r"""GetSizeMax(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetSizeMax(self)
 
 def GetX(self) -> "int":
 r"""GetX(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetX(self)
 
 def GetY(self) -> "int":
 r"""GetY(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetY(self)
 
 def GetOrigin(self) -> "wxPoint const":
 r"""GetOrigin(EDA_RECT self) -> wxPoint"""
 return _pcbnew.EDA_RECT_GetOrigin(self)
 
 def GetPosition(self) -> "wxPoint const":
 r"""GetPosition(EDA_RECT self) -> wxPoint"""
 return _pcbnew.EDA_RECT_GetPosition(self)
 
 def GetEnd(self) -> "wxPoint const":
 r"""GetEnd(EDA_RECT self) -> wxPoint"""
 return _pcbnew.EDA_RECT_GetEnd(self)
 
 def GetCenter(self) -> "wxPoint const":
 r"""GetCenter(EDA_RECT self) -> wxPoint"""
 return _pcbnew.EDA_RECT_GetCenter(self)
 
 def GetWidth(self) -> "int":
 r"""GetWidth(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetWidth(self)
 
 def GetHeight(self) -> "int":
 r"""GetHeight(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetHeight(self)
 
 def GetRight(self) -> "int":
 r"""GetRight(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetRight(self)
 
 def GetLeft(self) -> "int":
 r"""GetLeft(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetLeft(self)
 
 def GetTop(self) -> "int":
 r"""GetTop(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetTop(self)
 
 def GetBottom(self) -> "int":
 r"""GetBottom(EDA_RECT self) -> int"""
 return _pcbnew.EDA_RECT_GetBottom(self)
 
 def IsValid(self) -> "bool":
 r"""IsValid(EDA_RECT self) -> bool"""
 return _pcbnew.EDA_RECT_IsValid(self)
 
 def SetOrigin(self, *args) -> "void":
 r"""
 SetOrigin(EDA_RECT self, wxPoint pos)
 SetOrigin(EDA_RECT self, int x, int y)
 """
 return _pcbnew.EDA_RECT_SetOrigin(self, *args)
 
 def SetSize(self, *args) -> "void":
 r"""
 SetSize(EDA_RECT self, wxSize size)
 SetSize(EDA_RECT self, int w, int h)
 """
 return _pcbnew.EDA_RECT_SetSize(self, *args)
 
 def Offset(self, *args) -> "void":
 r"""
 Offset(EDA_RECT self, int dx, int dy)
 Offset(EDA_RECT self, wxPoint offset)
 """
 return _pcbnew.EDA_RECT_Offset(self, *args)
 
 def SetX(self, val: "int") -> "void":
 r"""SetX(EDA_RECT self, int val)"""
 return _pcbnew.EDA_RECT_SetX(self, val)
 
 def SetY(self, val: "int") -> "void":
 r"""SetY(EDA_RECT self, int val)"""
 return _pcbnew.EDA_RECT_SetY(self, val)
 
 def SetWidth(self, val: "int") -> "void":
 r"""SetWidth(EDA_RECT self, int val)"""
 return _pcbnew.EDA_RECT_SetWidth(self, val)
 
 def SetHeight(self, val: "int") -> "void":
 r"""SetHeight(EDA_RECT self, int val)"""
 return _pcbnew.EDA_RECT_SetHeight(self, val)
 
 def SetEnd(self, *args) -> "void":
 r"""
 SetEnd(EDA_RECT self, int x, int y)
 SetEnd(EDA_RECT self, wxPoint pos)
 """
 return _pcbnew.EDA_RECT_SetEnd(self, *args)
 
 def RevertYAxis(self) -> "void":
 r"""RevertYAxis(EDA_RECT self)"""
 return _pcbnew.EDA_RECT_RevertYAxis(self)
 
 def Intersects(self, *args) -> "bool":
 r"""
 Intersects(EDA_RECT self, EDA_RECT aRect) -> bool
 Intersects(EDA_RECT self, EDA_RECT aRect, double aRot) -> bool
 Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2) -> bool
 Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2, wxPoint aIntersection1, wxPoint aIntersection2) -> bool
 """
 return _pcbnew.EDA_RECT_Intersects(self, *args)
 
 def ClosestPointTo(self, aPoint: "wxPoint") -> "wxPoint const":
 r"""ClosestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
 return _pcbnew.EDA_RECT_ClosestPointTo(self, aPoint)
 
 def FarthestPointTo(self, aPoint: "wxPoint") -> "wxPoint const":
 r"""FarthestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
 return _pcbnew.EDA_RECT_FarthestPointTo(self, aPoint)
 
 def IntersectsCircle(self, aCenter: "wxPoint", aRadius: "int const") -> "bool":
 r"""IntersectsCircle(EDA_RECT self, wxPoint aCenter, int const aRadius) -> bool"""
 return _pcbnew.EDA_RECT_IntersectsCircle(self, aCenter, aRadius)
 
 def IntersectsCircleEdge(self, aCenter: "wxPoint", aRadius: "int const", aWidth: "int const") -> "bool":
 r"""IntersectsCircleEdge(EDA_RECT self, wxPoint aCenter, int const aRadius, int const aWidth) -> bool"""
 return _pcbnew.EDA_RECT_IntersectsCircleEdge(self, aCenter, aRadius, aWidth)
 
 def getWxRect(self) -> "wxRect":
 r"""getWxRect(EDA_RECT self) -> wxRect"""
 return _pcbnew.EDA_RECT_getWxRect(self)
 
 def getBOX2I(self) -> "BOX2I":
 r"""getBOX2I(EDA_RECT self) -> BOX2I"""
 return _pcbnew.EDA_RECT_getBOX2I(self)
 
 def Inflate(self, *args) -> "EDA_RECT &":
 r"""
 Inflate(EDA_RECT self, wxCoord dx, wxCoord dy) -> EDA_RECT
 Inflate(EDA_RECT self, int aDelta) -> EDA_RECT
 """
 return _pcbnew.EDA_RECT_Inflate(self, *args)
 
 def Merge(self, *args) -> "void":
 r"""
 Merge(EDA_RECT self, EDA_RECT aRect)
 Merge(EDA_RECT self, wxPoint aPoint)
 """
 return _pcbnew.EDA_RECT_Merge(self, *args)
 
 def GetArea(self) -> "double":
 r"""GetArea(EDA_RECT self) -> double"""
 return _pcbnew.EDA_RECT_GetArea(self)
 
 def Common(self, aRect: "EDA_RECT") -> "EDA_RECT":
 r"""Common(EDA_RECT self, EDA_RECT aRect) -> EDA_RECT"""
 return _pcbnew.EDA_RECT_Common(self, aRect)
 
 def GetBoundingBoxRotated(self, aRotCenter: "wxPoint", aAngle: "double") -> "EDA_RECT const":
 r"""GetBoundingBoxRotated(EDA_RECT self, wxPoint aRotCenter, double aAngle) -> EDA_RECT"""
 return _pcbnew.EDA_RECT_GetBoundingBoxRotated(self, aRotCenter, aAngle)
 
# Register EDA_RECT in _pcbnew:
_pcbnew.EDA_RECT_swigregister(EDA_RECT)
 
EDA_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_UNITS_INCHES = _pcbnew.EDA_UNITS_INCHES
 
EDA_UNITS_MILLIMETRES = _pcbnew.EDA_UNITS_MILLIMETRES
 
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
 
 
def IsImperialUnit(aUnit: "EDA_UNITS") -> "bool":
 r"""IsImperialUnit(EDA_UNITS aUnit) -> bool"""
 return _pcbnew.IsImperialUnit(aUnit)
 
def IsMetricUnit(aUnit: "EDA_UNITS") -> "bool":
 r"""IsMetricUnit(EDA_UNITS aUnit) -> bool"""
 return _pcbnew.IsMetricUnit(aUnit)
 
def SearchHelpFileFullPath(aBaseName: "wxString") -> "wxString":
 r"""SearchHelpFileFullPath(wxString aBaseName) -> wxString"""
 return _pcbnew.SearchHelpFileFullPath(aBaseName)
 
def EnsureFileDirectoryExists(aTargetFullFileName: "wxFileName *", aBaseFilename: "wxString", aReporter: "REPORTER *"=None) -> "bool":
 r"""EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename, REPORTER * aReporter=None) -> bool"""
 return _pcbnew.EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter)
 
def ExpandEnvVarSubstitutions(aString: "wxString", aProject: "PROJECT *") -> "wxString const":
 r"""ExpandEnvVarSubstitutions(wxString aString, PROJECT * aProject) -> wxString"""
 return _pcbnew.ExpandEnvVarSubstitutions(aString, aProject)
 
def ExpandTextVars(*args) -> "wxString":
 r"""
 ExpandTextVars(wxString aSource, std::function< bool (wxString *) > const * aLocalResolver, std::function< bool (wxString *) > const * aFallbackResolver, PROJECT const * aProject) -> wxString
 ExpandTextVars(wxString aSource, PROJECT const * aProject) -> wxString
 """
 return _pcbnew.ExpandTextVars(*args)
 
def ResolveUriByEnvVars(aUri: "wxString", aProject: "PROJECT *") -> "wxString const":
 r"""ResolveUriByEnvVars(wxString aUri, PROJECT * aProject) -> wxString"""
 return _pcbnew.ResolveUriByEnvVars(aUri, aProject)
 
def TimestampDir(aDirPath: "wxString", aFilespec: "wxString") -> "long long":
 r"""TimestampDir(wxString aDirPath, wxString aFilespec) -> long long"""
 return _pcbnew.TimestampDir(aDirPath, aFilespec)
 
def WarnUserIfOperatingSystemUnsupported() -> "bool":
 r"""WarnUserIfOperatingSystemUnsupported() -> bool"""
 return _pcbnew.WarnUserIfOperatingSystemUnsupported()
 
def StrPrintf(*args) -> "std::string":
 r"""
 StrPrintf(string aResult, char const * aFormat) -> int
 StrPrintf(char const * format) -> string
 """
 return _pcbnew.StrPrintf(*args)
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) -> "char *":
 r"""ReadLine(LINE_READER self) -> char *"""
 return _pcbnew.LINE_READER_ReadLine(self)
 
 def GetSource(self) -> "wxString const &":
 r"""GetSource(LINE_READER self) -> wxString"""
 return _pcbnew.LINE_READER_GetSource(self)
 
 def Line(self) -> "char *":
 r"""Line(LINE_READER self) -> char *"""
 return _pcbnew.LINE_READER_Line(self)
 
 def LineNumber(self) -> "unsigned int":
 r"""LineNumber(LINE_READER self) -> unsigned int"""
 return _pcbnew.LINE_READER_LineNumber(self)
 
 def Length(self) -> "unsigned int":
 r"""Length(LINE_READER self) -> unsigned int"""
 return _pcbnew.LINE_READER_Length(self)
 
# Register LINE_READER in _pcbnew:
_pcbnew.LINE_READER_swigregister(LINE_READER)
 
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 ReadLine(self) -> "char *":
 r"""ReadLine(FILE_LINE_READER self) -> char *"""
 return _pcbnew.FILE_LINE_READER_ReadLine(self)
 
 def Rewind(self) -> "void":
 r"""Rewind(FILE_LINE_READER self)"""
 return _pcbnew.FILE_LINE_READER_Rewind(self)
 
 def FileLength(self) -> "long":
 r"""FileLength(FILE_LINE_READER self) -> long"""
 return _pcbnew.FILE_LINE_READER_FileLength(self)
 
 def CurPos(self) -> "long":
 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))
 
 def ReadLine(self) -> "char *":
 r"""ReadLine(STRING_LINE_READER self) -> char *"""
 return _pcbnew.STRING_LINE_READER_ReadLine(self)
 __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: "wxInputStream *", aSource: "wxString"):
 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))
 
 def ReadLine(self) -> "char *":
 r"""ReadLine(INPUTSTREAM_LINE_READER self) -> char *"""
 return _pcbnew.INPUTSTREAM_LINE_READER_ReadLine(self)
 __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
 
 def Print(self, nestLevel: "int", fmt: "char const *") -> "int":
 r"""Print(OUTPUTFORMATTER self, int nestLevel, char const * fmt) -> int"""
 return _pcbnew.OUTPUTFORMATTER_Print(self, nestLevel, fmt)
 
 def GetQuoteChar(self, wrapee: "char const *") -> "char const *":
 r"""GetQuoteChar(OUTPUTFORMATTER self, char const * wrapee) -> char const *"""
 return _pcbnew.OUTPUTFORMATTER_GetQuoteChar(self, wrapee)
 
 def Quotes(self, aWrapee: "string") -> "std::string":
 r"""Quotes(OUTPUTFORMATTER self, string aWrapee) -> string"""
 return _pcbnew.OUTPUTFORMATTER_Quotes(self, aWrapee)
 
 def Quotew(self, aWrapee: "wxString") -> "std::string":
 r"""Quotew(OUTPUTFORMATTER self, wxString aWrapee) -> string"""
 return _pcbnew.OUTPUTFORMATTER_Quotew(self, aWrapee)
 
# 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) -> "void":
 r"""Clear(STRING_FORMATTER self)"""
 return _pcbnew.STRING_FORMATTER_Clear(self)
 
 def StripUseless(self) -> "void":
 r"""StripUseless(STRING_FORMATTER self)"""
 return _pcbnew.STRING_FORMATTER_StripUseless(self)
 
 def GetString(self) -> "std::string const &":
 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 STREAM_OUTPUTFORMATTER(OUTPUTFORMATTER):
 r"""Proxy of C++ STREAM_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__(STREAM_OUTPUTFORMATTER self, wxOutputStream & aStream, char aQuoteChar='\"') -> STREAM_OUTPUTFORMATTER"""
 _pcbnew.STREAM_OUTPUTFORMATTER_swiginit(self, _pcbnew.new_STREAM_OUTPUTFORMATTER(*args))
 __swig_destroy__ = _pcbnew.delete_STREAM_OUTPUTFORMATTER
 
# Register STREAM_OUTPUTFORMATTER in _pcbnew:
_pcbnew.STREAM_OUTPUTFORMATTER_swigregister(STREAM_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: "wxString") -> "void":
 r"""SetTitle(TITLE_BLOCK self, wxString aTitle)"""
 return _pcbnew.TITLE_BLOCK_SetTitle(self, aTitle)
 
 def GetTitle(self) -> "wxString const &":
 r"""GetTitle(TITLE_BLOCK self) -> wxString"""
 return _pcbnew.TITLE_BLOCK_GetTitle(self)
 
 def SetDate(self, aDate: "wxString") -> "void":
 r"""SetDate(TITLE_BLOCK self, wxString aDate)"""
 return _pcbnew.TITLE_BLOCK_SetDate(self, aDate)
 
 def GetDate(self) -> "wxString const &":
 r"""GetDate(TITLE_BLOCK self) -> wxString"""
 return _pcbnew.TITLE_BLOCK_GetDate(self)
 
 def SetRevision(self, aRevision: "wxString") -> "void":
 r"""SetRevision(TITLE_BLOCK self, wxString aRevision)"""
 return _pcbnew.TITLE_BLOCK_SetRevision(self, aRevision)
 
 def GetRevision(self) -> "wxString const &":
 r"""GetRevision(TITLE_BLOCK self) -> wxString"""
 return _pcbnew.TITLE_BLOCK_GetRevision(self)
 
 def SetCompany(self, aCompany: "wxString") -> "void":
 r"""SetCompany(TITLE_BLOCK self, wxString aCompany)"""
 return _pcbnew.TITLE_BLOCK_SetCompany(self, aCompany)
 
 def GetCompany(self) -> "wxString const &":
 r"""GetCompany(TITLE_BLOCK self) -> wxString"""
 return _pcbnew.TITLE_BLOCK_GetCompany(self)
 
 def SetComment(self, aIdx: "int", aComment: "wxString") -> "void":
 r"""SetComment(TITLE_BLOCK self, int aIdx, wxString aComment)"""
 return _pcbnew.TITLE_BLOCK_SetComment(self, aIdx, aComment)
 
 def GetComment(self, aIdx: "int") -> "wxString const &":
 r"""GetComment(TITLE_BLOCK self, int aIdx) -> wxString"""
 return _pcbnew.TITLE_BLOCK_GetComment(self, aIdx)
 
 def Clear(self) -> "void":
 r"""Clear(TITLE_BLOCK self)"""
 return _pcbnew.TITLE_BLOCK_Clear(self)
 
 @staticmethod
 def GetContextualTextVars(aVars: "wxArrayString *") -> "void":
 r"""GetContextualTextVars(wxArrayString * aVars)"""
 return _pcbnew.TITLE_BLOCK_GetContextualTextVars(aVars)
 
 def TextVarResolver(self, aToken: "wxString", aProject: "PROJECT const *") -> "bool":
 r"""TextVarResolver(TITLE_BLOCK self, wxString aToken, PROJECT const * aProject) -> bool"""
 return _pcbnew.TITLE_BLOCK_TextVarResolver(self, aToken, aProject)
 
 def Format(self, aFormatter: "OUTPUTFORMATTER", aNestLevel: "int", aControlBits: "int") -> "void":
 r"""Format(TITLE_BLOCK self, OUTPUTFORMATTER aFormatter, int aNestLevel, int aControlBits)"""
 return _pcbnew.TITLE_BLOCK_Format(self, aFormatter, aNestLevel, aControlBits)
 
# Register TITLE_BLOCK in _pcbnew:
_pcbnew.TITLE_BLOCK_swigregister(TITLE_BLOCK)
 
def TITLE_BLOCK_GetContextualTextVars(aVars: "wxArrayString *") -> "void":
 r"""TITLE_BLOCK_GetContextualTextVars(wxArrayString * aVars)"""
 return _pcbnew.TITLE_BLOCK_GetContextualTextVars(aVars)
 
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() -> "StructColors const *":
 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: "int", aGreen: "int", aBlue: "int", aAlpha: "double"=1.0) -> "KIGFX::COLOR4D &":
 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: "wxString") -> "bool":
 r"""SetFromWxString(COLOR4D self, wxString aColorString) -> bool"""
 return _pcbnew.COLOR4D_SetFromWxString(self, aColorString)
 
 def ToCSSString(self) -> "wxString":
 r"""ToCSSString(COLOR4D self) -> wxString"""
 return _pcbnew.COLOR4D_ToCSSString(self)
 
 def SetFromHexString(self, aColorString: "wxString") -> "bool":
 r"""SetFromHexString(COLOR4D self, wxString aColorString) -> bool"""
 return _pcbnew.COLOR4D_SetFromHexString(self, aColorString)
 
 def ToHexString(self) -> "wxString":
 r"""ToHexString(COLOR4D self) -> wxString"""
 return _pcbnew.COLOR4D_ToHexString(self)
 
 def ToColour(self) -> "wxColour":
 r"""ToColour(COLOR4D self) -> wxColour"""
 return _pcbnew.COLOR4D_ToColour(self)
 
 def LegacyMix(self, aColor: "COLOR4D") -> "KIGFX::COLOR4D":
 r"""LegacyMix(COLOR4D self, COLOR4D aColor) -> COLOR4D"""
 return _pcbnew.COLOR4D_LegacyMix(self, aColor)
 
 def ToU32(self) -> "unsigned int":
 r"""ToU32(COLOR4D self) -> unsigned int"""
 return _pcbnew.COLOR4D_ToU32(self)
 
 def FromU32(self, aPackedColor: "unsigned int") -> "void":
 r"""FromU32(COLOR4D self, unsigned int aPackedColor)"""
 return _pcbnew.COLOR4D_FromU32(self, aPackedColor)
 
 def ToHSL(self, aOutHue: "double &", aOutSaturation: "double &", aOutValue: "double &") -> "void":
 r"""ToHSL(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue)"""
 return _pcbnew.COLOR4D_ToHSL(self, aOutHue, aOutSaturation, aOutValue)
 
 def FromHSL(self, aInHue: "double", aInSaturation: "double", aInLightness: "double") -> "void":
 r"""FromHSL(COLOR4D self, double aInHue, double aInSaturation, double aInLightness)"""
 return _pcbnew.COLOR4D_FromHSL(self, aInHue, aInSaturation, aInLightness)
 
 def Brighten(self, aFactor: "double") -> "KIGFX::COLOR4D &":
 r"""Brighten(COLOR4D self, double aFactor) -> COLOR4D"""
 return _pcbnew.COLOR4D_Brighten(self, aFactor)
 
 def Darken(self, aFactor: "double") -> "KIGFX::COLOR4D &":
 r"""Darken(COLOR4D self, double aFactor) -> COLOR4D"""
 return _pcbnew.COLOR4D_Darken(self, aFactor)
 
 def Invert(self) -> "KIGFX::COLOR4D &":
 r"""Invert(COLOR4D self) -> COLOR4D"""
 return _pcbnew.COLOR4D_Invert(self)
 
 def Saturate(self, aFactor: "double") -> "KIGFX::COLOR4D &":
 r"""Saturate(COLOR4D self, double aFactor) -> COLOR4D"""
 return _pcbnew.COLOR4D_Saturate(self, aFactor)
 
 def Brightened(self, aFactor: "double") -> "KIGFX::COLOR4D":
 r"""Brightened(COLOR4D self, double aFactor) -> COLOR4D"""
 return _pcbnew.COLOR4D_Brightened(self, aFactor)
 
 def Darkened(self, aFactor: "double") -> "KIGFX::COLOR4D":
 r"""Darkened(COLOR4D self, double aFactor) -> COLOR4D"""
 return _pcbnew.COLOR4D_Darkened(self, aFactor)
 
 def Mix(self, aColor: "COLOR4D", aFactor: "double") -> "KIGFX::COLOR4D":
 r"""Mix(COLOR4D self, COLOR4D aColor, double aFactor) -> COLOR4D"""
 return _pcbnew.COLOR4D_Mix(self, aColor, aFactor)
 
 def WithAlpha(self, aAlpha: "double") -> "KIGFX::COLOR4D":
 r"""WithAlpha(COLOR4D self, double aAlpha) -> COLOR4D"""
 return _pcbnew.COLOR4D_WithAlpha(self, aAlpha)
 
 def Inverted(self) -> "KIGFX::COLOR4D":
 r"""Inverted(COLOR4D self) -> COLOR4D"""
 return _pcbnew.COLOR4D_Inverted(self)
 
 def GetBrightness(self) -> "double":
 r"""GetBrightness(COLOR4D self) -> double"""
 return _pcbnew.COLOR4D_GetBrightness(self)
 
 def ToHSV(self, aOutHue: "double &", aOutSaturation: "double &", aOutValue: "double &", aAlwaysDefineHue: "bool"=False) -> "void":
 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: "double", aInS: "double", aInV: "double") -> "void":
 r"""FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
 return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)
 
 def Distance(self, other: "COLOR4D") -> "double":
 r"""Distance(COLOR4D self, COLOR4D other) -> double"""
 return _pcbnew.COLOR4D_Distance(self, other)
 
 @staticmethod
 def FindNearestLegacyColor(aR: "int", aG: "int", aB: "int") -> "EDA_COLOR_T":
 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)
 
def COLOR4D_FindNearestLegacyColor(aR: "int", aG: "int", aB: "int") -> "EDA_COLOR_T":
 r"""COLOR4D_FindNearestLegacyColor(int aR, int aG, int aB) -> EDA_COLOR_T"""
 return _pcbnew.COLOR4D_FindNearestLegacyColor(aR, aG, aB)
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: "COLOR4D", rhs: "COLOR4D") -> "bool const":
 r"""__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
 return _pcbnew.__eq__(lhs, rhs)
 
def __ne__(lhs: "COLOR4D", rhs: "COLOR4D") -> "bool const":
 r"""__ne__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
 return _pcbnew.__ne__(lhs, rhs)
 
def __lt__(lhs: "COLOR4D", rhs: "COLOR4D") -> "bool const":
 r"""__lt__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
 return _pcbnew.__lt__(lhs, rhs)
 
def __lshift__(aStream: "std::ostream &", aColor: "COLOR4D") -> "std::ostream &":
 r"""__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
 return _pcbnew.__lshift__(aStream, aColor)
 
def to_json(aJson: "nlohmann::json &", aColor: "COLOR4D") -> "void":
 r"""to_json(nlohmann::json & aJson, COLOR4D aColor)"""
 return _pcbnew.to_json(aJson, aColor)
 
def from_json(aJson: "nlohmann::json const &", aColor: "COLOR4D") -> "void":
 r"""from_json(nlohmann::json const & aJson, COLOR4D aColor)"""
 return _pcbnew.from_json(aJson, 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_PCB = _pcbnew.MARKER_BASE_MARKER_PCB
 
 MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
 
 __swig_destroy__ = _pcbnew.delete_MARKER_BASE
 
 def MarkerScale(self) -> "int":
 r"""MarkerScale(MARKER_BASE self) -> int"""
 return _pcbnew.MARKER_BASE_MarkerScale(self)
 
 def SetMarkerScale(self, aScale: "int") -> "void":
 r"""SetMarkerScale(MARKER_BASE self, int aScale)"""
 return _pcbnew.MARKER_BASE_SetMarkerScale(self, aScale)
 
 def ShapeToPolygon(self, aPolygon: "SHAPE_LINE_CHAIN", aScale: "int"=-1) -> "void":
 r"""ShapeToPolygon(MARKER_BASE self, SHAPE_LINE_CHAIN aPolygon, int aScale=-1)"""
 return _pcbnew.MARKER_BASE_ShapeToPolygon(self, aPolygon, aScale)
 
 def PrintMarker(self, aSettings: "RENDER_SETTINGS const *", aOffset: "wxPoint") -> "void":
 r"""PrintMarker(MARKER_BASE self, RENDER_SETTINGS const * aSettings, wxPoint aOffset)"""
 return _pcbnew.MARKER_BASE_PrintMarker(self, aSettings, aOffset)
 
 def GetPos(self) -> "wxPoint const &":
 r"""GetPos(MARKER_BASE self) -> wxPoint"""
 return _pcbnew.MARKER_BASE_GetPos(self)
 
 def GetUUID(self) -> "KIID const":
 r"""GetUUID(MARKER_BASE self) -> KIID"""
 return _pcbnew.MARKER_BASE_GetUUID(self)
 
 def SetMarkerType(self, aMarkerType: "enum MARKER_BASE::TYPEMARKER") -> "void":
 r"""SetMarkerType(MARKER_BASE self, enum MARKER_BASE::TYPEMARKER aMarkerType)"""
 return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)
 
 def GetMarkerType(self) -> "enum MARKER_BASE::TYPEMARKER":
 r"""GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::TYPEMARKER"""
 return _pcbnew.MARKER_BASE_GetMarkerType(self)
 
 def IsExcluded(self) -> "bool":
 r"""IsExcluded(MARKER_BASE self) -> bool"""
 return _pcbnew.MARKER_BASE_IsExcluded(self)
 
 def SetExcluded(self, aExcluded: "bool") -> "void":
 r"""SetExcluded(MARKER_BASE self, bool aExcluded)"""
 return _pcbnew.MARKER_BASE_SetExcluded(self, aExcluded)
 
 def GetRCItem(self) -> "std::shared_ptr< RC_ITEM >":
 r"""GetRCItem(MARKER_BASE self) -> std::shared_ptr< RC_ITEM >"""
 return _pcbnew.MARKER_BASE_GetRCItem(self)
 
 def HitTestMarker(self, aHitPosition: "wxPoint", aAccuracy: "int") -> "bool":
 r"""HitTestMarker(MARKER_BASE self, wxPoint aHitPosition, int aAccuracy) -> bool"""
 return _pcbnew.MARKER_BASE_HitTestMarker(self, aHitPosition, aAccuracy)
 
 def GetBoundingBoxMarker(self) -> "EDA_RECT":
 r"""GetBoundingBoxMarker(MARKER_BASE self) -> EDA_RECT"""
 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 : wxPoint""")
 
# Register MARKER_BASE in _pcbnew:
_pcbnew.MARKER_BASE_swigregister(MARKER_BASE)
 
class TSEGM_2_POLY_PRMS(object):
 r"""Proxy of C++ TSEGM_2_POLY_PRMS class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 m_textWidth = property(_pcbnew.TSEGM_2_POLY_PRMS_m_textWidth_get, _pcbnew.TSEGM_2_POLY_PRMS_m_textWidth_set, doc=r"""m_textWidth : int""")
 m_error = property(_pcbnew.TSEGM_2_POLY_PRMS_m_error_get, _pcbnew.TSEGM_2_POLY_PRMS_m_error_set, doc=r"""m_error : int""")
 m_cornerBuffer = property(_pcbnew.TSEGM_2_POLY_PRMS_m_cornerBuffer_get, _pcbnew.TSEGM_2_POLY_PRMS_m_cornerBuffer_set, doc=r"""m_cornerBuffer : p.SHAPE_POLY_SET""")
 
 def __init__(self):
 r"""__init__(TSEGM_2_POLY_PRMS self) -> TSEGM_2_POLY_PRMS"""
 _pcbnew.TSEGM_2_POLY_PRMS_swiginit(self, _pcbnew.new_TSEGM_2_POLY_PRMS())
 __swig_destroy__ = _pcbnew.delete_TSEGM_2_POLY_PRMS
 
# Register TSEGM_2_POLY_PRMS in _pcbnew:
_pcbnew.TSEGM_2_POLY_PRMS_swigregister(TSEGM_2_POLY_PRMS)
 
 
def addTextSegmToPoly(x0: "int", y0: "int", xf: "int", yf: "int", aData: "void *") -> "void":
 r"""addTextSegmToPoly(int x0, int y0, int xf, int yf, void * aData)"""
 return _pcbnew.addTextSegmToPoly(x0, y0, xf, yf, aData)
TEXT_ANGLE_HORIZ = _pcbnew.TEXT_ANGLE_HORIZ
 
TEXT_ANGLE_VERT = _pcbnew.TEXT_ANGLE_VERT
 
CTL_OMIT_HIDE = _pcbnew.CTL_OMIT_HIDE
 
GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT
 
GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER
 
GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT
 
GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP
 
GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER
 
GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM
 
DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT
 
DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE
 
class TEXT_EFFECTS(object):
 r"""Proxy of C++ TEXT_EFFECTS class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 
 def __init__(self, aSetOfBits: "int"=0):
 r"""__init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS"""
 _pcbnew.TEXT_EFFECTS_swiginit(self, _pcbnew.new_TEXT_EFFECTS(aSetOfBits))
 bits = property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set, doc=r"""bits : int""")
 hjustify = property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set, doc=r"""hjustify : signed char""")
 vjustify = property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set, doc=r"""vjustify : signed char""")
 size = property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set, doc=r"""size : wxSize""")
 penwidth = property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set, doc=r"""penwidth : int""")
 angle = property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set, doc=r"""angle : double""")
 pos = property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set, doc=r"""pos : wxPoint""")
 
 def Bit(self, *args) -> "bool":
 r"""
 Bit(TEXT_EFFECTS self, int aBit, bool aValue)
 Bit(TEXT_EFFECTS self, int aBit) -> bool
 """
 return _pcbnew.TEXT_EFFECTS_Bit(self, *args)
 __swig_destroy__ = _pcbnew.delete_TEXT_EFFECTS
 
# Register TEXT_EFFECTS in _pcbnew:
_pcbnew.TEXT_EFFECTS_swigregister(TEXT_EFFECTS)
 
class EDA_TEXT(object):
 r"""Proxy of C++ EDA_TEXT class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 
 def __init__(self, *args):
 r"""
 __init__(EDA_TEXT self, wxString text=wxEmptyString) -> EDA_TEXT
 __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 GetText(self) -> "wxString const &":
 r"""GetText(EDA_TEXT self) -> wxString"""
 return _pcbnew.EDA_TEXT_GetText(self)
 
 def GetShownText(self, aDepth: "int"=0, aAllowExtraText: "bool"=True) -> "wxString":
 r"""GetShownText(EDA_TEXT self, int aDepth=0, bool aAllowExtraText=True) -> wxString"""
 return _pcbnew.EDA_TEXT_GetShownText(self, aDepth, aAllowExtraText)
 
 def ShortenedShownText(self) -> "wxString":
 r"""ShortenedShownText(EDA_TEXT self) -> wxString"""
 return _pcbnew.EDA_TEXT_ShortenedShownText(self)
 
 def HasTextVars(self) -> "bool":
 r"""HasTextVars(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_HasTextVars(self)
 
 def SetText(self, aText: "wxString") -> "void":
 r"""SetText(EDA_TEXT self, wxString aText)"""
 return _pcbnew.EDA_TEXT_SetText(self, aText)
 
 def SetTextThickness(self, aWidth: "int") -> "void":
 r"""SetTextThickness(EDA_TEXT self, int aWidth)"""
 return _pcbnew.EDA_TEXT_SetTextThickness(self, aWidth)
 
 def GetTextThickness(self) -> "int":
 r"""GetTextThickness(EDA_TEXT self) -> int"""
 return _pcbnew.EDA_TEXT_GetTextThickness(self)
 
 def GetEffectiveTextPenWidth(self, aDefaultWidth: "int"=0) -> "int":
 r"""GetEffectiveTextPenWidth(EDA_TEXT self, int aDefaultWidth=0) -> int"""
 return _pcbnew.EDA_TEXT_GetEffectiveTextPenWidth(self, aDefaultWidth)
 
 def SetTextAngle(self, aAngle: "double") -> "void":
 r"""SetTextAngle(EDA_TEXT self, double aAngle)"""
 return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)
 
 def GetTextAngle(self) -> "double":
 r"""GetTextAngle(EDA_TEXT self) -> double"""
 return _pcbnew.EDA_TEXT_GetTextAngle(self)
 
 def GetTextAngleDegrees(self) -> "double":
 r"""GetTextAngleDegrees(EDA_TEXT self) -> double"""
 return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)
 
 def GetTextAngleRadians(self) -> "double":
 r"""GetTextAngleRadians(EDA_TEXT self) -> double"""
 return _pcbnew.EDA_TEXT_GetTextAngleRadians(self)
 
 def SetItalic(self, isItalic: "bool") -> "void":
 r"""SetItalic(EDA_TEXT self, bool isItalic)"""
 return _pcbnew.EDA_TEXT_SetItalic(self, isItalic)
 
 def IsItalic(self) -> "bool":
 r"""IsItalic(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_IsItalic(self)
 
 def SetBold(self, aBold: "bool") -> "void":
 r"""SetBold(EDA_TEXT self, bool aBold)"""
 return _pcbnew.EDA_TEXT_SetBold(self, aBold)
 
 def IsBold(self) -> "bool":
 r"""IsBold(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_IsBold(self)
 
 def SetVisible(self, aVisible: "bool") -> "void":
 r"""SetVisible(EDA_TEXT self, bool aVisible)"""
 return _pcbnew.EDA_TEXT_SetVisible(self, aVisible)
 
 def IsVisible(self) -> "bool":
 r"""IsVisible(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_IsVisible(self)
 
 def SetMirrored(self, isMirrored: "bool") -> "void":
 r"""SetMirrored(EDA_TEXT self, bool isMirrored)"""
 return _pcbnew.EDA_TEXT_SetMirrored(self, isMirrored)
 
 def IsMirrored(self) -> "bool":
 r"""IsMirrored(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_IsMirrored(self)
 
 def SetMultilineAllowed(self, aAllow: "bool") -> "void":
 r"""SetMultilineAllowed(EDA_TEXT self, bool aAllow)"""
 return _pcbnew.EDA_TEXT_SetMultilineAllowed(self, aAllow)
 
 def IsMultilineAllowed(self) -> "bool":
 r"""IsMultilineAllowed(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_IsMultilineAllowed(self)
 
 def GetHorizJustify(self) -> "EDA_TEXT_HJUSTIFY_T":
 r"""GetHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_GetHorizJustify(self)
 
 def GetVertJustify(self) -> "EDA_TEXT_VJUSTIFY_T":
 r"""GetVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_GetVertJustify(self)
 
 def SetHorizJustify(self, aType: "EDA_TEXT_HJUSTIFY_T") -> "void":
 r"""SetHorizJustify(EDA_TEXT self, EDA_TEXT_HJUSTIFY_T aType)"""
 return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)
 
 def SetVertJustify(self, aType: "EDA_TEXT_VJUSTIFY_T") -> "void":
 r"""SetVertJustify(EDA_TEXT self, EDA_TEXT_VJUSTIFY_T aType)"""
 return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)
 
 def SetEffects(self, aSrc: "EDA_TEXT") -> "void":
 r"""SetEffects(EDA_TEXT self, EDA_TEXT aSrc)"""
 return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)
 
 def SwapEffects(self, aTradingPartner: "EDA_TEXT") -> "void":
 r"""SwapEffects(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
 return _pcbnew.EDA_TEXT_SwapEffects(self, aTradingPartner)
 
 def SwapText(self, aTradingPartner: "EDA_TEXT") -> "void":
 r"""SwapText(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
 return _pcbnew.EDA_TEXT_SwapText(self, aTradingPartner)
 
 def CopyText(self, aSrc: "EDA_TEXT") -> "void":
 r"""CopyText(EDA_TEXT self, EDA_TEXT aSrc)"""
 return _pcbnew.EDA_TEXT_CopyText(self, aSrc)
 
 def Replace(self, aSearchData: "wxFindReplaceData const &") -> "bool":
 r"""Replace(EDA_TEXT self, wxFindReplaceData const & aSearchData) -> bool"""
 return _pcbnew.EDA_TEXT_Replace(self, aSearchData)
 
 def IsDefaultFormatting(self) -> "bool":
 r"""IsDefaultFormatting(EDA_TEXT self) -> bool"""
 return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)
 
 def SetTextSize(self, aNewSize: "wxSize") -> "void":
 r"""SetTextSize(EDA_TEXT self, wxSize aNewSize)"""
 return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize)
 
 def GetTextSize(self) -> "wxSize const &":
 r"""GetTextSize(EDA_TEXT self) -> wxSize"""
 return _pcbnew.EDA_TEXT_GetTextSize(self)
 
 def SetTextWidth(self, aWidth: "int") -> "void":
 r"""SetTextWidth(EDA_TEXT self, int aWidth)"""
 return _pcbnew.EDA_TEXT_SetTextWidth(self, aWidth)
 
 def GetTextWidth(self) -> "int":
 r"""GetTextWidth(EDA_TEXT self) -> int"""
 return _pcbnew.EDA_TEXT_GetTextWidth(self)
 
 def SetTextHeight(self, aHeight: "int") -> "void":
 r"""SetTextHeight(EDA_TEXT self, int aHeight)"""
 return _pcbnew.EDA_TEXT_SetTextHeight(self, aHeight)
 
 def GetTextHeight(self) -> "int":
 r"""GetTextHeight(EDA_TEXT self) -> int"""
 return _pcbnew.EDA_TEXT_GetTextHeight(self)
 
 def SetTextPos(self, aPoint: "wxPoint") -> "void":
 r"""SetTextPos(EDA_TEXT self, wxPoint aPoint)"""
 return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)
 
 def GetTextPos(self) -> "wxPoint const &":
 r"""GetTextPos(EDA_TEXT self) -> wxPoint"""
 return _pcbnew.EDA_TEXT_GetTextPos(self)
 
 def SetTextX(self, aX: "int") -> "void":
 r"""SetTextX(EDA_TEXT self, int aX)"""
 return _pcbnew.EDA_TEXT_SetTextX(self, aX)
 
 def SetTextY(self, aY: "int") -> "void":
 r"""SetTextY(EDA_TEXT self, int aY)"""
 return _pcbnew.EDA_TEXT_SetTextY(self, aY)
 
 def Offset(self, aOffset: "wxPoint") -> "void":
 r"""Offset(EDA_TEXT self, wxPoint aOffset)"""
 return _pcbnew.EDA_TEXT_Offset(self, aOffset)
 
 def Empty(self) -> "void":
 r"""Empty(EDA_TEXT self)"""
 return _pcbnew.EDA_TEXT_Empty(self)
 
 @staticmethod
 def MapHorizJustify(aHorizJustify: "int") -> "EDA_TEXT_HJUSTIFY_T":
 r"""MapHorizJustify(int aHorizJustify) -> EDA_TEXT_HJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_MapHorizJustify(aHorizJustify)
 
 @staticmethod
 def MapVertJustify(aVertJustify: "int") -> "EDA_TEXT_VJUSTIFY_T":
 r"""MapVertJustify(int aVertJustify) -> EDA_TEXT_VJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_MapVertJustify(aVertJustify)
 
 def Print(self, aSettings: "RENDER_SETTINGS const *", aOffset: "wxPoint", aColor: "COLOR4D", aDisplay_mode: "OUTLINE_MODE"=FILLED) -> "void":
 r"""Print(EDA_TEXT self, RENDER_SETTINGS const * aSettings, wxPoint aOffset, COLOR4D aColor, OUTLINE_MODE aDisplay_mode=FILLED)"""
 return _pcbnew.EDA_TEXT_Print(self, aSettings, aOffset, aColor, aDisplay_mode)
 
 def TransformToSegmentList(self) -> "std::vector< wxPoint,std::allocator< wxPoint > >":
 r"""TransformToSegmentList(EDA_TEXT self) -> wxPoint_Vector"""
 return _pcbnew.EDA_TEXT_TransformToSegmentList(self)
 
 def TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aClearanceValue: "int") -> "void":
 r"""TransformBoundingBoxWithClearanceToPolygon(EDA_TEXT self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue)"""
 return _pcbnew.EDA_TEXT_TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue)
 
 def GetEffectiveTextShape(self) -> "std::shared_ptr< SHAPE_COMPOUND >":
 r"""GetEffectiveTextShape(EDA_TEXT self) -> std::shared_ptr< SHAPE_COMPOUND >"""
 return _pcbnew.EDA_TEXT_GetEffectiveTextShape(self)
 
 def TextHitTest(self, *args) -> "bool":
 r"""
 TextHitTest(EDA_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
 TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains, int aAccuracy=0) -> bool
 """
 return _pcbnew.EDA_TEXT_TextHitTest(self, *args)
 
 def LenSize(self, aLine: "wxString", aThickness: "int") -> "int":
 r"""LenSize(EDA_TEXT self, wxString aLine, int aThickness) -> int"""
 return _pcbnew.EDA_TEXT_LenSize(self, aLine, aThickness)
 
 def GetTextBox(self, aLine: "int"=-1, aInvertY: "bool"=False) -> "EDA_RECT":
 r"""GetTextBox(EDA_TEXT self, int aLine=-1, bool aInvertY=False) -> EDA_RECT"""
 return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aInvertY)
 
 def GetInterline(self) -> "int":
 r"""GetInterline(EDA_TEXT self) -> int"""
 return _pcbnew.EDA_TEXT_GetInterline(self)
 
 def GetTextStyleName(self) -> "wxString":
 r"""GetTextStyleName(EDA_TEXT self) -> wxString"""
 return _pcbnew.EDA_TEXT_GetTextStyleName(self)
 
 def GetLinePositions(self, aPositions: "wxPoint_Vector", aLineCount: "int") -> "void":
 r"""GetLinePositions(EDA_TEXT self, wxPoint_Vector aPositions, int aLineCount)"""
 return _pcbnew.EDA_TEXT_GetLinePositions(self, aPositions, aLineCount)
 
 def Format(self, aFormatter: "OUTPUTFORMATTER", aNestLevel: "int", aControlBits: "int") -> "void":
 r"""Format(EDA_TEXT self, OUTPUTFORMATTER aFormatter, int aNestLevel, int aControlBits)"""
 return _pcbnew.EDA_TEXT_Format(self, aFormatter, aNestLevel, aControlBits)
 
 def GetDrawRotation(self) -> "double":
 r"""GetDrawRotation(EDA_TEXT self) -> double"""
 return _pcbnew.EDA_TEXT_GetDrawRotation(self)
 
 def GetDrawPos(self) -> "wxPoint":
 r"""GetDrawPos(EDA_TEXT self) -> wxPoint"""
 return _pcbnew.EDA_TEXT_GetDrawPos(self)
 
 def GetDrawHorizJustify(self) -> "EDA_TEXT_HJUSTIFY_T":
 r"""GetDrawHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_GetDrawHorizJustify(self)
 
 def GetDrawVertJustify(self) -> "EDA_TEXT_VJUSTIFY_T":
 r"""GetDrawVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_GetDrawVertJustify(self)
 
 def Compare(self, aOther: "EDA_TEXT") -> "int":
 r"""Compare(EDA_TEXT self, EDA_TEXT aOther) -> int"""
 return _pcbnew.EDA_TEXT_Compare(self, aOther)
 
# Register EDA_TEXT in _pcbnew:
_pcbnew.EDA_TEXT_swigregister(EDA_TEXT)
 
def EDA_TEXT_MapHorizJustify(aHorizJustify: "int") -> "EDA_TEXT_HJUSTIFY_T":
 r"""EDA_TEXT_MapHorizJustify(int aHorizJustify) -> EDA_TEXT_HJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_MapHorizJustify(aHorizJustify)
 
def EDA_TEXT_MapVertJustify(aVertJustify: "int") -> "EDA_TEXT_VJUSTIFY_T":
 r"""EDA_TEXT_MapVertJustify(int aVertJustify) -> EDA_TEXT_VJUSTIFY_T"""
 return _pcbnew.EDA_TEXT_MapVertJustify(aVertJustify)
 
 
def GetBuildVersion() -> "wxString":
 r"""GetBuildVersion() -> wxString"""
 return _pcbnew.GetBuildVersion()
 
def GetPlatformGetBitnessName() -> "wxString":
 r"""GetPlatformGetBitnessName() -> wxString"""
 return _pcbnew.GetPlatformGetBitnessName()
 
def GetSemanticVersion() -> "wxString":
 r"""GetSemanticVersion() -> wxString"""
 return _pcbnew.GetSemanticVersion()
 
def GetMajorMinorVersion() -> "wxString":
 r"""GetMajorMinorVersion() -> wxString"""
 return _pcbnew.GetMajorMinorVersion()
 
def GetBuildDate() -> "wxString":
 r"""GetBuildDate() -> wxString"""
 return _pcbnew.GetBuildDate()
 
def GetVersionInfoData(aTitle: "wxString", aHtml: "bool"=False, aBrief: "bool"=False) -> "wxString":
 r"""GetVersionInfoData(wxString aTitle, bool aHtml=False, bool aBrief=False) -> wxString"""
 return _pcbnew.GetVersionInfoData(aTitle, aHtml, aBrief)
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: "bool"=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) -> "bool":
 r"""IsOK(SETTINGS_MANAGER self) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_IsOK(self)
 
 def SetKiway(self, aKiway: "KIWAY *") -> "void":
 r"""SetKiway(SETTINGS_MANAGER self, KIWAY * aKiway)"""
 return _pcbnew.SETTINGS_MANAGER_SetKiway(self, aKiway)
 
 def Load(self, *args) -> "void":
 r"""
 Load(SETTINGS_MANAGER self)
 Load(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings)
 """
 return _pcbnew.SETTINGS_MANAGER_Load(self, *args)
 
 def Save(self, *args) -> "void":
 r"""
 Save(SETTINGS_MANAGER self)
 Save(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings)
 """
 return _pcbnew.SETTINGS_MANAGER_Save(self, *args)
 
 def FlushAndRelease(self, aSettings: "JSON_SETTINGS *", aSave: "bool"=True) -> "void":
 r"""FlushAndRelease(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings, bool aSave=True)"""
 return _pcbnew.SETTINGS_MANAGER_FlushAndRelease(self, aSettings, aSave)
 
 def GetColorSettings(self, *args) -> "COLOR_SETTINGS *":
 r"""GetColorSettings(SETTINGS_MANAGER self, wxString aName="user") -> COLOR_SETTINGS"""
 return _pcbnew.SETTINGS_MANAGER_GetColorSettings(self, *args)
 
 def GetColorSettingsList(self) -> "std::vector< COLOR_SETTINGS *,std::allocator< COLOR_SETTINGS * > >":
 r"""GetColorSettingsList(SETTINGS_MANAGER self) -> std::vector< COLOR_SETTINGS *,std::allocator< COLOR_SETTINGS * > >"""
 return _pcbnew.SETTINGS_MANAGER_GetColorSettingsList(self)
 
 def SaveColorSettings(self, *args) -> "void":
 r"""SaveColorSettings(SETTINGS_MANAGER self, COLOR_SETTINGS * aSettings, string aNamespace="")"""
 return _pcbnew.SETTINGS_MANAGER_SaveColorSettings(self, *args)
 
 def AddNewColorSettings(self, aFilename: "wxString") -> "COLOR_SETTINGS *":
 r"""AddNewColorSettings(SETTINGS_MANAGER self, wxString aFilename) -> COLOR_SETTINGS *"""
 return _pcbnew.SETTINGS_MANAGER_AddNewColorSettings(self, aFilename)
 
 def GetMigratedColorSettings(self) -> "COLOR_SETTINGS *":
 r"""GetMigratedColorSettings(SETTINGS_MANAGER self) -> COLOR_SETTINGS *"""
 return _pcbnew.SETTINGS_MANAGER_GetMigratedColorSettings(self)
 
 def GetCommonSettings(self) -> "COMMON_SETTINGS *":
 r"""GetCommonSettings(SETTINGS_MANAGER self) -> COMMON_SETTINGS *"""
 return _pcbnew.SETTINGS_MANAGER_GetCommonSettings(self)
 
 def GetPathForSettingsFile(self, aSettings: "JSON_SETTINGS *") -> "wxString":
 r"""GetPathForSettingsFile(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings) -> wxString"""
 return _pcbnew.SETTINGS_MANAGER_GetPathForSettingsFile(self, aSettings)
 
 def MigrateIfNeeded(self) -> "bool":
 r"""MigrateIfNeeded(SETTINGS_MANAGER self) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_MigrateIfNeeded(self)
 
 def SetMigrationSource(self, aSource: "wxString") -> "void":
 r"""SetMigrationSource(SETTINGS_MANAGER self, wxString aSource)"""
 return _pcbnew.SETTINGS_MANAGER_SetMigrationSource(self, aSource)
 
 def SetMigrateLibraryTables(self, aMigrate: "bool"=True) -> "void":
 r"""SetMigrateLibraryTables(SETTINGS_MANAGER self, bool aMigrate=True)"""
 return _pcbnew.SETTINGS_MANAGER_SetMigrateLibraryTables(self, aMigrate)
 
 def GetPreviousVersionPaths(self, aName: "std::vector< wxString,std::allocator< wxString > > *"=None) -> "bool":
 r"""GetPreviousVersionPaths(SETTINGS_MANAGER self, std::vector< wxString,std::allocator< wxString > > * aName=None) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_GetPreviousVersionPaths(self, aName)
 
 def ReloadColorSettings(self) -> "void":
 r"""ReloadColorSettings(SETTINGS_MANAGER self)"""
 return _pcbnew.SETTINGS_MANAGER_ReloadColorSettings(self)
 
 def LoadProject(self, aFullPath: "wxString", aSetActive: "bool"=True) -> "bool":
 r"""LoadProject(SETTINGS_MANAGER self, wxString aFullPath, bool aSetActive=True) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_LoadProject(self, aFullPath, aSetActive)
 
 def UnloadProject(self, aProject: "PROJECT *", aSave: "bool"=True) -> "bool":
 r"""UnloadProject(SETTINGS_MANAGER self, PROJECT * aProject, bool aSave=True) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_UnloadProject(self, aProject, aSave)
 
 def IsProjectOpen(self) -> "bool":
 r"""IsProjectOpen(SETTINGS_MANAGER self) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_IsProjectOpen(self)
 
 def Prj(self) -> "PROJECT &":
 r"""Prj(SETTINGS_MANAGER self) -> PROJECT &"""
 return _pcbnew.SETTINGS_MANAGER_Prj(self)
 
 def GetProject(self, aFullPath: "wxString") -> "PROJECT *":
 r"""GetProject(SETTINGS_MANAGER self, wxString aFullPath) -> PROJECT *"""
 return _pcbnew.SETTINGS_MANAGER_GetProject(self, aFullPath)
 
 def GetOpenProjects(self) -> "std::vector< wxString,std::allocator< wxString > >":
 r"""GetOpenProjects(SETTINGS_MANAGER self) -> std::vector< wxString,std::allocator< wxString > >"""
 return _pcbnew.SETTINGS_MANAGER_GetOpenProjects(self)
 
 def SaveProject(self, *args) -> "bool":
 r"""SaveProject(SETTINGS_MANAGER self, wxString aFullPath=wxEmptyString, PROJECT * aProject=None) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_SaveProject(self, *args)
 
 def SaveProjectAs(self, aFullPath: "wxString", aProject: "PROJECT *"=None) -> "void":
 r"""SaveProjectAs(SETTINGS_MANAGER self, wxString aFullPath, PROJECT * aProject=None)"""
 return _pcbnew.SETTINGS_MANAGER_SaveProjectAs(self, aFullPath, aProject)
 
 def SaveProjectCopy(self, aFullPath: "wxString", aProject: "PROJECT *"=None) -> "void":
 r"""SaveProjectCopy(SETTINGS_MANAGER self, wxString aFullPath, PROJECT * aProject=None)"""
 return _pcbnew.SETTINGS_MANAGER_SaveProjectCopy(self, aFullPath, aProject)
 
 def GetProjectBackupsPath(self) -> "wxString":
 r"""GetProjectBackupsPath(SETTINGS_MANAGER self) -> wxString"""
 return _pcbnew.SETTINGS_MANAGER_GetProjectBackupsPath(self)
 
 def BackupProject(self, aReporter: "REPORTER &") -> "bool":
 r"""BackupProject(SETTINGS_MANAGER self, REPORTER & aReporter) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_BackupProject(self, aReporter)
 
 def TriggerBackupIfNeeded(self, aReporter: "REPORTER &") -> "bool":
 r"""TriggerBackupIfNeeded(SETTINGS_MANAGER self, REPORTER & aReporter) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_TriggerBackupIfNeeded(self, aReporter)
 
 @staticmethod
 def IsSettingsPathValid(aPath: "wxString") -> "bool":
 r"""IsSettingsPathValid(wxString aPath) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_IsSettingsPathValid(aPath)
 
 @staticmethod
 def GetColorSettingsPath() -> "wxString":
 r"""GetColorSettingsPath() -> wxString"""
 return _pcbnew.SETTINGS_MANAGER_GetColorSettingsPath()
 
 @staticmethod
 def GetUserSettingsPath() -> "wxString":
 r"""GetUserSettingsPath() -> wxString"""
 return _pcbnew.SETTINGS_MANAGER_GetUserSettingsPath()
 
 @staticmethod
 def GetSettingsVersion() -> "std::string":
 r"""GetSettingsVersion() -> string"""
 return _pcbnew.SETTINGS_MANAGER_GetSettingsVersion()
 
# Register SETTINGS_MANAGER in _pcbnew:
_pcbnew.SETTINGS_MANAGER_swigregister(SETTINGS_MANAGER)
 
def SETTINGS_MANAGER_IsSettingsPathValid(aPath: "wxString") -> "bool":
 r"""SETTINGS_MANAGER_IsSettingsPathValid(wxString aPath) -> bool"""
 return _pcbnew.SETTINGS_MANAGER_IsSettingsPathValid(aPath)
 
def SETTINGS_MANAGER_GetColorSettingsPath() -> "wxString":
 r"""SETTINGS_MANAGER_GetColorSettingsPath() -> wxString"""
 return _pcbnew.SETTINGS_MANAGER_GetColorSettingsPath()
 
def SETTINGS_MANAGER_GetUserSettingsPath() -> "wxString":
 r"""SETTINGS_MANAGER_GetUserSettingsPath() -> wxString"""
 return _pcbnew.SETTINGS_MANAGER_GetUserSettingsPath()
 
def SETTINGS_MANAGER_GetSettingsVersion() -> "std::string":
 r"""SETTINGS_MANAGER_GetSettingsVersion() -> string"""
 return _pcbnew.SETTINGS_MANAGER_GetSettingsVersion()
 
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) -> "swig::SwigPyIterator *":
 r"""iterator(intVector self) -> SwigPyIterator"""
 return _pcbnew.intVector_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(intVector self) -> bool"""
 return _pcbnew.intVector___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(intVector self) -> bool"""
 return _pcbnew.intVector___bool__(self)
 
 def __len__(self) -> "std::vector< int >::size_type":
 r"""__len__(intVector self) -> std::vector< int >::size_type"""
 return _pcbnew.intVector___len__(self)
 
 def __getslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "std::vector< int,std::allocator< int > > *":
 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) -> "void":
 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: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "void":
 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) -> "void":
 r"""
 __delitem__(intVector self, std::vector< int >::difference_type i)
 __delitem__(intVector self, PySliceObject * slice)
 """
 return _pcbnew.intVector___delitem__(self, *args)
 
 def __getitem__(self, *args) -> "std::vector< int >::value_type const &":
 r"""
 __getitem__(intVector self, PySliceObject * slice) -> intVector
 __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
 """
 return _pcbnew.intVector___getitem__(self, *args)
 
 def __setitem__(self, *args) -> "void":
 r"""
 __setitem__(intVector self, PySliceObject * slice, intVector v)
 __setitem__(intVector self, PySliceObject * slice)
 __setitem__(intVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
 """
 return _pcbnew.intVector___setitem__(self, *args)
 
 def pop(self) -> "std::vector< int >::value_type":
 r"""pop(intVector self) -> std::vector< int >::value_type"""
 return _pcbnew.intVector_pop(self)
 
 def append(self, x: "std::vector< int >::value_type const &") -> "void":
 r"""append(intVector self, std::vector< int >::value_type const & x)"""
 return _pcbnew.intVector_append(self, x)
 
 def empty(self) -> "bool":
 r"""empty(intVector self) -> bool"""
 return _pcbnew.intVector_empty(self)
 
 def size(self) -> "std::vector< int >::size_type":
 r"""size(intVector self) -> std::vector< int >::size_type"""
 return _pcbnew.intVector_size(self)
 
 def swap(self, v: "intVector") -> "void":
 r"""swap(intVector self, intVector v)"""
 return _pcbnew.intVector_swap(self, v)
 
 def begin(self) -> "std::vector< int >::iterator":
 r"""begin(intVector self) -> std::vector< int >::iterator"""
 return _pcbnew.intVector_begin(self)
 
 def end(self) -> "std::vector< int >::iterator":
 r"""end(intVector self) -> std::vector< int >::iterator"""
 return _pcbnew.intVector_end(self)
 
 def rbegin(self) -> "std::vector< int >::reverse_iterator":
 r"""rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
 return _pcbnew.intVector_rbegin(self)
 
 def rend(self) -> "std::vector< int >::reverse_iterator":
 r"""rend(intVector self) -> std::vector< int >::reverse_iterator"""
 return _pcbnew.intVector_rend(self)
 
 def clear(self) -> "void":
 r"""clear(intVector self)"""
 return _pcbnew.intVector_clear(self)
 
 def get_allocator(self) -> "std::vector< int >::allocator_type":
 r"""get_allocator(intVector self) -> std::vector< int >::allocator_type"""
 return _pcbnew.intVector_get_allocator(self)
 
 def pop_back(self) -> "void":
 r"""pop_back(intVector self)"""
 return _pcbnew.intVector_pop_back(self)
 
 def erase(self, *args) -> "std::vector< int >::iterator":
 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: "std::vector< int >::value_type const &") -> "void":
 r"""push_back(intVector self, std::vector< int >::value_type const & x)"""
 return _pcbnew.intVector_push_back(self, x)
 
 def front(self) -> "std::vector< int >::value_type const &":
 r"""front(intVector self) -> std::vector< int >::value_type const &"""
 return _pcbnew.intVector_front(self)
 
 def back(self) -> "std::vector< int >::value_type const &":
 r"""back(intVector self) -> std::vector< int >::value_type const &"""
 return _pcbnew.intVector_back(self)
 
 def assign(self, n: "std::vector< int >::size_type", x: "std::vector< int >::value_type const &") -> "void":
 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) -> "void":
 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) -> "void":
 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: "std::vector< int >::size_type") -> "void":
 r"""reserve(intVector self, std::vector< int >::size_type n)"""
 return _pcbnew.intVector_reserve(self, n)
 
 def capacity(self) -> "std::vector< int >::size_type":
 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) -> "swig::SwigPyIterator *":
 r"""iterator(str_utf8_Map self) -> SwigPyIterator"""
 return _pcbnew.str_utf8_Map_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(str_utf8_Map self) -> bool"""
 return _pcbnew.str_utf8_Map___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(str_utf8_Map self) -> bool"""
 return _pcbnew.str_utf8_Map___bool__(self)
 
 def __len__(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type":
 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: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::mapped_type const &":
 r"""__getitem__(str_utf8_Map self, string key) -> UTF8"""
 return _pcbnew.str_utf8_Map___getitem__(self, key)
 
 def __delitem__(self, key: "string") -> "void":
 r"""__delitem__(str_utf8_Map self, string key)"""
 return _pcbnew.str_utf8_Map___delitem__(self, key)
 
 def has_key(self, key: "string") -> "bool":
 r"""has_key(str_utf8_Map self, string key) -> bool"""
 return _pcbnew.str_utf8_Map_has_key(self, key)
 
 def keys(self) -> "PyObject *":
 r"""keys(str_utf8_Map self) -> PyObject *"""
 return _pcbnew.str_utf8_Map_keys(self)
 
 def values(self) -> "PyObject *":
 r"""values(str_utf8_Map self) -> PyObject *"""
 return _pcbnew.str_utf8_Map_values(self)
 
 def items(self) -> "PyObject *":
 r"""items(str_utf8_Map self) -> PyObject *"""
 return _pcbnew.str_utf8_Map_items(self)
 
 def __contains__(self, key: "string") -> "bool":
 r"""__contains__(str_utf8_Map self, string key) -> bool"""
 return _pcbnew.str_utf8_Map___contains__(self, key)
 
 def key_iterator(self) -> "swig::SwigPyIterator *":
 r"""key_iterator(str_utf8_Map self) -> SwigPyIterator"""
 return _pcbnew.str_utf8_Map_key_iterator(self)
 
 def value_iterator(self) -> "swig::SwigPyIterator *":
 r"""value_iterator(str_utf8_Map self) -> SwigPyIterator"""
 return _pcbnew.str_utf8_Map_value_iterator(self)
 
 def __setitem__(self, *args) -> "void":
 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) -> "PyObject *":
 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) -> "bool":
 r"""empty(str_utf8_Map self) -> bool"""
 return _pcbnew.str_utf8_Map_empty(self)
 
 def size(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type":
 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: "str_utf8_Map") -> "void":
 r"""swap(str_utf8_Map self, str_utf8_Map v)"""
 return _pcbnew.str_utf8_Map_swap(self, v)
 
 def begin(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
 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) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
 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) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator":
 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) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator":
 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) -> "void":
 r"""clear(str_utf8_Map self)"""
 return _pcbnew.str_utf8_Map_clear(self)
 
 def get_allocator(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type":
 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: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type":
 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) -> "void":
 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: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
 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: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
 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: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
 r"""upper_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
 return _pcbnew.str_utf8_Map_upper_bound(self, x)
 __swig_destroy__ = _pcbnew.delete_str_utf8_Map
 
# Register str_utf8_Map in _pcbnew:
_pcbnew.str_utf8_Map_swigregister(str_utf8_Map)
 
class base_seqVect(object):
 r"""Proxy of C++ std::vector< enum PCB_LAYER_ID > class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 
 def iterator(self) -> "swig::SwigPyIterator *":
 r"""iterator(base_seqVect self) -> SwigPyIterator"""
 return _pcbnew.base_seqVect_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(base_seqVect self) -> bool"""
 return _pcbnew.base_seqVect___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(base_seqVect self) -> bool"""
 return _pcbnew.base_seqVect___bool__(self)
 
 def __len__(self) -> "std::vector< enum PCB_LAYER_ID >::size_type":
 r"""__len__(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
 return _pcbnew.base_seqVect___len__(self)
 
 def __getslice__(self, i: "std::vector< enum PCB_LAYER_ID >::difference_type", j: "std::vector< enum PCB_LAYER_ID >::difference_type") -> "std::vector< enum PCB_LAYER_ID,std::allocator< enum PCB_LAYER_ID > > *":
 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) -> "void":
 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: "std::vector< enum PCB_LAYER_ID >::difference_type", j: "std::vector< enum PCB_LAYER_ID >::difference_type") -> "void":
 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) -> "void":
 r"""
 __delitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i)
 __delitem__(base_seqVect self, PySliceObject * slice)
 """
 return _pcbnew.base_seqVect___delitem__(self, *args)
 
 def __getitem__(self, *args) -> "std::vector< enum PCB_LAYER_ID >::value_type const &":
 r"""
 __getitem__(base_seqVect self, PySliceObject * slice) -> base_seqVect
 __getitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i) -> std::vector< enum PCB_LAYER_ID >::value_type const &
 """
 return _pcbnew.base_seqVect___getitem__(self, *args)
 
 def __setitem__(self, *args) -> "void":
 r"""
 __setitem__(base_seqVect self, PySliceObject * slice, base_seqVect v)
 __setitem__(base_seqVect self, PySliceObject * slice)
 __setitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::value_type const & x)
 """
 return _pcbnew.base_seqVect___setitem__(self, *args)
 
 def pop(self) -> "std::vector< enum PCB_LAYER_ID >::value_type":
 r"""pop(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type"""
 return _pcbnew.base_seqVect_pop(self)
 
 def append(self, x: "std::vector< enum PCB_LAYER_ID >::value_type const &") -> "void":
 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) -> "bool":
 r"""empty(base_seqVect self) -> bool"""
 return _pcbnew.base_seqVect_empty(self)
 
 def size(self) -> "std::vector< enum PCB_LAYER_ID >::size_type":
 r"""size(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
 return _pcbnew.base_seqVect_size(self)
 
 def swap(self, v: "base_seqVect") -> "void":
 r"""swap(base_seqVect self, base_seqVect v)"""
 return _pcbnew.base_seqVect_swap(self, v)
 
 def begin(self) -> "std::vector< enum PCB_LAYER_ID >::iterator":
 r"""begin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
 return _pcbnew.base_seqVect_begin(self)
 
 def end(self) -> "std::vector< enum PCB_LAYER_ID >::iterator":
 r"""end(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
 return _pcbnew.base_seqVect_end(self)
 
 def rbegin(self) -> "std::vector< enum PCB_LAYER_ID >::reverse_iterator":
 r"""rbegin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
 return _pcbnew.base_seqVect_rbegin(self)
 
 def rend(self) -> "std::vector< enum PCB_LAYER_ID >::reverse_iterator":
 r"""rend(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
 return _pcbnew.base_seqVect_rend(self)
 
 def clear(self) -> "void":
 r"""clear(base_seqVect self)"""
 return _pcbnew.base_seqVect_clear(self)
 
 def get_allocator(self) -> "std::vector< enum PCB_LAYER_ID >::allocator_type":
 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) -> "void":
 r"""pop_back(base_seqVect self)"""
 return _pcbnew.base_seqVect_pop_back(self)
 
 def erase(self, *args) -> "std::vector< enum PCB_LAYER_ID >::iterator":
 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: "std::vector< enum PCB_LAYER_ID >::value_type const &") -> "void":
 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) -> "std::vector< enum PCB_LAYER_ID >::value_type const &":
 r"""front(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
 return _pcbnew.base_seqVect_front(self)
 
 def back(self) -> "std::vector< enum PCB_LAYER_ID >::value_type const &":
 r"""back(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
 return _pcbnew.base_seqVect_back(self)
 
 def assign(self, n: "std::vector< enum PCB_LAYER_ID >::size_type", x: "std::vector< enum PCB_LAYER_ID >::value_type const &") -> "void":
 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) -> "void":
 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) -> "void":
 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: "std::vector< enum PCB_LAYER_ID >::size_type") -> "void":
 r"""reserve(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n)"""
 return _pcbnew.base_seqVect_reserve(self, n)
 
 def capacity(self) -> "std::vector< enum PCB_LAYER_ID >::size_type":
 r"""capacity(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
 return _pcbnew.base_seqVect_capacity(self)
 __swig_destroy__ = _pcbnew.delete_base_seqVect
 
# Register base_seqVect in _pcbnew:
_pcbnew.base_seqVect_swigregister(base_seqVect)
 
 
 
KICAD_PLUGINS={} # the list of loaded footprint wizards
 
""" the list of not loaded python scripts
 (usually because there is a syntax error in python script)
 this is the python script full filenames list.
 filenames are separated by '\n'
"""
NOT_LOADED_WIZARDS=""
 
""" the list of paths used to search python scripts.
 Stored here to be displayed on request in Pcbnew
 paths are separated by '\n'
"""
PLUGIN_DIRECTORIES_SEARCH=""
 
"""
 the trace of errors during execution of footprint wizards scripts
 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 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
 
 
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: "SHAPE_TYPE") -> "wxString":
 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: "SHAPE_TYPE"):
 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) -> "SHAPE_TYPE":
 r"""Type(SHAPE_BASE self) -> SHAPE_TYPE"""
 return _pcbnew.SHAPE_BASE_Type(self)
 
 def TypeName(self) -> "wxString":
 r"""TypeName(SHAPE_BASE self) -> wxString"""
 return _pcbnew.SHAPE_BASE_TypeName(self)
 
 def HasIndexableSubshapes(self) -> "bool":
 r"""HasIndexableSubshapes(SHAPE_BASE self) -> bool"""
 return _pcbnew.SHAPE_BASE_HasIndexableSubshapes(self)
 
 def GetIndexableSubshapeCount(self) -> "size_t":
 r"""GetIndexableSubshapeCount(SHAPE_BASE self) -> size_t"""
 return _pcbnew.SHAPE_BASE_GetIndexableSubshapeCount(self)
 
 def GetIndexableSubshapes(self, aSubshapes: "std::vector< SHAPE *,std::allocator< SHAPE * > > &") -> "void":
 r"""GetIndexableSubshapes(SHAPE_BASE self, std::vector< SHAPE *,std::allocator< SHAPE * > > & 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) -> "SHAPE *":
 r"""Clone(SHAPE self) -> SHAPE"""
 return _pcbnew.SHAPE_Clone(self)
 
 def IsNull(self) -> "bool":
 r"""IsNull(SHAPE self) -> bool"""
 return _pcbnew.SHAPE_IsNull(self)
 
 def Collide(self, *args) -> "bool":
 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 const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
 """
 return _pcbnew.SHAPE_Collide(self, *args)
 
 def BBox(self, aClearance: "int"=0) -> "BOX2I const":
 r"""BBox(SHAPE self, int aClearance=0) -> BOX2I const"""
 return _pcbnew.SHAPE_BBox(self, aClearance)
 
 def Centre(self) -> "VECTOR2I":
 r"""Centre(SHAPE self) -> VECTOR2I"""
 return _pcbnew.SHAPE_Centre(self)
 
 def Rotate(self, *args) -> "void":
 r"""Rotate(SHAPE self, double aAngle, VECTOR2I aCenter={ 0, 0 })"""
 return _pcbnew.SHAPE_Rotate(self, *args)
 
 def Move(self, aVector: "VECTOR2I") -> "void":
 r"""Move(SHAPE self, VECTOR2I aVector)"""
 return _pcbnew.SHAPE_Move(self, aVector)
 
 def IsSolid(self) -> "bool":
 r"""IsSolid(SHAPE self) -> bool"""
 return _pcbnew.SHAPE_IsSolid(self)
 
 def Parse(self, aStream: "std::stringstream &") -> "bool":
 r"""Parse(SHAPE self, std::stringstream & aStream) -> bool"""
 return _pcbnew.SHAPE_Parse(self, aStream)
 
 def Format(self) -> "std::string const":
 r"""Format(SHAPE self) -> string"""
 return _pcbnew.SHAPE_Format(self)
 
# 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) -> "bool":
 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 const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
 """
 return _pcbnew.SHAPE_LINE_CHAIN_BASE_Collide(self, *args)
 
 def SquaredDistance(self, aP: "VECTOR2I", aOutlineOnly: "bool"=False) -> "SEG::ecoord":
 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: "VECTOR2I", aAccuracy: "int"=0, aUseBBoxCache: "bool"=False) -> "bool":
 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: "VECTOR2I", aAccuracy: "int"=0) -> "bool":
 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: "VECTOR2I", aAccuracy: "int"=0) -> "int":
 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: "int") -> "VECTOR2I const":
 r"""GetPoint(SHAPE_LINE_CHAIN_BASE self, int aIndex) -> VECTOR2I"""
 return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetPoint(self, aIndex)
 
 def GetSegment(self, aIndex: "int") -> "SEG const":
 r"""GetSegment(SHAPE_LINE_CHAIN_BASE self, int aIndex) -> SEG const"""
 return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetSegment(self, aIndex)
 
 def GetPointCount(self) -> "size_t":
 r"""GetPointCount(SHAPE_LINE_CHAIN_BASE self) -> size_t"""
 return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetPointCount(self)
 
 def GetSegmentCount(self) -> "size_t":
 r"""GetSegmentCount(SHAPE_LINE_CHAIN_BASE self) -> size_t"""
 return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetSegmentCount(self)
 
 def IsClosed(self) -> "bool":
 r"""IsClosed(SHAPE_LINE_CHAIN_BASE self) -> bool"""
 return _pcbnew.SHAPE_LINE_CHAIN_BASE_IsClosed(self)
 
 def GetCachedBBox(self) -> "BOX2I *":
 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 VECTOR2I(object):
 r"""Proxy of C++ VECTOR2< int > class."""
 
 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 __repr__ = _swig_repr
 x = property(_pcbnew.VECTOR2I_x_get, _pcbnew.VECTOR2I_x_set, doc=r"""x : int""")
 y = property(_pcbnew.VECTOR2I_y_get, _pcbnew.VECTOR2I_y_set, doc=r"""y : int""")
 
 def __init__(self, *args):
 r"""
 __init__(VECTOR2I self) -> VECTOR2I
 __init__(VECTOR2I self, wxPoint aPoint) -> VECTOR2I
 __init__(VECTOR2I self, wxSize aSize) -> VECTOR2I
 __init__(VECTOR2I self, int x, int y) -> VECTOR2I
 __init__(VECTOR2I self, VECTOR2I aVec) -> VECTOR2I
 """
 _pcbnew.VECTOR2I_swiginit(self, _pcbnew.new_VECTOR2I(*args))
 
 def getWxPoint(self) -> "wxPoint":
 r"""getWxPoint(VECTOR2I self) -> wxPoint"""
 return _pcbnew.VECTOR2I_getWxPoint(self)
 
 def EuclideanNorm(self) -> "int":
 r"""EuclideanNorm(VECTOR2I self) -> int"""
 return _pcbnew.VECTOR2I_EuclideanNorm(self)
 
 def SquaredEuclideanNorm(self) -> "VECTOR2< int >::extended_type":
 r"""SquaredEuclideanNorm(VECTOR2I self) -> VECTOR2< int >::extended_type"""
 return _pcbnew.VECTOR2I_SquaredEuclideanNorm(self)
 
 def Perpendicular(self) -> "VECTOR2< int >":
 r"""Perpendicular(VECTOR2I self) -> VECTOR2I"""
 return _pcbnew.VECTOR2I_Perpendicular(self)
 
 def Resize(self, aNewLength: "int") -> "VECTOR2< int >":
 r"""Resize(VECTOR2I self, int aNewLength) -> VECTOR2I"""
 return _pcbnew.VECTOR2I_Resize(self, aNewLength)
 
 def Angle(self) -> "double":
 r"""Angle(VECTOR2I self) -> double"""
 return _pcbnew.VECTOR2I_Angle(self)
 
 def Rotate(self, aAngle: "double") -> "VECTOR2< int >":
 r"""Rotate(VECTOR2I self, double aAngle) -> VECTOR2I"""
 return _pcbnew.VECTOR2I_Rotate(self, aAngle)
 
 def Format(self) -> "std::string const":
 r"""Format(VECTOR2I self) -> string"""
 return _pcbnew.VECTOR2I_Format(self)
 
 def Cross(self, aVector: "VECTOR2I") -> "VECTOR2< int >::extended_type":
 r"""Cross(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
 return _pcbnew.VECTOR2I_Cross(self, aVector)
 
 def Dot(self, aVector: "VECTOR2I") -> "VECTOR2< int >::extended_type":
 r"""Dot(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
 return _pcbnew.VECTOR2I_Dot(self, aVector)
 
 def __add__(self, *args) -> "VECTOR2< int >":
 r"""
 __add__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
 __add__(VECTOR2I self, int const & aScalar) -> VECTOR2I
 """
 return _pcbnew.VECTOR2I___add__(self, *args)
 
 def __iadd__(self, *args) -> "VECTOR2< int > &":
 r"""
 __iadd__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
 __iadd__(VECTOR2I self, int const & aScalar) -> VECTOR2I
 """
 return _pcbnew.VECTOR2I___iadd__(self, *args)
 
 def __sub__(self, *args) -> "VECTOR2< int >":
 r"""
 __sub__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
 __sub__(VECTOR2I self, int const & aScalar) -> VECTOR2I
 """
 return _pcbnew.VECTOR2I___sub__(self, *args)
 
 def __isub__(self, *args) -> "VECTOR2< int > &":
 r"""
 __isub__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
 __isub__(VECTOR2I self, int const & aScalar) -> VECTOR2I
 """
 return _pcbnew.VECTOR2I___isub__(self, *args)
 
 def __neg__(self) -> "VECTOR2< int >":
 r"""__neg__(VECTOR2I self) -> VECTOR2I"""
 return _pcbnew.VECTOR2I___neg__(self)
 
 def __mul__(self, *args) -> "VECTOR2< int >":
 r"""
 __mul__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type
 __mul__(VECTOR2I self, int const & aFactor) -> VECTOR2I
 """
 return _pcbnew.VECTOR2I___mul__(self, *args)
 
 def __truediv__(self, *args):
 return _pcbnew.VECTOR2I___truediv__(self, *args)
 __div__ = __truediv__
 
 
 
 def __eq__(self, aVector: "VECTOR2I") -> "bool":
 r"""__eq__(VECTOR2I self, VECTOR2I aVector) -> bool"""
 return _pcbnew.VECTOR2I___eq__(self, aVector)
 
 def __ne__(self, aVector: "VECTOR2I") -> "bool":
 r"""__ne__(VECTOR2I self, VECTOR2I aVector) -> bool"""
 return _pcbnew.VECTOR2I___ne__(self, aVector)
 
 def __lt__(self, aVector: "VECTOR2I") -> "bool":
 r"""__lt__(VECTOR2I self, VECTOR2I aVector) -> bool"""
 return _pcbnew.VECTOR2I___lt__(self, aVector)
 
 def __le__(self, aVector: "VECTOR2I") -> "bool":
 r"""__le__(VECTOR2I self, VECTOR2I aVector) -> bool"""
 return _pcbnew.VECTOR2I___le__(self, aVector)
 
 def __gt__(self, aVector: "VECTOR2I") -> "bool":
 r"""__gt__(VECTOR2I self, VECTOR2I aVector) -> bool"""
 return _pcbnew.VECTOR2I___gt__(self, aVector)
 
 def __ge__(self, aVector: "VECTOR2I") -> "bool":
 r"""__ge__(VECTOR2I self, VECTOR2I aVector) -> bool"""
 return _pcbnew.VECTOR2I___ge__(self, aVector)
 
 def Set(self, x: "long", y: "long") -> "void":
 r"""Set(VECTOR2I self, long x, long y)"""
 return _pcbnew.VECTOR2I_Set(self, x, y)
 
 def Get(self) -> "PyObject *":
 r"""Get(VECTOR2I self) -> PyObject *"""
 return _pcbnew.VECTOR2I_Get(self)
 
 def __eq__(self,other): return (self.x==other.x and self.y==other.y)
 def __ne__(self,other): return not (self==other)
 def __str__(self): return str(self.Get())
 def __repr__(self): return '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.x = val
 elif index == 1:
 self.y = val
 else:
 raise IndexError
 def __nonzero__(self): return self.Get() != (0,0)
 
 
 __swig_destroy__ = _pcbnew.delete_VECTOR2I
 
# Register VECTOR2I in _pcbnew:
_pcbnew.VECTOR2I_swigregister(VECTOR2I)
 
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) -> "swig::SwigPyIterator *":
 r"""iterator(VECTOR_VECTOR2I self) -> SwigPyIterator"""
 return _pcbnew.VECTOR_VECTOR2I_iterator(self)
 def __iter__(self):
 return self.iterator()
 
 def __nonzero__(self) -> "bool":
 r"""__nonzero__(VECTOR_VECTOR2I self) -> bool"""
 return _pcbnew.VECTOR_VECTOR2I___nonzero__(self)
 
 def __bool__(self) -> "bool":
 r"""__bool__(VECTOR_VECTOR2I self) -> bool"""
 return _pcbnew.VECTOR_VECTOR2I___bool__(self)
 
 def __len__(self) -> "std::vector< VECTOR2< int > >::size_type":
 r"""__len__(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
 return _pcbnew.VECTOR_VECTOR2I___len__(self)
 
 def __getslice__(self, i: "std::vector< VECTOR2< int > >::difference_type", j: "std::vector< VECTOR2< int > >::difference_type") -> "std::vector< VECTOR2< int >,std::allocator< VECTOR2< int > > > *":
 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) -> "void":
 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: "std::vector< VECTOR2< int > >::difference_type", j: "std::vector< VECTOR2< int > >::difference_type") -> "void":
 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) -> "void":
 r"""
 __delitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i)
 __delitem__(VECTOR_VECTOR2I self, PySliceObject * slice)
 """
 return _pcbnew.VECTOR_VECTOR2I___delitem__(self, *args)
 
 def __getitem__(self, *args) -> "std::vector< VECTOR2< int > >::value_type const &":
 r"""
 __getitem__(VECTOR_VECTOR2I self, PySliceObject * 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) -> "void":
 r"""
 __setitem__(VECTOR_VECTOR2I self, PySliceObject * slice, VECTOR_VECTOR2I v)
 __setitem__(VECTOR_VECTOR2I self, PySliceObject * slice)
 __setitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, VECTOR2I x)
 """
 return _pcbnew.VECTOR_VECTOR2I___setitem__(self, *args)
 
 def pop(self) -> "std::vector< VECTOR2< int > >::value_type":
 r"""pop(VECTOR_VECTOR2I self) -> VECTOR2I"""
 return _pcbnew.VECTOR_VECTOR2I_pop(self)
 
 def append(self, x: "VECTOR2I") -> "void":
 r"""append(VECTOR_VECTOR2I self, VECTOR2I x)"""
 return _pcbnew.VECTOR_VECTOR2I_append(self, x)
 
 def empty(self) -> "bool":
 r"""empty(VECTOR_VECTOR2I self) -> bool"""
 return _pcbnew.VECTOR_VECTOR2I_empty(self)
 
 def size(self) -> "std::vector< VECTOR2< int > >::size_type":
 r"""size(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
 return _pcbnew.VECTOR_VECTOR2I_size(self)
 
 def swap(self, v: "VECTOR_VECTOR2I") -> "void":
 r"""swap(VECTOR_VECTOR2I self, VECTOR_VECTOR2I v)"""
 return _pcbnew.VECTOR_VECTOR2I_swap(self, v)
 
 def begin(self) -> "std::vector< VECTOR2< int > >::iterator":
 r"""begin(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::iterator"""
 return _pcbnew.VECTOR_VECTOR2I_begin(self)
 
 def end(self) -> "std::vector< VECTOR2< int > >::iterator":
 r"""end(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::iterator"""
 return _pcbnew.VECTOR_VECTOR2I_end(self)
 
 def rbegin(self) -> "std::vector< VECTOR2< int > >::reverse_iterator":
 r"""rbegin(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::reverse_iterator"""
 return _pcbnew.VECTOR_VECTOR2I_rbegin(self)
 
 def rend(self) -> "std::vector< VECTOR2< int > >::reverse_iterator":
 r"""rend(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::reverse_iterator"""
 return _pcbnew.VECTOR_VECTOR2I_rend(self)
 
 def clear(self) -> "void":
 r"""clear(VECTOR_VECTOR2I self)"""
 return _pcbnew.VECTOR_VECTOR2I_clear(self)
 
 def get_allocator(self) -> "std::vector< VECTOR2< int > >::allocator_type":
 r"""get_allocator(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::allocator_type"""
 return _pcbnew.VECTOR_VECTOR2I_get_allocator(self)
 
 def pop_back(self) -> "void":
 r"""pop_back(VECTOR_VECTOR2I self)"""
 return _pcbnew.VECTOR_VECTOR2I_pop_back(self)
 
 def erase(self, *args) -> "std::vector< VECTOR2< int > >::iterator":
 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: "VECTOR2I") -> "void":
 r"""push_back(VECTOR_VECTOR2I self, VECTOR2I x)"""
 return _pcbnew.VECTOR_VECTOR2I_push_back(self, x)
 
 def front(self) -> "std::vector< VECTOR2< int > >::value_type const &":
 r"""front(VECTOR_VECTOR2I self) -> VECTOR2I"""
 return _pcbnew.VECTOR_VECTOR2I_front(self)
 
 def back(self) -> "std::vector< VECTOR2< int > >::value_type const &":
 r"""back(VECTOR_VECTOR2I self) -> VECTOR2I"""
 return _pcbnew.VECTOR_VECTOR2I_back(self)
 
 def assign(self, n: "std::vector< VECTOR2< int > >::size_type", x: "VECTOR2I") -> "void":
 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) -> "void":
 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) -> "void":
 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: "std::vector< VECTOR2< int > >::size_type") -> "void":
 r"""reserve(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type n)"""
 return _pcbnew.VECTOR_VECTOR2I_reserve(self, n)
 
 def capacity(self) -> "std::vector< VECTOR2< int > >::size_type":
 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)
 
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, wxPoint_Vector aV, bool aClosed=False) -> SHAPE_LINE_CHAIN
 __init__(SHAPE_LINE_CHAIN self, VECTOR_VECTOR2I aV, bool aClosed=False) -> SHAPE_LINE_CHAIN
 __init__(SHAPE_LINE_CHAIN self, SHAPE_ARC const & aArc, bool aClosed=False) -> SHAPE_LINE_CHAIN
 __init__(SHAPE_LINE_CHAIN self, ClipperLib::Path 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) -> "bool":
 r"""
 Collide(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
 Collide(SHAPE_LINE_CHAIN self, SEG const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
 """
 return _pcbnew.SHAPE_LINE_CHAIN_Collide(self, *args)
 
 def Clone(self) -> "SHAPE *":
 r"""Clone(SHAPE_LINE_CHAIN self) -> SHAPE"""
 return _pcbnew.SHAPE_LINE_CHAIN_Clone(self)
 
 def Clear(self) -> "void":
 r"""Clear(SHAPE_LINE_CHAIN self)"""
 return _pcbnew.SHAPE_LINE_CHAIN_Clear(self)
 
 def SetClosed(self, aClosed: "bool") -> "void":
 r"""SetClosed(SHAPE_LINE_CHAIN self, bool aClosed)"""
 return _pcbnew.SHAPE_LINE_CHAIN_SetClosed(self, aClosed)
 
 def IsClosed(self) -> "bool":
 r"""IsClosed(SHAPE_LINE_CHAIN self) -> bool"""
 return _pcbnew.SHAPE_LINE_CHAIN_IsClosed(self)
 
 def SetWidth(self, aWidth: "int") -> "void":
 r"""SetWidth(SHAPE_LINE_CHAIN self, int aWidth)"""
 return _pcbnew.SHAPE_LINE_CHAIN_SetWidth(self, aWidth)
 
 def Width(self) -> "int":
 r"""Width(SHAPE_LINE_CHAIN self) -> int"""
 return _pcbnew.SHAPE_LINE_CHAIN_Width(self)
 
 def SegmentCount(self) -> "int":
 r"""SegmentCount(SHAPE_LINE_CHAIN self) -> int"""
 return _pcbnew.SHAPE_LINE_CHAIN_SegmentCount(self)
 
 def ShapeCount(self) -> "int":
 r"""ShapeCount(SHAPE_LINE_CHAIN self) -> int"""
 return _pcbnew.SHAPE_LINE_CHAIN_ShapeCount(self)
 
 def PointCount(self) -> "int":
 r"""PointCount(SHAPE_LINE_CHAIN self) -> int"""
 return _pcbnew.SHAPE_LINE_CHAIN_PointCount(self)
 
 def Segment(self, aIndex: "int") -> "SEG":
 r"""Segment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG"""
 return _pcbnew.SHAPE_LINE_CHAIN_Segment(self, aIndex)
 
 def CSegment(self, aIndex: "int") -> "SEG const":
 r"""CSegment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG const"""
 return _pcbnew.SHAPE_LINE_CHAIN_CSegment(self, aIndex)
 
 def NextShape(self, aPointIndex: "int", aForwards: "bool"=True) -> "int":
 r"""NextShape(SHAPE_LINE_CHAIN self, int aPointIndex, bool aForwards=True) -> int"""
 return _pcbnew.SHAPE_LINE_CHAIN_NextShape(self, aPointIndex, aForwards)
 
 def PrevShape(self, aPointIndex: "int") -> "int":
 r"""PrevShape(SHAPE_LINE_CHAIN self, int aPointIndex) -> int"""
 return _pcbnew.SHAPE_LINE_CHAIN_PrevShape(self, aPointIndex)
 
 def SetPoint(self, aIndex: "int", aPos: "VECTOR2I") -> "void":
 r"""SetPoint(SHAPE_LINE_CHAIN self, int aIndex, VECTOR2I aPos)"""
 return _pcbnew.SHAPE_LINE_CHAIN_SetPoint(self, aIndex, aPos)
 
 def CPoint(self, aIndex: "int") -> "VECTOR2I const &":
 r"""CPoint(SHAPE_LINE_CHAIN self, int aIndex) -> VECTOR2I"""
 return _pcbnew.SHAPE_LINE_CHAIN_CPoint(self, aIndex)
 
 def