pcbnew_temp.py

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

from sys import version_info as _swig_python_version_info
if False:
    raise RuntimeError('Python 2.7 or later required')

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
        __init__(string self) -> string
        __init__(string self, string other) -> string
        __init__(string self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string
        """
        _pcbnew.string_swiginit(self, _pcbnew.new_string(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SHARED_PTR_DISOWN = _pcbnew.SHARED_PTR_DISOWN

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

    def __init__(self, *args):
        r"""
        __init__(wxRect self) -> wxRect
        __init__(wxRect self, int xx, int yy, int ww, int hh) -> wxRect
        __init__(wxRect self, wxPoint topLeft, wxPoint bottomRight) -> wxRect
        __init__(wxRect self, wxPoint pt, wxSize size) -> wxRect
        __init__(wxRect self, wxSize size) -> wxRect
        """
        _pcbnew.wxRect_swiginit(self, _pcbnew.new_wxRect(*args))

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

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

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

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

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

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

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

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

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

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

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


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

    __swig_destroy__ = _pcbnew.delete_wxRect

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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



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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

def GetChars(s):
    r"""GetChars(wxString s) -> wxChar const *"""
    return _pcbnew.GetChars(s)
NOT_USED = _pcbnew.NOT_USED

EOT = _pcbnew.EOT

TYPE_NOT_INIT = _pcbnew.TYPE_NOT_INIT

PCB_T = _pcbnew.PCB_T

SCREEN_T = _pcbnew.SCREEN_T

PCB_MODULE_T = _pcbnew.PCB_MODULE_T

PCB_PAD_T = _pcbnew.PCB_PAD_T

PCB_LINE_T = _pcbnew.PCB_LINE_T

PCB_TEXT_T = _pcbnew.PCB_TEXT_T

PCB_MODULE_TEXT_T = _pcbnew.PCB_MODULE_TEXT_T

PCB_MODULE_EDGE_T = _pcbnew.PCB_MODULE_EDGE_T

PCB_TRACE_T = _pcbnew.PCB_TRACE_T

PCB_VIA_T = _pcbnew.PCB_VIA_T

PCB_MARKER_T = _pcbnew.PCB_MARKER_T

PCB_DIMENSION_T = _pcbnew.PCB_DIMENSION_T

PCB_TARGET_T = _pcbnew.PCB_TARGET_T

PCB_ZONE_AREA_T = _pcbnew.PCB_ZONE_AREA_T

PCB_ITEM_LIST_T = _pcbnew.PCB_ITEM_LIST_T

PCB_NETINFO_T = _pcbnew.PCB_NETINFO_T

SCH_MARKER_T = _pcbnew.SCH_MARKER_T

SCH_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_COMPONENT_T = _pcbnew.SCH_COMPONENT_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_LOCATE_ANY_T = _pcbnew.SCH_LOCATE_ANY_T

SCH_SCREEN_T = _pcbnew.SCH_SCREEN_T