KiCAD pcbnew scripting
pcbnew.py
Go to the documentation of this file.
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.7
3 #
4 # Do not make changes to this file unless you know what you are doing--modify
5 # the SWIG interface file instead.
6 
7 
8 
9 
10 
11 from sys import version_info
12 if False:
14  from os.path import dirname
15  import imp
16  fp = None
17  try:
18  fp, pathname, description = imp.find_module('_pcbnew', [dirname(__file__)])
19  except ImportError:
20  import _pcbnew
21  return _pcbnew
22  if fp is not None:
23  try:
24  _mod = imp.load_module('_pcbnew', fp, pathname, description)
25  finally:
26  fp.close()
27  return _mod
28  _pcbnew = swig_import_helper()
29  del swig_import_helper
30 else:
31  import _pcbnew
32 del version_info
33 try:
34  _swig_property = property
35 except NameError:
36  pass # Python < 2.2 doesn't have 'property'.
37 
38 
39 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
40  if (name == "thisown"):
41  return self.this.own(value)
42  if (name == "this"):
43  if type(value).__name__ == 'SwigPyObject':
44  self.__dict__[name] = value
45  return
46  method = class_type.__swig_setmethods__.get(name, None)
47  if method:
48  return method(self, value)
49  if (not static):
50  if _newclass:
51  object.__setattr__(self, name, value)
52  else:
53  self.__dict__[name] = value
54  else:
55  raise AttributeError("You cannot add attributes to %s" % self)
56 
57 
58 def _swig_setattr(self, class_type, name, value):
59  return _swig_setattr_nondynamic(self, class_type, name, value, 0)
60 
61 
62 def _swig_getattr_nondynamic(self, class_type, name, static=1):
63  if (name == "thisown"):
64  return self.this.own()
65  method = class_type.__swig_getmethods__.get(name, None)
66  if method:
67  return method(self)
68  if (not static):
69  return object.__getattr__(self, name)
70  else:
71  raise AttributeError(name)
72 
73 def _swig_getattr(self, class_type, name):
74  return _swig_getattr_nondynamic(self, class_type, name, 0)
75 
76 
77 def _swig_repr(self):
78  try:
79  strthis = "proxy of " + self.this.__repr__()
80  except:
81  strthis = ""
82  return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
83 
84 try:
85  _object = object
86  _newclass = 1
87 except AttributeError:
88  class _object:
89  pass
90  _newclass = 0
91 
92 
94  """Proxy of C++ swig::SwigPyIterator class"""
95  __swig_setmethods__ = {}
96  __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
97  __swig_getmethods__ = {}
98  __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
99 
100  def __init__(self, *args, **kwargs):
101  raise AttributeError("No constructor defined - class is abstract")
102  __repr__ = _swig_repr
103  __swig_destroy__ = _pcbnew.delete_SwigPyIterator
104  __del__ = lambda self: None
105 
106  def value(self):
107  """value(SwigPyIterator self) -> PyObject *"""
108  return _pcbnew.SwigPyIterator_value(self)
109 
110 
111  def incr(self, n=1):
112  """
113  incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
114  incr(SwigPyIterator self) -> SwigPyIterator
115  """
116  return _pcbnew.SwigPyIterator_incr(self, n)
117 
118 
119  def decr(self, n=1):
120  """
121  decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
122  decr(SwigPyIterator self) -> SwigPyIterator
123  """
124  return _pcbnew.SwigPyIterator_decr(self, n)
125 
126 
127  def distance(self, x):
128  """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
129  return _pcbnew.SwigPyIterator_distance(self, x)
130 
131 
132  def equal(self, x):
133  """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
134  return _pcbnew.SwigPyIterator_equal(self, x)
135 
136 
137  def copy(self):
138  """copy(SwigPyIterator self) -> SwigPyIterator"""
139  return _pcbnew.SwigPyIterator_copy(self)
140 
141 
142  def next(self):
143  """next(SwigPyIterator self) -> PyObject *"""
144  return _pcbnew.SwigPyIterator_next(self)
145 
146 
147  def __next__(self):
148  """__next__(SwigPyIterator self) -> PyObject *"""
149  return _pcbnew.SwigPyIterator___next__(self)
150 
151 
152  def previous(self):
153  """previous(SwigPyIterator self) -> PyObject *"""
154  return _pcbnew.SwigPyIterator_previous(self)
155 
156 
157  def advance(self, n):
158  """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
159  return _pcbnew.SwigPyIterator_advance(self, n)
160 
161 
162  def __eq__(self, x):
163  """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
164  return _pcbnew.SwigPyIterator___eq__(self, x)
165 
166 
167  def __ne__(self, x):
168  """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
169  return _pcbnew.SwigPyIterator___ne__(self, x)
170 
171 
172  def __iadd__(self, n):
173  """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
174  return _pcbnew.SwigPyIterator___iadd__(self, n)
175 
176 
177  def __isub__(self, n):
178  """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
179  return _pcbnew.SwigPyIterator___isub__(self, n)
180 
181 
182  def __add__(self, n):
183  """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
184  return _pcbnew.SwigPyIterator___add__(self, n)
185 
186 
187  def __sub__(self, *args):
188  """
189  __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
190  __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
191  """
192  return _pcbnew.SwigPyIterator___sub__(self, *args)
193 
194  def __iter__(self):
195  return self
196 SwigPyIterator_swigregister = _pcbnew.SwigPyIterator_swigregister
197 SwigPyIterator_swigregister(SwigPyIterator)
198 
200  """Proxy of C++ std::basic_string<(char)> class"""
201  __swig_setmethods__ = {}
202  __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
203  __swig_getmethods__ = {}
204  __getattr__ = lambda self, name: _swig_getattr(self, string, name)
205  __repr__ = _swig_repr
206 
207  def length(self):
208  """length(string self) -> std::basic_string< char >::size_type"""
209  return _pcbnew.string_length(self)
210 
211 
212  def max_size(self):
213  """max_size(string self) -> std::basic_string< char >::size_type"""
214  return _pcbnew.string_max_size(self)
215 
216 
217  def capacity(self):
218  """capacity(string self) -> std::basic_string< char >::size_type"""
219  return _pcbnew.string_capacity(self)
220 
221 
222  def reserve(self, __res_arg=0):
223  """
224  reserve(string self, std::basic_string< char >::size_type __res_arg=0)
225  reserve(string self)
226  """
227  return _pcbnew.string_reserve(self, __res_arg)
228 
229 
230  def copy(self, __s, __n, __pos=0):
231  """
232  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
233  copy(string self, char * __s, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
234  """
235  return _pcbnew.string_copy(self, __s, __n, __pos)
236 
237 
238  def c_str(self):
239  """c_str(string self) -> char const *"""
240  return _pcbnew.string_c_str(self)
241 
242 
243  def find(self, *args):
244  """
245  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
246  find(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
247  find(string self, string __str) -> std::basic_string< char >::size_type
248  find(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
249  find(string self, char __c) -> std::basic_string< char >::size_type
250  """
251  return _pcbnew.string_find(self, *args)
252 
253 
254  def rfind(self, *args):
255  """
256  rfind(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
257  rfind(string self, string __str) -> std::basic_string< char >::size_type
258  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
259  rfind(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
260  rfind(string self, char __c) -> std::basic_string< char >::size_type
261  """
262  return _pcbnew.string_rfind(self, *args)
263 
264 
265  def find_first_of(self, *args):
266  """
267  find_first_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
268  find_first_of(string self, string __str) -> std::basic_string< char >::size_type
269  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
270  find_first_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
271  find_first_of(string self, char __c) -> std::basic_string< char >::size_type
272  """
273  return _pcbnew.string_find_first_of(self, *args)
274 
275 
276  def find_last_of(self, *args):
277  """
278  find_last_of(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
279  find_last_of(string self, string __str) -> std::basic_string< char >::size_type
280  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
281  find_last_of(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
282  find_last_of(string self, char __c) -> std::basic_string< char >::size_type
283  """
284  return _pcbnew.string_find_last_of(self, *args)
285 
286 
287  def find_first_not_of(self, *args):
288  """
289  find_first_not_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
290  find_first_not_of(string self, string __str) -> std::basic_string< char >::size_type
291  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
292  find_first_not_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
293  find_first_not_of(string self, char __c) -> std::basic_string< char >::size_type
294  """
295  return _pcbnew.string_find_first_not_of(self, *args)
296 
297 
298  def find_last_not_of(self, *args):
299  """
300  find_last_not_of(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
301  find_last_not_of(string self, string __str) -> std::basic_string< char >::size_type
302  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
303  find_last_not_of(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type
304  find_last_not_of(string self, char __c) -> std::basic_string< char >::size_type
305  """
306  return _pcbnew.string_find_last_not_of(self, *args)
307 
308 
309  def substr(self, *args):
310  """
311  substr(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n) -> string
312  substr(string self, std::basic_string< char >::size_type __pos=0) -> string
313  substr(string self) -> string
314  """
315  return _pcbnew.string_substr(self, *args)
316 
317 
318  def empty(self):
319  """empty(string self) -> bool"""
320  return _pcbnew.string_empty(self)
321 
322 
323  def size(self):
324  """size(string self) -> std::basic_string< char >::size_type"""
325  return _pcbnew.string_size(self)
326 
327 
328  def swap(self, v):
329  """swap(string self, string v)"""
330  return _pcbnew.string_swap(self, v)
331 
332 
333  def get_allocator(self):
334  """get_allocator(string self) -> std::basic_string< char >::allocator_type"""
335  return _pcbnew.string_get_allocator(self)
336 
337 
338  def begin(self):
339  """begin(string self) -> std::basic_string< char >::iterator"""
340  return _pcbnew.string_begin(self)
341 
342 
343  def end(self):
344  """end(string self) -> std::basic_string< char >::iterator"""
345  return _pcbnew.string_end(self)
346 
347 
348  def rbegin(self):
349  """rbegin(string self) -> std::basic_string< char >::reverse_iterator"""
350  return _pcbnew.string_rbegin(self)
351 
352 
353  def rend(self):
354  """rend(string self) -> std::basic_string< char >::reverse_iterator"""
355  return _pcbnew.string_rend(self)
356 
357 
358  def erase(self, *args):
359  """
360  erase(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n) -> string
361  erase(string self, std::basic_string< char >::size_type __pos=0) -> string
362  erase(string self) -> string
363  erase(string self, std::basic_string< char >::iterator pos) -> std::basic_string< char >::iterator
364  erase(string self, std::basic_string< char >::iterator first, std::basic_string< char >::iterator last) -> std::basic_string< char >::iterator
365  """
366  return _pcbnew.string_erase(self, *args)
367 
368 
369  def __init__(self, *args):
370  """
371  __init__(std::basic_string<(char)> self, char const * __s, std::basic_string< char >::size_type __n) -> string
372  __init__(std::basic_string<(char)> self) -> string
373  __init__(std::basic_string<(char)> self, string arg2) -> string
374  __init__(std::basic_string<(char)> self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string
375  """
376  this = _pcbnew.new_string(*args)
377  try:
378  self.this.append(this)
379  except:
380  self.this = this
381 
382  def assign(self, *args):
383  """
384  assign(string self, string __str) -> string
385  assign(string self, string __str, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> string
386  assign(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
387  assign(string self, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
388  """
389  return _pcbnew.string_assign(self, *args)
390 
391 
392  def resize(self, *args):
393  """
394  resize(string self, std::basic_string< char >::size_type new_size)
395  resize(string self, std::basic_string< char >::size_type new_size, std::basic_string< char >::value_type x)
396  """
397  return _pcbnew.string_resize(self, *args)
398 
399 
400  def iterator(self):
401  """iterator(string self) -> SwigPyIterator"""
402  return _pcbnew.string_iterator(self)
403 
404  def __iter__(self):
405  return self.iterator()
406 
407  def __nonzero__(self):
408  """__nonzero__(string self) -> bool"""
409  return _pcbnew.string___nonzero__(self)
410 
411 
412  def __bool__(self):
413  """__bool__(string self) -> bool"""
414  return _pcbnew.string___bool__(self)
415 
416 
417  def __len__(self):
418  """__len__(string self) -> std::basic_string< char >::size_type"""
419  return _pcbnew.string___len__(self)
420 
421 
422  def __getslice__(self, i, j):
423  """__getslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) -> string"""
424  return _pcbnew.string___getslice__(self, i, j)
425 
426 
427  def __setslice__(self, *args):
428  """
429  __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v)
430  __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)
431  """
432  return _pcbnew.string___setslice__(self, *args)
433 
434 
435  def __delslice__(self, i, j):
436  """__delslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)"""
437  return _pcbnew.string___delslice__(self, i, j)
438 
439 
440  def __delitem__(self, *args):
441  """
442  __delitem__(string self, std::basic_string< char >::difference_type i)
443  __delitem__(string self, PySliceObject * slice)
444  """
445  return _pcbnew.string___delitem__(self, *args)
446 
447 
448  def __getitem__(self, *args):
449  """
450  __getitem__(string self, PySliceObject * slice) -> string
451  __getitem__(string self, std::basic_string< char >::difference_type i) -> std::basic_string< char >::value_type
452  """
453  return _pcbnew.string___getitem__(self, *args)
454 
455 
456  def __setitem__(self, *args):
457  """
458  __setitem__(string self, PySliceObject * slice, string v)
459  __setitem__(string self, PySliceObject * slice)
460  __setitem__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::value_type x)
461  """
462  return _pcbnew.string___setitem__(self, *args)
463 
464 
465  def insert(self, *args):
466  """
467  insert(string self, std::basic_string< char >::size_type __pos1, string __str) -> string
468  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
469  insert(string self, std::basic_string< char >::size_type __pos, char const * __s, std::basic_string< char >::size_type __n) -> string
470  insert(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, char __c) -> string
471  insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::value_type x) -> std::basic_string< char >::iterator
472  insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
473  insert(string self, std::basic_string< char >::iterator __p, std::basic_string< char >::size_type __n, char __c)
474  """
475  return _pcbnew.string_insert(self, *args)
476 
477 
478  def replace(self, *args):
479  """
480  replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, string __str) -> string
481  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
482  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
483  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
484  replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, string __str) -> string
485  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
486  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
487  replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __k1, char const * __k2) -> string
488  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
489  """
490  return _pcbnew.string_replace(self, *args)
491 
492 
493  def __iadd__(self, v):
494  """__iadd__(string self, string v) -> string"""
495  return _pcbnew.string___iadd__(self, v)
496 
497 
498  def __add__(self, v):
499  """__add__(string self, string v) -> string"""
500  return _pcbnew.string___add__(self, v)
501 
502 
503  def __radd__(self, v):
504  """__radd__(string self, string v) -> string"""
505  return _pcbnew.string___radd__(self, v)
506 
507 
508  def __str__(self):
509  """__str__(string self) -> string"""
510  return _pcbnew.string___str__(self)
511 
512 
513  def __rlshift__(self, out):
514  """__rlshift__(string self, std::basic_ostream< char,std::char_traits< char > > & out) -> std::basic_ostream< char,std::char_traits< char > > &"""
515  return _pcbnew.string___rlshift__(self, out)
516 
517 
518  def __eq__(self, v):
519  """__eq__(string self, string v) -> bool"""
520  return _pcbnew.string___eq__(self, v)
521 
522 
523  def __ne__(self, v):
524  """__ne__(string self, string v) -> bool"""
525  return _pcbnew.string___ne__(self, v)
526 
527 
528  def __gt__(self, v):
529  """__gt__(string self, string v) -> bool"""
530  return _pcbnew.string___gt__(self, v)
531 
532 
533  def __lt__(self, v):
534  """__lt__(string self, string v) -> bool"""
535  return _pcbnew.string___lt__(self, v)
536 
537 
538  def __ge__(self, v):
539  """__ge__(string self, string v) -> bool"""
540  return _pcbnew.string___ge__(self, v)
541 
542 
543  def __le__(self, v):
544  """__le__(string self, string v) -> bool"""
545  return _pcbnew.string___le__(self, v)
546 
547  __swig_destroy__ = _pcbnew.delete_string
548  __del__ = lambda self: None
549 string_swigregister = _pcbnew.string_swigregister
550 string_swigregister(string)
551 cvar = _pcbnew.cvar
552 string.npos = _pcbnew.cvar.string_npos
553 
554 
555 _pcbnew.SHARED_PTR_DISOWN_swigconstant(_pcbnew)
556 SHARED_PTR_DISOWN = _pcbnew.SHARED_PTR_DISOWN
558  """
559 
560 
561  Struct IO_ERROR is a class used to hold an error message and may be
562  used when throwing exceptions containing meaningful error messages.
563 
564  Dick Hollenbeck
565 
566  C++ includes: ki_exception.h
567  """
568  __swig_setmethods__ = {}
569  __setattr__ = lambda self, name, value: _swig_setattr(self, IO_ERROR, name, value)
570  __swig_getmethods__ = {}
571  __getattr__ = lambda self, name: _swig_getattr(self, IO_ERROR, name)
572  __repr__ = _swig_repr
573 
574  def __init__(self, *args):
575  """
576  __init__(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber) -> IO_ERROR
577  __init__(IO_ERROR self) -> IO_ERROR
578 
579  IO_ERROR::IO_ERROR()
580  """
581  this = _pcbnew.new_IO_ERROR(*args)
582  try:
583  self.this.append(this)
584  except:
585  self.this = this
586 
587  def init(self, aProblem, aThrowersFile, aThrowersFunction, aThrowersLineNumber):
588  """
589  init(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber)
590 
591  void IO_ERROR::init(const
592  wxString &aProblem, const char *aThrowersFile, const char
593  *aThrowersFunction, int aThrowersLineNumber)
594  """
595  return _pcbnew.IO_ERROR_init(self, aProblem, aThrowersFile, aThrowersFunction, aThrowersLineNumber)
596 
597 
598  def Problem(self):
599  """
600  Problem(IO_ERROR self) -> wxString
601 
602  const wxString
603  IO_ERROR::Problem() const
604 
605  what was the problem?
606  """
607  return _pcbnew.IO_ERROR_Problem(self)
608 
609 
610  def Where(self):
611  """
612  Where(IO_ERROR self) -> wxString
613 
614  const wxString
615  IO_ERROR::Where() const
616 
617  where did the Problem() occur?
618  """
619  return _pcbnew.IO_ERROR_Where(self)
620 
621 
622  def What(self):
623  """
624  What(IO_ERROR self) -> wxString
625 
626  const wxString
627  IO_ERROR::What() const
628 
629  A composite of Problem() and Where()
630  """
631  return _pcbnew.IO_ERROR_What(self)
632 
633  __swig_destroy__ = _pcbnew.delete_IO_ERROR
634  __del__ = lambda self: None
635 IO_ERROR_swigregister = _pcbnew.IO_ERROR_swigregister
636 IO_ERROR_swigregister(IO_ERROR)
637 
638 class DHEAD(_object):
639  """
640 
641 
642  Class DHEAD is only for use by template class DLIST, use that instead.
643 
644  C++ includes: dlist.h
645  """
646  __swig_setmethods__ = {}
647  __setattr__ = lambda self, name, value: _swig_setattr(self, DHEAD, name, value)
648  __swig_getmethods__ = {}
649  __getattr__ = lambda self, name: _swig_getattr(self, DHEAD, name)
650 
651  def __init__(self, *args, **kwargs):
652  raise AttributeError("No constructor defined")
653  __repr__ = _swig_repr
654 
655  def DeleteAll(self):
656  """
657  DeleteAll(DHEAD self)
658 
659  void DHEAD::DeleteAll()
660 
661  Function DeleteAll deletes all items on the list and leaves the list
662  empty.
663 
664  The destructor for each item is called.
665  """
666  return _pcbnew.DHEAD_DeleteAll(self)
667 
668 
669  def SetOwnership(self, Iown):
670  """
671  SetOwnership(DHEAD self, bool Iown)
672 
673  void
674  DHEAD::SetOwnership(bool Iown)
675 
676  Function SetOwnership controls whether the list owns the objects and
677  is responsible for deleteing their memory at time of this object's
678  destruction.
679  """
680  return _pcbnew.DHEAD_SetOwnership(self, Iown)
681 
682 
683  def GetCount(self):
684  """
685  GetCount(DHEAD self) -> unsigned int
686 
687  unsigned DHEAD::GetCount()
688  const
689 
690  Function GetCount returns the number of elements in the list.
691  """
692  return _pcbnew.DHEAD_GetCount(self)
693 
694 DHEAD_swigregister = _pcbnew.DHEAD_swigregister
695 DHEAD_swigregister(DHEAD)
696 
697 
699  """wxSetDefaultPyEncoding(char const * encoding)"""
700  return _pcbnew.wxSetDefaultPyEncoding(encoding)
701 
703  """wxGetDefaultPyEncoding() -> char const *"""
704  return _pcbnew.wxGetDefaultPyEncoding()
706  """Proxy of C++ wxRect class"""
707  __swig_setmethods__ = {}
708  __setattr__ = lambda self, name, value: _swig_setattr(self, wxRect, name, value)
709  __swig_getmethods__ = {}
710  __getattr__ = lambda self, name: _swig_getattr(self, wxRect, name)
711  __repr__ = _swig_repr
712 
713  def __init__(self, *args):
714  """
715  __init__(wxRect self) -> wxRect
716  __init__(wxRect self, int xx, int yy, int ww, int hh) -> wxRect
717  __init__(wxRect self, wxPoint topLeft, wxPoint bottomRight) -> wxRect
718  __init__(wxRect self, wxPoint pt, wxSize size) -> wxRect
719  __init__(wxRect self, wxSize size) -> wxRect
720  """
721  this = _pcbnew.new_wxRect(*args)
722  try:
723  self.this.append(this)
724  except:
725  self.this = this
726 
727  def GetX(self):
728  """GetX(wxRect self) -> int"""
729  return _pcbnew.wxRect_GetX(self)
730 
731 
732  def SetX(self, xx):
733  """SetX(wxRect self, int xx)"""
734  return _pcbnew.wxRect_SetX(self, xx)
735 
736 
737  def GetY(self):
738  """GetY(wxRect self) -> int"""
739  return _pcbnew.wxRect_GetY(self)
740 
741 
742  def SetY(self, yy):
743  """SetY(wxRect self, int yy)"""
744  return _pcbnew.wxRect_SetY(self, yy)
745 
746 
747  def GetWidth(self):
748  """GetWidth(wxRect self) -> int"""
749  return _pcbnew.wxRect_GetWidth(self)
750 
751 
752  def SetWidth(self, w):
753  """SetWidth(wxRect self, int w)"""
754  return _pcbnew.wxRect_SetWidth(self, w)
755 
756 
757  def GetHeight(self):
758  """GetHeight(wxRect self) -> int"""
759  return _pcbnew.wxRect_GetHeight(self)
760 
761 
762  def SetHeight(self, h):
763  """SetHeight(wxRect self, int h)"""
764  return _pcbnew.wxRect_SetHeight(self, h)
765 
766 
767  def GetPosition(self):
768  """GetPosition(wxRect self) -> wxPoint"""
769  return _pcbnew.wxRect_GetPosition(self)
770 
771 
772  def SetPosition(self, p):
773  """SetPosition(wxRect self, wxPoint p)"""
774  return _pcbnew.wxRect_SetPosition(self, p)
775 
776  __swig_setmethods__["x"] = _pcbnew.wxRect_x_set
777  __swig_getmethods__["x"] = _pcbnew.wxRect_x_get
778  if _newclass:
779  x = _swig_property(_pcbnew.wxRect_x_get, _pcbnew.wxRect_x_set)
780  __swig_setmethods__["y"] = _pcbnew.wxRect_y_set
781  __swig_getmethods__["y"] = _pcbnew.wxRect_y_get
782  if _newclass:
783  y = _swig_property(_pcbnew.wxRect_y_get, _pcbnew.wxRect_y_set)
784  __swig_setmethods__["width"] = _pcbnew.wxRect_width_set
785  __swig_getmethods__["width"] = _pcbnew.wxRect_width_get
786  if _newclass:
787  width = _swig_property(_pcbnew.wxRect_width_get, _pcbnew.wxRect_width_set)
788  __swig_setmethods__["height"] = _pcbnew.wxRect_height_set
789  __swig_getmethods__["height"] = _pcbnew.wxRect_height_get
790  if _newclass:
791  height = _swig_property(_pcbnew.wxRect_height_get, _pcbnew.wxRect_height_set)
792 
793  def Get(self):
794  """Get(wxRect self) -> PyObject *"""
795  return _pcbnew.wxRect_Get(self)
796 
797 
798 
799  def __eq__(self,other):
800  return self.x==other.x and self.y==other.y and self.width==other.width and self.height==other.height
801  def __str__(self): return str(self.Get())
802  def __repr__(self): return 'wxRect'+str(self.Get())
803  def __len__(self): return len(self.Get())
804  def __getitem__(self, index): return self.Get()[index]
805  def __setitem__(self, index, val):
806  if index == 0: self.SetX(val)
807  elif index == 1: self.SetY(val)
808  elif index == 2: self.SetWidth(val)
809  elif index == 3: self.SetHeight(val)
810  else: raise IndexError
811  def __nonzero__(self): return self.Get() != (0,0,0,0)
812  __safe_for_unpickling__ = True
813 
814  __swig_destroy__ = _pcbnew.delete_wxRect
815  __del__ = lambda self: None
816 wxRect_swigregister = _pcbnew.wxRect_swigregister
817 wxRect_swigregister(wxRect)
818 
820  """Proxy of C++ wxSize class"""
821  __swig_setmethods__ = {}
822  __setattr__ = lambda self, name, value: _swig_setattr(self, wxSize, name, value)
823  __swig_getmethods__ = {}
824  __getattr__ = lambda self, name: _swig_getattr(self, wxSize, name)
825  __repr__ = _swig_repr
826  __swig_setmethods__["x"] = _pcbnew.wxSize_x_set
827  __swig_getmethods__["x"] = _pcbnew.wxSize_x_get
828  if _newclass:
829  x = _swig_property(_pcbnew.wxSize_x_get, _pcbnew.wxSize_x_set)
830  __swig_setmethods__["y"] = _pcbnew.wxSize_y_set
831  __swig_getmethods__["y"] = _pcbnew.wxSize_y_get
832  if _newclass:
833  y = _swig_property(_pcbnew.wxSize_y_get, _pcbnew.wxSize_y_set)
834 
835  def __init__(self, *args):
836  """
837  __init__(wxSize self, int xx, int yy) -> wxSize
838  __init__(wxSize self, double xx, double yy) -> wxSize
839  """
840  this = _pcbnew.new_wxSize(*args)
841  try:
842  self.this.append(this)
843  except:
844  self.this = this
845 
846  def Get(self):
847  """Get(wxSize self) -> PyObject *"""
848  return _pcbnew.wxSize_Get(self)
849 
850  __swig_destroy__ = _pcbnew.delete_wxSize
851  __del__ = lambda self: None
852 
853  def SetWidth(self, w):
854  """SetWidth(wxSize self, int w)"""
855  return _pcbnew.wxSize_SetWidth(self, w)
856 
857 
858  def SetHeight(self, h):
859  """SetHeight(wxSize self, int h)"""
860  return _pcbnew.wxSize_SetHeight(self, h)
861 
862 
863  def GetWidth(self):
864  """GetWidth(wxSize self) -> int"""
865  return _pcbnew.wxSize_GetWidth(self)
866 
867 
868  def GetHeight(self):
869  """GetHeight(wxSize self) -> int"""
870  return _pcbnew.wxSize_GetHeight(self)
871 
872 
873  def Scale(self,xscale,yscale):
874  return wxSize(self.x*xscale,self.y*yscale)
875  def __eq__(self,other):
876  return self.GetWidth()==other.GetWidth() and self.GetHeight()==other.GetHeight()
877  def __str__(self): return str(self.Get())
878  def __repr__(self): return 'wxSize'+str(self.Get())
879  def __len__(self): return len(self.Get())
880  def __getitem__(self, index): return self.Get()[index]
881  def __setitem__(self, index, val):
882  if index == 0: self.SetWidth(val)
883  elif index == 1: self.SetHeight(val)
884  else: raise IndexError
885  def __nonzero__(self): return self.Get() != (0,0)
886  __safe_for_unpickling__ = True
887 
888 
889 wxSize_swigregister = _pcbnew.wxSize_swigregister
890 wxSize_swigregister(wxSize)
891 
893  """
894  C++ includes:
895  polygon_test_point_inside.h
896  """
897  __swig_setmethods__ = {}
898  __setattr__ = lambda self, name, value: _swig_setattr(self, wxPoint, name, value)
899  __swig_getmethods__ = {}
900  __getattr__ = lambda self, name: _swig_getattr(self, wxPoint, name)
901  __repr__ = _swig_repr
902  __swig_setmethods__["x"] = _pcbnew.wxPoint_x_set
903  __swig_getmethods__["x"] = _pcbnew.wxPoint_x_get
904  if _newclass:
905  x = _swig_property(_pcbnew.wxPoint_x_get, _pcbnew.wxPoint_x_set)
906  __swig_setmethods__["y"] = _pcbnew.wxPoint_y_set
907  __swig_getmethods__["y"] = _pcbnew.wxPoint_y_get
908  if _newclass:
909  y = _swig_property(_pcbnew.wxPoint_y_get, _pcbnew.wxPoint_y_set)
910 
911  def __init__(self, *args):
912  """
913  __init__(wxPoint self, int xx, int yy) -> wxPoint
914  __init__(wxPoint self, double xx, double yy) -> wxPoint
915 
916  C++ includes:
917  polygon_test_point_inside.h
918  """
919  this = _pcbnew.new_wxPoint(*args)
920  try:
921  self.this.append(this)
922  except:
923  self.this = this
924  __swig_destroy__ = _pcbnew.delete_wxPoint
925  __del__ = lambda self: None
926 
927  def __add__(self, pt):
928  """__add__(wxPoint self, wxPoint pt) -> wxPoint"""
929  return _pcbnew.wxPoint___add__(self, pt)
930 
931 
932  def __sub__(self, pt):
933  """__sub__(wxPoint self, wxPoint pt) -> wxPoint"""
934  return _pcbnew.wxPoint___sub__(self, pt)
935 
936 
937  def Set(self, x, y):
938  """Set(wxPoint self, long x, long y)"""
939  return _pcbnew.wxPoint_Set(self, x, y)
940 
941 
942  def Get(self):
943  """Get(wxPoint self) -> PyObject *"""
944  return _pcbnew.wxPoint_Get(self)
945 
946 
947  def __eq__(self,other): return (self.x==other.x and self.y==other.y)
948  def __ne__(self,other): return not (self==other)
949  def __str__(self): return str(self.Get())
950  def __repr__(self): return 'wxPoint'+str(self.Get())
951  def __len__(self): return len(self.Get())
952  def __getitem__(self, index): return self.Get()[index]
953  def __setitem__(self, index, val):
954  if index == 0:
955  self.x = val
956  elif index == 1:
957  self.y = val
958  else:
959  raise IndexError
960  def __nonzero__(self): return self.Get() != (0,0)
961 
962 
963 wxPoint_swigregister = _pcbnew.wxPoint_swigregister
964 wxPoint_swigregister(wxPoint)
965 
967  """Proxy of C++ wxString class"""
968  __swig_setmethods__ = {}
969  __setattr__ = lambda self, name, value: _swig_setattr(self, wxString, name, value)
970  __swig_getmethods__ = {}
971  __getattr__ = lambda self, name: _swig_getattr(self, wxString, name)
972  __repr__ = _swig_repr
973  __swig_destroy__ = _pcbnew.delete_wxString
974  __del__ = lambda self: None
975 
976  def __str__(self):
977  """__str__(wxString self) -> PyObject *"""
978  return _pcbnew.wxString___str__(self)
979 
980 
981  def __repr__(self): return 'wxString(\'' + self.__str__() + '\')'
982 
983 
984  def __init__(self):
985  """__init__(wxString self) -> wxString"""
986  this = _pcbnew.new_wxString()
987  try:
988  self.this.append(this)
989  except:
990  self.this = this
991 wxString_swigregister = _pcbnew.wxString_swigregister
992 wxString_swigregister(wxString)
993 
995  """Proxy of C++ std::vector<(wxPoint)> class"""
996  __swig_setmethods__ = {}
997  __setattr__ = lambda self, name, value: _swig_setattr(self, wxPoint_Vector, name, value)
998  __swig_getmethods__ = {}
999  __getattr__ = lambda self, name: _swig_getattr(self, wxPoint_Vector, name)
1000  __repr__ = _swig_repr
1001 
1002  def iterator(self):
1003  """iterator(wxPoint_Vector self) -> SwigPyIterator"""
1004  return _pcbnew.wxPoint_Vector_iterator(self)
1005 
1006  def __iter__(self):
1007  return self.iterator()
1008 
1009  def __nonzero__(self):
1010  """__nonzero__(wxPoint_Vector self) -> bool"""
1011  return _pcbnew.wxPoint_Vector___nonzero__(self)
1012 
1013 
1014  def __bool__(self):
1015  """__bool__(wxPoint_Vector self) -> bool"""
1016  return _pcbnew.wxPoint_Vector___bool__(self)
1017 
1018 
1019  def __len__(self):
1020  """__len__(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
1021  return _pcbnew.wxPoint_Vector___len__(self)
1022 
1023 
1024  def pop(self):
1025  """pop(wxPoint_Vector self) -> wxPoint"""
1026  return _pcbnew.wxPoint_Vector_pop(self)
1027 
1028 
1029  def __getslice__(self, i, j):
1030  """__getslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j) -> wxPoint_Vector"""
1031  return _pcbnew.wxPoint_Vector___getslice__(self, i, j)
1032 
1033 
1034  def __setslice__(self, *args):
1035  """
1036  __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j, wxPoint_Vector v)
1037  __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j)
1038  """
1039  return _pcbnew.wxPoint_Vector___setslice__(self, *args)
1040 
1041 
1042  def __delslice__(self, i, j):
1043  """__delslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j)"""
1044  return _pcbnew.wxPoint_Vector___delslice__(self, i, j)
1045 
1046 
1047  def __delitem__(self, *args):
1048  """
1049  __delitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i)
1050  __delitem__(wxPoint_Vector self, PySliceObject * slice)
1051  """
1052  return _pcbnew.wxPoint_Vector___delitem__(self, *args)
1053 
1054 
1055  def __getitem__(self, *args):
1056  """
1057  __getitem__(wxPoint_Vector self, PySliceObject * slice) -> wxPoint_Vector
1058  __getitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i) -> wxPoint
1059  """
1060  return _pcbnew.wxPoint_Vector___getitem__(self, *args)
1061 
1062 
1063  def __setitem__(self, *args):
1064  """
1065  __setitem__(wxPoint_Vector self, PySliceObject * slice, wxPoint_Vector v)
1066  __setitem__(wxPoint_Vector self, PySliceObject * slice)
1067  __setitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, wxPoint x)
1068  """
1069  return _pcbnew.wxPoint_Vector___setitem__(self, *args)
1070 
1071 
1072  def append(self, x):
1073  """append(wxPoint_Vector self, wxPoint x)"""
1074  return _pcbnew.wxPoint_Vector_append(self, x)
1075 
1076 
1077  def empty(self):
1078  """empty(wxPoint_Vector self) -> bool"""
1079  return _pcbnew.wxPoint_Vector_empty(self)
1080 
1081 
1082  def size(self):
1083  """size(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
1084  return _pcbnew.wxPoint_Vector_size(self)
1085 
1086 
1087  def clear(self):
1088  """clear(wxPoint_Vector self)"""
1089  return _pcbnew.wxPoint_Vector_clear(self)
1090 
1091 
1092  def swap(self, v):
1093  """swap(wxPoint_Vector self, wxPoint_Vector v)"""
1094  return _pcbnew.wxPoint_Vector_swap(self, v)
1095 
1096 
1097  def get_allocator(self):
1098  """get_allocator(wxPoint_Vector self) -> std::vector< wxPoint >::allocator_type"""
1099  return _pcbnew.wxPoint_Vector_get_allocator(self)
1100 
1101 
1102  def begin(self):
1103  """begin(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
1104  return _pcbnew.wxPoint_Vector_begin(self)
1105 
1106 
1107  def end(self):
1108  """end(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
1109  return _pcbnew.wxPoint_Vector_end(self)
1110 
1111 
1112  def rbegin(self):
1113  """rbegin(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
1114  return _pcbnew.wxPoint_Vector_rbegin(self)
1115 
1116 
1117  def rend(self):
1118  """rend(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
1119  return _pcbnew.wxPoint_Vector_rend(self)
1120 
1121 
1122  def pop_back(self):
1123  """pop_back(wxPoint_Vector self)"""
1124  return _pcbnew.wxPoint_Vector_pop_back(self)
1125 
1126 
1127  def erase(self, *args):
1128  """
1129  erase(wxPoint_Vector self, std::vector< wxPoint >::iterator pos) -> std::vector< wxPoint >::iterator
1130  erase(wxPoint_Vector self, std::vector< wxPoint >::iterator first, std::vector< wxPoint >::iterator last) -> std::vector< wxPoint >::iterator
1131  """
1132  return _pcbnew.wxPoint_Vector_erase(self, *args)
1133 
1134 
1135  def __init__(self, *args):
1136  """
1137  __init__(std::vector<(wxPoint)> self) -> wxPoint_Vector
1138  __init__(std::vector<(wxPoint)> self, wxPoint_Vector arg2) -> wxPoint_Vector
1139  __init__(std::vector<(wxPoint)> self, std::vector< wxPoint >::size_type size) -> wxPoint_Vector
1140  __init__(std::vector<(wxPoint)> self, std::vector< wxPoint >::size_type size, wxPoint value) -> wxPoint_Vector
1141  """
1142  this = _pcbnew.new_wxPoint_Vector(*args)
1143  try:
1144  self.this.append(this)
1145  except:
1146  self.this = this
1147 
1148  def push_back(self, x):
1149  """push_back(wxPoint_Vector self, wxPoint x)"""
1150  return _pcbnew.wxPoint_Vector_push_back(self, x)
1151 
1152 
1153  def front(self):
1154  """front(wxPoint_Vector self) -> wxPoint"""
1155  return _pcbnew.wxPoint_Vector_front(self)
1156 
1157 
1158  def back(self):
1159  """back(wxPoint_Vector self) -> wxPoint"""
1160  return _pcbnew.wxPoint_Vector_back(self)
1161 
1162 
1163  def assign(self, n, x):
1164  """assign(wxPoint_Vector self, std::vector< wxPoint >::size_type n, wxPoint x)"""
1165  return _pcbnew.wxPoint_Vector_assign(self, n, x)
1166 
1167 
1168  def resize(self, *args):
1169  """
1170  resize(wxPoint_Vector self, std::vector< wxPoint >::size_type new_size)
1171  resize(wxPoint_Vector self, std::vector< wxPoint >::size_type new_size, wxPoint x)
1172  """
1173  return _pcbnew.wxPoint_Vector_resize(self, *args)
1174 
1175 
1176  def insert(self, *args):
1177  """
1178  insert(wxPoint_Vector self, std::vector< wxPoint >::iterator pos, wxPoint x) -> std::vector< wxPoint >::iterator
1179  insert(wxPoint_Vector self, std::vector< wxPoint >::iterator pos, std::vector< wxPoint >::size_type n, wxPoint x)
1180  """
1181  return _pcbnew.wxPoint_Vector_insert(self, *args)
1182 
1183 
1184  def reserve(self, n):
1185  """reserve(wxPoint_Vector self, std::vector< wxPoint >::size_type n)"""
1186  return _pcbnew.wxPoint_Vector_reserve(self, n)
1187 
1188 
1189  def capacity(self):
1190  """capacity(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
1191  return _pcbnew.wxPoint_Vector_capacity(self)
1192 
1193  __swig_destroy__ = _pcbnew.delete_wxPoint_Vector
1194  __del__ = lambda self: None
1195 wxPoint_Vector_swigregister = _pcbnew.wxPoint_Vector_swigregister
1196 wxPoint_Vector_swigregister(wxPoint_Vector)
1197 
1198 
1199 def FROM_UTF8(cstring):
1200  """FROM_UTF8(char const * cstring) -> wxString"""
1201  return _pcbnew.FROM_UTF8(cstring)
1202 
1203 def AccumulateDescription(aDesc, aItem):
1204  """AccumulateDescription(wxString aDesc, wxString aItem)"""
1205  return _pcbnew.AccumulateDescription(aDesc, aItem)
1206 
1207 def GetChars(s):
1208  """GetChars(wxString s) -> wxChar const *"""
1209  return _pcbnew.GetChars(s)
1210 
1211 _pcbnew.NOT_USED_swigconstant(_pcbnew)
1212 NOT_USED = _pcbnew.NOT_USED
1213 
1214 _pcbnew.EOT_swigconstant(_pcbnew)
1215 EOT = _pcbnew.EOT
1216 
1217 _pcbnew.TYPE_NOT_INIT_swigconstant(_pcbnew)
1218 TYPE_NOT_INIT = _pcbnew.TYPE_NOT_INIT
1219 
1220 _pcbnew.PCB_T_swigconstant(_pcbnew)
1221 PCB_T = _pcbnew.PCB_T
1222 
1223 _pcbnew.SCREEN_T_swigconstant(_pcbnew)
1224 SCREEN_T = _pcbnew.SCREEN_T
1225 
1226 _pcbnew.PCB_MODULE_T_swigconstant(_pcbnew)
1227 PCB_MODULE_T = _pcbnew.PCB_MODULE_T
1228 
1229 _pcbnew.PCB_PAD_T_swigconstant(_pcbnew)
1230 PCB_PAD_T = _pcbnew.PCB_PAD_T
1231 
1232 _pcbnew.PCB_LINE_T_swigconstant(_pcbnew)
1233 PCB_LINE_T = _pcbnew.PCB_LINE_T
1234 
1235 _pcbnew.PCB_TEXT_T_swigconstant(_pcbnew)
1236 PCB_TEXT_T = _pcbnew.PCB_TEXT_T
1237 
1238 _pcbnew.PCB_MODULE_TEXT_T_swigconstant(_pcbnew)
1239 PCB_MODULE_TEXT_T = _pcbnew.PCB_MODULE_TEXT_T
1240 
1241 _pcbnew.PCB_MODULE_EDGE_T_swigconstant(_pcbnew)
1242 PCB_MODULE_EDGE_T = _pcbnew.PCB_MODULE_EDGE_T
1243 
1244 _pcbnew.PCB_TRACE_T_swigconstant(_pcbnew)
1245 PCB_TRACE_T = _pcbnew.PCB_TRACE_T
1246 
1247 _pcbnew.PCB_VIA_T_swigconstant(_pcbnew)
1248 PCB_VIA_T = _pcbnew.PCB_VIA_T
1249 
1250 _pcbnew.PCB_ZONE_T_swigconstant(_pcbnew)
1251 PCB_ZONE_T = _pcbnew.PCB_ZONE_T
1252 
1253 _pcbnew.PCB_MARKER_T_swigconstant(_pcbnew)
1254 PCB_MARKER_T = _pcbnew.PCB_MARKER_T
1255 
1256 _pcbnew.PCB_DIMENSION_T_swigconstant(_pcbnew)
1257 PCB_DIMENSION_T = _pcbnew.PCB_DIMENSION_T
1258 
1259 _pcbnew.PCB_TARGET_T_swigconstant(_pcbnew)
1260 PCB_TARGET_T = _pcbnew.PCB_TARGET_T
1261 
1262 _pcbnew.PCB_ZONE_AREA_T_swigconstant(_pcbnew)
1263 PCB_ZONE_AREA_T = _pcbnew.PCB_ZONE_AREA_T
1264 
1265 _pcbnew.PCB_ITEM_LIST_T_swigconstant(_pcbnew)
1266 PCB_ITEM_LIST_T = _pcbnew.PCB_ITEM_LIST_T
1267 
1268 _pcbnew.PCB_NETINFO_T_swigconstant(_pcbnew)
1269 PCB_NETINFO_T = _pcbnew.PCB_NETINFO_T
1270 
1271 _pcbnew.SCH_MARKER_T_swigconstant(_pcbnew)
1272 SCH_MARKER_T = _pcbnew.SCH_MARKER_T
1273 
1274 _pcbnew.SCH_JUNCTION_T_swigconstant(_pcbnew)
1275 SCH_JUNCTION_T = _pcbnew.SCH_JUNCTION_T
1276 
1277 _pcbnew.SCH_NO_CONNECT_T_swigconstant(_pcbnew)
1278 SCH_NO_CONNECT_T = _pcbnew.SCH_NO_CONNECT_T
1279 
1280 _pcbnew.SCH_BUS_WIRE_ENTRY_T_swigconstant(_pcbnew)
1281 SCH_BUS_WIRE_ENTRY_T = _pcbnew.SCH_BUS_WIRE_ENTRY_T
1282 
1283 _pcbnew.SCH_BUS_BUS_ENTRY_T_swigconstant(_pcbnew)
1284 SCH_BUS_BUS_ENTRY_T = _pcbnew.SCH_BUS_BUS_ENTRY_T
1285 
1286 _pcbnew.SCH_LINE_T_swigconstant(_pcbnew)
1287 SCH_LINE_T = _pcbnew.SCH_LINE_T
1288 
1289 _pcbnew.SCH_BITMAP_T_swigconstant(_pcbnew)
1290 SCH_BITMAP_T = _pcbnew.SCH_BITMAP_T
1291 
1292 _pcbnew.SCH_TEXT_T_swigconstant(_pcbnew)
1293 SCH_TEXT_T = _pcbnew.SCH_TEXT_T
1294 
1295 _pcbnew.SCH_LABEL_T_swigconstant(_pcbnew)
1296 SCH_LABEL_T = _pcbnew.SCH_LABEL_T
1297 
1298 _pcbnew.SCH_GLOBAL_LABEL_T_swigconstant(_pcbnew)
1299 SCH_GLOBAL_LABEL_T = _pcbnew.SCH_GLOBAL_LABEL_T
1300 
1301 _pcbnew.SCH_HIERARCHICAL_LABEL_T_swigconstant(_pcbnew)
1302 SCH_HIERARCHICAL_LABEL_T = _pcbnew.SCH_HIERARCHICAL_LABEL_T
1303 
1304 _pcbnew.SCH_FIELD_T_swigconstant(_pcbnew)
1305 SCH_FIELD_T = _pcbnew.SCH_FIELD_T
1306 
1307 _pcbnew.SCH_COMPONENT_T_swigconstant(_pcbnew)
1308 SCH_COMPONENT_T = _pcbnew.SCH_COMPONENT_T
1309 
1310 _pcbnew.SCH_SHEET_PIN_T_swigconstant(_pcbnew)
1311 SCH_SHEET_PIN_T = _pcbnew.SCH_SHEET_PIN_T
1312 
1313 _pcbnew.SCH_SHEET_T_swigconstant(_pcbnew)
1314 SCH_SHEET_T = _pcbnew.SCH_SHEET_T
1315 
1316 _pcbnew.SCH_FIELD_LOCATE_REFERENCE_T_swigconstant(_pcbnew)
1317 SCH_FIELD_LOCATE_REFERENCE_T = _pcbnew.SCH_FIELD_LOCATE_REFERENCE_T
1318 
1319 _pcbnew.SCH_FIELD_LOCATE_VALUE_T_swigconstant(_pcbnew)
1320 SCH_FIELD_LOCATE_VALUE_T = _pcbnew.SCH_FIELD_LOCATE_VALUE_T
1321 
1322 _pcbnew.SCH_FIELD_LOCATE_FOOTPRINT_T_swigconstant(_pcbnew)
1323 SCH_FIELD_LOCATE_FOOTPRINT_T = _pcbnew.SCH_FIELD_LOCATE_FOOTPRINT_T
1324 
1325 _pcbnew.SCH_SCREEN_T_swigconstant(_pcbnew)
1326 SCH_SCREEN_T = _pcbnew.SCH_SCREEN_T
1327 
1328 _pcbnew.LIB_PART_T_swigconstant(_pcbnew)
1329 LIB_PART_T = _pcbnew.LIB_PART_T
1330 
1331 _pcbnew.LIB_ALIAS_T_swigconstant(_pcbnew)
1332 LIB_ALIAS_T = _pcbnew.LIB_ALIAS_T
1333 
1334 _pcbnew.LIB_ARC_T_swigconstant(_pcbnew)
1335 LIB_ARC_T = _pcbnew.LIB_ARC_T
1336 
1337 _pcbnew.LIB_CIRCLE_T_swigconstant(_pcbnew)
1338 LIB_CIRCLE_T = _pcbnew.LIB_CIRCLE_T
1339 
1340 _pcbnew.LIB_TEXT_T_swigconstant(_pcbnew)
1341 LIB_TEXT_T = _pcbnew.LIB_TEXT_T
1342 
1343 _pcbnew.LIB_RECTANGLE_T_swigconstant(_pcbnew)
1344 LIB_RECTANGLE_T = _pcbnew.LIB_RECTANGLE_T
1345 
1346 _pcbnew.LIB_POLYLINE_T_swigconstant(_pcbnew)
1347 LIB_POLYLINE_T = _pcbnew.LIB_POLYLINE_T
1348 
1349 _pcbnew.LIB_BEZIER_T_swigconstant(_pcbnew)
1350 LIB_BEZIER_T = _pcbnew.LIB_BEZIER_T
1351 
1352 _pcbnew.LIB_PIN_T_swigconstant(_pcbnew)
1353 LIB_PIN_T = _pcbnew.LIB_PIN_T
1354 
1355 _pcbnew.LIB_FIELD_T_swigconstant(_pcbnew)
1356 LIB_FIELD_T = _pcbnew.LIB_FIELD_T
1357 
1358 _pcbnew.TYPE_GERBER_DRAW_ITEM_swigconstant(_pcbnew)
1359 TYPE_GERBER_DRAW_ITEM = _pcbnew.TYPE_GERBER_DRAW_ITEM
1360 
1361 _pcbnew.TYPE_PL_EDITOR_LAYOUT_swigconstant(_pcbnew)
1362 TYPE_PL_EDITOR_LAYOUT = _pcbnew.TYPE_PL_EDITOR_LAYOUT
1363 
1364 _pcbnew.MAX_STRUCT_TYPE_ID_swigconstant(_pcbnew)
1365 MAX_STRUCT_TYPE_ID = _pcbnew.MAX_STRUCT_TYPE_ID
1366 
1367 _pcbnew.NO_FILL_swigconstant(_pcbnew)
1368 NO_FILL = _pcbnew.NO_FILL
1369 
1370 _pcbnew.FILLED_SHAPE_swigconstant(_pcbnew)
1371 FILLED_SHAPE = _pcbnew.FILLED_SHAPE
1372 
1373 _pcbnew.FILLED_WITH_BG_BODYCOLOR_swigconstant(_pcbnew)
1374 FILLED_WITH_BG_BODYCOLOR = _pcbnew.FILLED_WITH_BG_BODYCOLOR
1375 
1376 _pcbnew.SEARCH_QUIT_swigconstant(_pcbnew)
1377 SEARCH_QUIT = _pcbnew.SEARCH_QUIT
1378 
1379 _pcbnew.SEARCH_CONTINUE_swigconstant(_pcbnew)
1380 SEARCH_CONTINUE = _pcbnew.SEARCH_CONTINUE
1381 
1382 _pcbnew.IS_CHANGED_swigconstant(_pcbnew)
1383 IS_CHANGED = _pcbnew.IS_CHANGED
1384 
1385 _pcbnew.IS_LINKED_swigconstant(_pcbnew)
1386 IS_LINKED = _pcbnew.IS_LINKED
1387 
1388 _pcbnew.IN_EDIT_swigconstant(_pcbnew)
1389 IN_EDIT = _pcbnew.IN_EDIT
1390 
1391 _pcbnew.IS_MOVED_swigconstant(_pcbnew)
1392 IS_MOVED = _pcbnew.IS_MOVED
1393 
1394 _pcbnew.IS_NEW_swigconstant(_pcbnew)
1395 IS_NEW = _pcbnew.IS_NEW
1396 
1397 _pcbnew.IS_RESIZED_swigconstant(_pcbnew)
1398 IS_RESIZED = _pcbnew.IS_RESIZED
1399 
1400 _pcbnew.IS_DRAGGED_swigconstant(_pcbnew)
1401 IS_DRAGGED = _pcbnew.IS_DRAGGED
1402 
1403 _pcbnew.IS_DELETED_swigconstant(_pcbnew)
1404 IS_DELETED = _pcbnew.IS_DELETED
1405 
1406 _pcbnew.IS_WIRE_IMAGE_swigconstant(_pcbnew)
1407 IS_WIRE_IMAGE = _pcbnew.IS_WIRE_IMAGE
1408 
1409 _pcbnew.STARTPOINT_swigconstant(_pcbnew)
1410 STARTPOINT = _pcbnew.STARTPOINT
1411 
1412 _pcbnew.ENDPOINT_swigconstant(_pcbnew)
1413 ENDPOINT = _pcbnew.ENDPOINT
1414 
1415 _pcbnew.SELECTED_swigconstant(_pcbnew)
1416 SELECTED = _pcbnew.SELECTED
1417 
1418 _pcbnew.SELECTEDNODE_swigconstant(_pcbnew)
1419 SELECTEDNODE = _pcbnew.SELECTEDNODE
1420 
1421 _pcbnew.STRUCT_DELETED_swigconstant(_pcbnew)
1422 STRUCT_DELETED = _pcbnew.STRUCT_DELETED
1423 
1424 _pcbnew.CANDIDATE_swigconstant(_pcbnew)
1425 CANDIDATE = _pcbnew.CANDIDATE
1426 
1427 _pcbnew.SKIP_STRUCT_swigconstant(_pcbnew)
1428 SKIP_STRUCT = _pcbnew.SKIP_STRUCT
1429 
1430 _pcbnew.DO_NOT_DRAW_swigconstant(_pcbnew)
1431 DO_NOT_DRAW = _pcbnew.DO_NOT_DRAW
1432 
1433 _pcbnew.IS_CANCELLED_swigconstant(_pcbnew)
1434 IS_CANCELLED = _pcbnew.IS_CANCELLED
1435 
1436 _pcbnew.TRACK_LOCKED_swigconstant(_pcbnew)
1437 TRACK_LOCKED = _pcbnew.TRACK_LOCKED
1438 
1439 _pcbnew.TRACK_AR_swigconstant(_pcbnew)
1440 TRACK_AR = _pcbnew.TRACK_AR
1441 
1442 _pcbnew.FLAG1_swigconstant(_pcbnew)
1443 FLAG1 = _pcbnew.FLAG1
1444 
1445 _pcbnew.FLAG0_swigconstant(_pcbnew)
1446 FLAG0 = _pcbnew.FLAG0
1447 
1448 _pcbnew.BEGIN_ONPAD_swigconstant(_pcbnew)
1449 BEGIN_ONPAD = _pcbnew.BEGIN_ONPAD
1450 
1451 _pcbnew.END_ONPAD_swigconstant(_pcbnew)
1452 END_ONPAD = _pcbnew.END_ONPAD
1453 
1454 _pcbnew.BUSY_swigconstant(_pcbnew)
1455 BUSY = _pcbnew.BUSY
1456 
1457 _pcbnew.HIGHLIGHTED_swigconstant(_pcbnew)
1458 HIGHLIGHTED = _pcbnew.HIGHLIGHTED
1459 
1460 _pcbnew.BRIGHTENED_swigconstant(_pcbnew)
1461 BRIGHTENED = _pcbnew.BRIGHTENED
1462 
1463 _pcbnew.DP_COUPLED_swigconstant(_pcbnew)
1464 DP_COUPLED = _pcbnew.DP_COUPLED
1465 
1466 _pcbnew.EDA_ITEM_ALL_FLAGS_swigconstant(_pcbnew)
1467 EDA_ITEM_ALL_FLAGS = _pcbnew.EDA_ITEM_ALL_FLAGS
1469  """
1470 
1471 
1472  Class EDA_ITEM is a base class for most all the KiCad significant
1473  classes, used in schematics and boards.
1474 
1475  C++ includes: base_struct.h
1476  """
1477  __swig_setmethods__ = {}
1478  __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_ITEM, name, value)
1479  __swig_getmethods__ = {}
1480  __getattr__ = lambda self, name: _swig_getattr(self, EDA_ITEM, name)
1481 
1482  def __init__(self, *args, **kwargs):
1483  raise AttributeError("No constructor defined - class is abstract")
1484  __repr__ = _swig_repr
1485  __swig_destroy__ = _pcbnew.delete_EDA_ITEM
1486  __del__ = lambda self: None
1487 
1488  def Type(self):
1489  """
1490  Type(EDA_ITEM self) -> KICAD_T
1491 
1492  KICAD_T EDA_ITEM::Type() const
1493 
1494  Function Type()
1495 
1496  returns the type of object. This attribute should never be changed
1497  after a constructor sets it, so there is no public "setter" method.
1498  KICAD_T - the type of object.
1499  """
1500  return _pcbnew.EDA_ITEM_Type(self)
1501 
1502 
1503  def SetTimeStamp(self, aNewTimeStamp):
1504  """
1505  SetTimeStamp(EDA_ITEM self, time_t aNewTimeStamp)
1506 
1507  void
1508  EDA_ITEM::SetTimeStamp(time_t aNewTimeStamp)
1509  """
1510  return _pcbnew.EDA_ITEM_SetTimeStamp(self, aNewTimeStamp)
1511 
1512 
1513  def GetTimeStamp(self):
1514  """
1515  GetTimeStamp(EDA_ITEM self) -> time_t
1516 
1517  time_t
1518  EDA_ITEM::GetTimeStamp() const
1519  """
1520  return _pcbnew.EDA_ITEM_GetTimeStamp(self)
1521 
1522 
1523  def Next(self):
1524  """
1525  Next(EDA_ITEM self) -> EDA_ITEM
1526 
1527  EDA_ITEM* EDA_ITEM::Next()
1528  const
1529  """
1530  return _pcbnew.EDA_ITEM_Next(self)
1531 
1532 
1533  def Back(self):
1534  """
1535  Back(EDA_ITEM self) -> EDA_ITEM
1536 
1537  EDA_ITEM* EDA_ITEM::Back()
1538  const
1539  """
1540  return _pcbnew.EDA_ITEM_Back(self)
1541 
1542 
1543  def GetParent(self):
1544  """
1545  GetParent(EDA_ITEM self) -> EDA_ITEM
1546 
1547  EDA_ITEM*
1548  EDA_ITEM::GetParent() const
1549  """
1550  return _pcbnew.EDA_ITEM_GetParent(self)
1551 
1552 
1553  def GetList(self):
1554  """
1555  GetList(EDA_ITEM self) -> DHEAD
1556 
1557  DHEAD* EDA_ITEM::GetList()
1558  const
1559  """
1560  return _pcbnew.EDA_ITEM_GetList(self)
1561 
1562 
1563  def SetParent(self, aParent):
1564  """
1565  SetParent(EDA_ITEM self, EDA_ITEM aParent)
1566 
1567  void
1568  EDA_ITEM::SetParent(EDA_ITEM *aParent)
1569  """
1570  return _pcbnew.EDA_ITEM_SetParent(self, aParent)
1571 
1572 
1573  def SetList(self, aList):
1574  """
1575  SetList(EDA_ITEM self, DHEAD aList)
1576 
1577  void
1578  EDA_ITEM::SetList(DHEAD *aList)
1579  """
1580  return _pcbnew.EDA_ITEM_SetList(self, aList)
1581 
1582 
1583  def IsNew(self):
1584  """
1585  IsNew(EDA_ITEM self) -> bool
1586 
1587  bool EDA_ITEM::IsNew() const
1588 
1589  """
1590  return _pcbnew.EDA_ITEM_IsNew(self)
1591 
1592 
1593  def IsModified(self):
1594  """
1595  IsModified(EDA_ITEM self) -> bool
1596 
1597  bool
1598  EDA_ITEM::IsModified() const
1599  """
1600  return _pcbnew.EDA_ITEM_IsModified(self)
1601 
1602 
1603  def IsMoving(self):
1604  """
1605  IsMoving(EDA_ITEM self) -> bool
1606 
1607  bool EDA_ITEM::IsMoving()
1608  const
1609  """
1610  return _pcbnew.EDA_ITEM_IsMoving(self)
1611 
1612 
1613  def IsDragging(self):
1614  """
1615  IsDragging(EDA_ITEM self) -> bool
1616 
1617  bool
1618  EDA_ITEM::IsDragging() const
1619  """
1620  return _pcbnew.EDA_ITEM_IsDragging(self)
1621 
1622 
1623  def IsWireImage(self):
1624  """
1625  IsWireImage(EDA_ITEM self) -> bool
1626 
1627  bool
1628  EDA_ITEM::IsWireImage() const
1629  """
1630  return _pcbnew.EDA_ITEM_IsWireImage(self)
1631 
1632 
1633  def IsSelected(self):
1634  """
1635  IsSelected(EDA_ITEM self) -> bool
1636 
1637  bool
1638  EDA_ITEM::IsSelected() const
1639  """
1640  return _pcbnew.EDA_ITEM_IsSelected(self)
1641 
1642 
1643  def IsResized(self):
1644  """
1645  IsResized(EDA_ITEM self) -> bool
1646 
1647  bool
1648  EDA_ITEM::IsResized() const
1649  """
1650  return _pcbnew.EDA_ITEM_IsResized(self)
1651 
1652 
1653  def IsHighlighted(self):
1654  """
1655  IsHighlighted(EDA_ITEM self) -> bool
1656 
1657  bool
1658  EDA_ITEM::IsHighlighted() const
1659  """
1660  return _pcbnew.EDA_ITEM_IsHighlighted(self)
1661 
1662 
1663  def IsBrightened(self):
1664  """
1665  IsBrightened(EDA_ITEM self) -> bool
1666 
1667  bool
1668  EDA_ITEM::IsBrightened() const
1669  """
1670  return _pcbnew.EDA_ITEM_IsBrightened(self)
1671 
1672 
1673  def SetWireImage(self):
1674  """
1675  SetWireImage(EDA_ITEM self)
1676 
1677  void
1678  EDA_ITEM::SetWireImage()
1679  """
1680  return _pcbnew.EDA_ITEM_SetWireImage(self)
1681 
1682 
1683  def SetSelected(self):
1684  """
1685  SetSelected(EDA_ITEM self)
1686 
1687  void
1688  EDA_ITEM::SetSelected()
1689  """
1690  return _pcbnew.EDA_ITEM_SetSelected(self)
1691 
1692 
1693  def SetHighlighted(self):
1694  """
1695  SetHighlighted(EDA_ITEM self)
1696 
1697  void
1698  EDA_ITEM::SetHighlighted()
1699  """
1700  return _pcbnew.EDA_ITEM_SetHighlighted(self)
1701 
1702 
1703  def SetBrightened(self):
1704  """
1705  SetBrightened(EDA_ITEM self)
1706 
1707  void
1708  EDA_ITEM::SetBrightened()
1709  """
1710  return _pcbnew.EDA_ITEM_SetBrightened(self)
1711 
1712 
1713  def ClearSelected(self):
1714  """
1715  ClearSelected(EDA_ITEM self)
1716 
1717  void
1718  EDA_ITEM::ClearSelected()
1719  """
1720  return _pcbnew.EDA_ITEM_ClearSelected(self)
1721 
1722 
1723  def ClearHighlighted(self):
1724  """
1725  ClearHighlighted(EDA_ITEM self)
1726 
1727  void
1728  EDA_ITEM::ClearHighlighted()
1729  """
1730  return _pcbnew.EDA_ITEM_ClearHighlighted(self)
1731 
1732 
1733  def ClearBrightened(self):
1734  """
1735  ClearBrightened(EDA_ITEM self)
1736 
1737  void
1738  EDA_ITEM::ClearBrightened()
1739  """
1740  return _pcbnew.EDA_ITEM_ClearBrightened(self)
1741 
1742 
1743  def SetModified(self):
1744  """
1745  SetModified(EDA_ITEM self)
1746 
1747  void
1748  EDA_ITEM::SetModified()
1749  """
1750  return _pcbnew.EDA_ITEM_SetModified(self)
1751 
1752 
1753  def GetState(self, type):
1754  """
1755  GetState(EDA_ITEM self, int type) -> int
1756 
1757  int EDA_ITEM::GetState(int
1758  type) const
1759  """
1760  return _pcbnew.EDA_ITEM_GetState(self, type)
1761 
1762 
1763  def SetState(self, type, state):
1764  """
1765  SetState(EDA_ITEM self, int type, int state)
1766 
1767  void
1768  EDA_ITEM::SetState(int type, int state)
1769  """
1770  return _pcbnew.EDA_ITEM_SetState(self, type, state)
1771 
1772 
1773  def GetStatus(self):
1774  """
1775  GetStatus(EDA_ITEM self) -> STATUS_FLAGS
1776 
1777  STATUS_FLAGS
1778  EDA_ITEM::GetStatus() const
1779  """
1780  return _pcbnew.EDA_ITEM_GetStatus(self)
1781 
1782 
1783  def SetStatus(self, aStatus):
1784  """
1785  SetStatus(EDA_ITEM self, STATUS_FLAGS aStatus)
1786 
1787  void
1788  EDA_ITEM::SetStatus(STATUS_FLAGS aStatus)
1789  """
1790  return _pcbnew.EDA_ITEM_SetStatus(self, aStatus)
1791 
1792 
1793  def SetFlags(self, aMask):
1794  """
1795  SetFlags(EDA_ITEM self, STATUS_FLAGS aMask)
1796 
1797  void
1798  EDA_ITEM::SetFlags(STATUS_FLAGS aMask)
1799  """
1800  return _pcbnew.EDA_ITEM_SetFlags(self, aMask)
1801 
1802 
1803  def ClearFlags(self, aMask=-1):
1804  """
1805  ClearFlags(EDA_ITEM self, STATUS_FLAGS aMask=-1)
1806  ClearFlags(EDA_ITEM self)
1807 
1808  void
1809  EDA_ITEM::ClearFlags(STATUS_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
1810  """
1811  return _pcbnew.EDA_ITEM_ClearFlags(self, aMask)
1812 
1813 
1814  def GetFlags(self):
1815  """
1816  GetFlags(EDA_ITEM self) -> STATUS_FLAGS
1817 
1818  STATUS_FLAGS
1819  EDA_ITEM::GetFlags() const
1820  """
1821  return _pcbnew.EDA_ITEM_GetFlags(self)
1822 
1823 
1824  def SetForceVisible(self, aEnable):
1825  """
1826  SetForceVisible(EDA_ITEM self, bool aEnable)
1827 
1828  void
1829  EDA_ITEM::SetForceVisible(bool aEnable)
1830 
1831  Function SetForceVisible is used to set and cleag force visible flag
1832  used to force the item to be drawn even if it's draw attribute is set
1833  to not visible.
1834 
1835  Parameters:
1836  -----------
1837 
1838  aEnable: True forces the item to be drawn. False uses the item's
1839  visibility setting to determine if the item is to be drawn.
1840  """
1841  return _pcbnew.EDA_ITEM_SetForceVisible(self, aEnable)
1842 
1843 
1844  def GetMsgPanelInfo(self, aList):
1845  """
1846  GetMsgPanelInfo(EDA_ITEM self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)
1847 
1848  virtual void
1849  EDA_ITEM::GetMsgPanelInfo(std::vector< MSG_PANEL_ITEM > &aList)
1850 
1851  Function GetMsgPanelInfo populates aList of MSG_PANEL_ITEM objects
1852  with it's internal state for display purposes.
1853 
1854  This method replaces DisplayInfo() so that KiCad objects no longer
1855  have any knowledge of wxWidgets UI objects.
1856 
1857  Parameters:
1858  -----------
1859 
1860  aList: is the list to populate.
1861  """
1862  return _pcbnew.EDA_ITEM_GetMsgPanelInfo(self, aList)
1863 
1864 
1865  def HitTest(self, aPosition):
1866  """
1867  HitTest(EDA_ITEM self, wxPoint aPosition) -> bool
1868 
1869  virtual bool
1870  EDA_ITEM::HitTest(const wxPoint &aPosition) const
1871 
1872  Function HitTest tests if aPosition is contained within or on the
1873  bounding area of an item.
1874 
1875  Parameters:
1876  -----------
1877 
1878  aPosition: A reference to a wxPoint object containing the coordinates
1879  to test.
1880 
1881  True if aPosition is within or on the item bounding area.
1882  """
1883  return _pcbnew.EDA_ITEM_HitTest(self, aPosition)
1884 
1885 
1886  def GetBoundingBox(self):
1887  """
1888  GetBoundingBox(EDA_ITEM self) -> EDA_RECT
1889 
1890  const EDA_RECT
1891  EDA_ITEM::GetBoundingBox() const
1892 
1893  Function GetBoundingBox returns the orthogonal, bounding box of this
1894  object for display purposes.
1895 
1896  This box should be an enclosing perimeter for visible components of
1897  this object, and the units should be in the pcb or schematic
1898  coordinate system. It is OK to overestimate the size by a few counts.
1899 
1900  """
1901  return _pcbnew.EDA_ITEM_GetBoundingBox(self)
1902 
1903 
1904  def Clone(self):
1905  """
1906  Clone(EDA_ITEM self) -> EDA_ITEM
1907 
1908  EDA_ITEM * EDA_ITEM::Clone()
1909  const
1910 
1911  Function Clone creates a duplicate of this item with linked list
1912  members set to NULL.
1913 
1914  The default version will return NULL in release builds and likely
1915  crash the program. In debug builds, a warning message indicating the
1916  derived class has not implemented cloning. This really should be a
1917  pure virtual function. Due to the fact that there are so many objects
1918  derived from EDA_ITEM, the decision was made to return NULL until all
1919  the objects derived from EDA_ITEM implement cloning. Once that
1920  happens, this function should be made pure.
1921 
1922  A clone of the item.
1923  """
1924  return _pcbnew.EDA_ITEM_Clone(self)
1925 
1926 
1927  def IterateForward(listStart, inspector, testData, scanTypes):
1928  """IterateForward(EDA_ITEM listStart, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
1929  return _pcbnew.EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes)
1930 
1931  if _newclass:
1932  IterateForward = staticmethod(IterateForward)
1933  __swig_getmethods__["IterateForward"] = lambda x: IterateForward
1934 
1935  def Visit(self, inspector, testData, scanTypes):
1936  """
1937  Visit(EDA_ITEM self, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT
1938 
1939  SEARCH_RESULT
1940  EDA_ITEM::Visit(INSPECTOR inspector, void *testData, const KICAD_T
1941  scanTypes[])
1942 
1943  Function Visit may be re-implemented for each derived class in order
1944  to handle all the types given by its member data.
1945 
1946  Implementations should call inspector->Inspect() on types in
1947  scanTypes[], and may use IterateForward() to do so on lists of such
1948  data.
1949 
1950  Parameters:
1951  -----------
1952 
1953  inspector: An INSPECTOR instance to use in the inspection.
1954 
1955  testData: Arbitrary data used by the inspector.
1956 
1957  scanTypes: Which KICAD_T types are of interest and the order is
1958  significant too, terminated by EOT.
1959 
1960  SEARCH_RESULT SEARCH_QUIT if the Iterator is to stop the scan, else
1961  SCAN_CONTINUE, and determined by the inspector.
1962  """
1963  return _pcbnew.EDA_ITEM_Visit(self, inspector, testData, scanTypes)
1964 
1965 
1966  def GetClass(self):
1967  """
1968  GetClass(EDA_ITEM self) -> wxString
1969 
1970  virtual wxString
1971  EDA_ITEM::GetClass() const =0
1972 
1973  Function GetClass returns the class name.
1974 
1975  wxString
1976  """
1977  return _pcbnew.EDA_ITEM_GetClass(self)
1978 
1979 
1981  """
1982  GetSelectMenuText(EDA_ITEM self) -> wxString
1983 
1984  wxString
1985  EDA_ITEM::GetSelectMenuText() const
1986 
1987  Function GetSelectMenuText returns the text to display to be used in
1988  the selection clarification context menu when multiple items are found
1989  at the current cursor position.
1990 
1991  The default version of this function raises an assertion in the debug
1992  mode and returns a string to indicate that it was not overridden to
1993  provide the object specific text.
1994 
1995  The menu text string.
1996  """
1997  return _pcbnew.EDA_ITEM_GetSelectMenuText(self)
1998 
1999 
2000  def GetMenuImage(self):
2001  """
2002  GetMenuImage(EDA_ITEM self) -> BITMAP_DEF
2003 
2004  BITMAP_DEF
2005  EDA_ITEM::GetMenuImage() const
2006 
2007  Function GetMenuImage returns a pointer to an image to be used in
2008  menus.
2009 
2010  The default version returns the right arrow image. Override this
2011  function to provide object specific menu images. The menu image
2012  associated with the item.
2013  """
2014  return _pcbnew.EDA_ITEM_GetMenuImage(self)
2015 
2016 
2017  def Matches(self, aSearchData, aAuxData, aFindLocation):
2018  """
2019  Matches(EDA_ITEM self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool
2020 
2021  virtual bool
2022  EDA_ITEM::Matches(wxFindReplaceData &aSearchData, void *aAuxData,
2023  wxPoint *aFindLocation)
2024 
2025  Function Matches compares the item against the search criteria in
2026  aSearchData.
2027 
2028  The base class returns false since many of the objects derived from
2029  EDA_ITEM do not have any text to search.
2030 
2031  Parameters:
2032  -----------
2033 
2034  aSearchData: A reference to a wxFindReplaceData object containing the
2035  search criteria.
2036 
2037  aAuxData: A pointer to optional data required for the search or NULL
2038  if not used.
2039 
2040  aFindLocation: A pointer to a wxPoint object to store the location of
2041  matched item. The pointer can be NULL if it is not used.
2042 
2043  True if the item's text matches the search criteria in aSearchData.
2044  """
2045  return _pcbnew.EDA_ITEM_Matches(self, aSearchData, aAuxData, aFindLocation)
2046 
2047 
2048  def Replace(self, *args):
2049  """
2050  Replace(EDA_ITEM self, wxFindReplaceData & aSearchData, wxString aText) -> bool
2051  Replace(EDA_ITEM self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
2052  Replace(EDA_ITEM self, wxFindReplaceData & aSearchData) -> bool
2053 
2054  virtual bool
2055  EDA_ITEM::Replace(wxFindReplaceData &aSearchData, void *aAuxData=NULL)
2056 
2057  Function Replace performs a text replace using the find and replace
2058  criteria in aSearchData on items that support text find and replace.
2059 
2060  This function must be overridden for items that support text replace.
2061 
2062  Parameters:
2063  -----------
2064 
2065  aSearchData: A reference to a wxFindReplaceData object containing the
2066  search and replace criteria.
2067 
2068  aAuxData: A pointer to optional data required for the search or NULL
2069  if not used.
2070 
2071  True if the item text was modified, otherwise false.
2072  """
2073  return _pcbnew.EDA_ITEM_Replace(self, *args)
2074 
2075 
2076  def IsReplaceable(self):
2077  """
2078  IsReplaceable(EDA_ITEM self) -> bool
2079 
2080  virtual bool
2081  EDA_ITEM::IsReplaceable() const
2082 
2083  Function IsReplaceable.
2084 
2085  Override this method in any derived object that supports test find and
2086  replace.
2087 
2088  True if the item has replaceable text that can be modified using the
2089  find and replace dialog.
2090  """
2091  return _pcbnew.EDA_ITEM_IsReplaceable(self)
2092 
2093 
2094  def __lt__(self, aItem):
2095  """__lt__(EDA_ITEM self, EDA_ITEM aItem) -> bool"""
2096  return _pcbnew.EDA_ITEM___lt__(self, aItem)
2097 
2098 
2099  def Sort(aLeft, aRight):
2100  """Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
2101  return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)
2102 
2103  if _newclass:
2104  Sort = staticmethod(Sort)
2105  __swig_getmethods__["Sort"] = lambda x: Sort
2106 
2107  def ViewBBox(self):
2108  """
2109  ViewBBox(EDA_ITEM self) -> BOX2I const
2110 
2111  const BOX2I
2112  EDA_ITEM::ViewBBox() const override
2113  """
2114  return _pcbnew.EDA_ITEM_ViewBBox(self)
2115 
2116 
2117  def ViewGetLayers(self, aLayers, aCount):
2118  """
2119  ViewGetLayers(EDA_ITEM self, int [] aLayers, int & aCount)
2120 
2121  void
2122  EDA_ITEM::ViewGetLayers(int aLayers[], int &aCount) const override
2123  """
2124  return _pcbnew.EDA_ITEM_ViewGetLayers(self, aLayers, aCount)
2125 
2126 EDA_ITEM_swigregister = _pcbnew.EDA_ITEM_swigregister
2127 EDA_ITEM_swigregister(EDA_ITEM)
2128 traceFindReplace = cvar.traceFindReplace
2129 
2130 def EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes):
2131  """EDA_ITEM_IterateForward(EDA_ITEM listStart, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
2132  return _pcbnew.EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes)
2133 
2134 def EDA_ITEM_Sort(aLeft, aRight):
2135  """EDA_ITEM_Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
2136  return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)
2137 
2138 
2139 def new_clone(aItem):
2140  """new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
2141  return _pcbnew.new_clone(aItem)
2143  """
2144 
2145 
2146  Class EDA_RECT handles the component boundary box.
2147 
2148  This class is similar to wxRect, but some wxRect functions are very
2149  curious, and are working only if dimensions are >= 0 (not always the
2150  case in KiCad) and also KiCad needs some specific method. so I prefer
2151  this more suitable class
2152 
2153  C++ includes: class_eda_rect.h
2154  """
2155  __swig_setmethods__ = {}
2156  __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_RECT, name, value)
2157  __swig_getmethods__ = {}
2158  __getattr__ = lambda self, name: _swig_getattr(self, EDA_RECT, name)
2159  __repr__ = _swig_repr
2160 
2161  def __init__(self, *args):
2162  """
2163  __init__(EDA_RECT self) -> EDA_RECT
2164  __init__(EDA_RECT self, wxPoint aPos, wxSize aSize) -> EDA_RECT
2165 
2166  EDA_RECT::EDA_RECT(const
2167  wxPoint &aPos, const wxSize &aSize)
2168  """
2169  this = _pcbnew.new_EDA_RECT(*args)
2170  try:
2171  self.this.append(this)
2172  except:
2173  self.this = this
2174 
2175  def Centre(self):
2176  """
2177  Centre(EDA_RECT self) -> wxPoint
2178 
2179  wxPoint EDA_RECT::Centre()
2180  const
2181  """
2182  return _pcbnew.EDA_RECT_Centre(self)
2183 
2184 
2185  def Move(self, aMoveVector):
2186  """
2187  Move(EDA_RECT self, wxPoint aMoveVector)
2188 
2189  void EDA_RECT::Move(const
2190  wxPoint &aMoveVector)
2191 
2192  Function Move moves the rectangle by the aMoveVector.
2193 
2194  Parameters:
2195  -----------
2196 
2197  aMoveVector: A wxPoint that is the value to move this rectangle
2198  """
2199  return _pcbnew.EDA_RECT_Move(self, aMoveVector)
2200 
2201 
2202  def Normalize(self):
2203  """
2204  Normalize(EDA_RECT self)
2205 
2206  void
2207  EDA_RECT::Normalize()
2208 
2209  Function Normalize ensures that the height ant width are positive.
2210  """
2211  return _pcbnew.EDA_RECT_Normalize(self)
2212 
2213 
2214  def Contains(self, *args):
2215  """
2216  Contains(EDA_RECT self, wxPoint aPoint) -> bool
2217  Contains(EDA_RECT self, int x, int y) -> bool
2218  Contains(EDA_RECT self, EDA_RECT aRect) -> bool
2219 
2220  bool
2221  EDA_RECT::Contains(const EDA_RECT &aRect) const
2222 
2223  Function Contains.
2224 
2225  Parameters:
2226  -----------
2227 
2228  aRect: = the EDA_RECT to test
2229 
2230  true if aRect is Contained. A common edge is seen as contained
2231  """
2232  return _pcbnew.EDA_RECT_Contains(self, *args)
2233 
2234 
2235  def GetSize(self):
2236  """
2237  GetSize(EDA_RECT self) -> wxSize
2238 
2239  const wxSize&
2240  EDA_RECT::GetSize() const
2241  """
2242  return _pcbnew.EDA_RECT_GetSize(self)
2243 
2244 
2245  def GetSizeMax(self):
2246  """
2247  GetSizeMax(EDA_RECT self) -> int
2248 
2249  int
2250  EDA_RECT::GetSizeMax() const
2251 
2252  GetSizeMax.
2253 
2254  the max size dimension
2255  """
2256  return _pcbnew.EDA_RECT_GetSizeMax(self)
2257 
2258 
2259  def GetX(self):
2260  """
2261  GetX(EDA_RECT self) -> int
2262 
2263  int EDA_RECT::GetX() const
2264  """
2265  return _pcbnew.EDA_RECT_GetX(self)
2266 
2267 
2268  def GetY(self):
2269  """
2270  GetY(EDA_RECT self) -> int
2271 
2272  int EDA_RECT::GetY() const
2273  """
2274  return _pcbnew.EDA_RECT_GetY(self)
2275 
2276 
2277  def GetOrigin(self):
2278  """
2279  GetOrigin(EDA_RECT self) -> wxPoint
2280 
2281  const wxPoint&
2282  EDA_RECT::GetOrigin() const
2283  """
2284  return _pcbnew.EDA_RECT_GetOrigin(self)
2285 
2286 
2287  def GetPosition(self):
2288  """
2289  GetPosition(EDA_RECT self) -> wxPoint
2290 
2291  const wxPoint&
2292  EDA_RECT::GetPosition() const
2293  """
2294  return _pcbnew.EDA_RECT_GetPosition(self)
2295 
2296 
2297  def GetEnd(self):
2298  """
2299  GetEnd(EDA_RECT self) -> wxPoint
2300 
2301  const wxPoint
2302  EDA_RECT::GetEnd() const
2303  """
2304  return _pcbnew.EDA_RECT_GetEnd(self)
2305 
2306 
2307  def GetCenter(self):
2308  """
2309  GetCenter(EDA_RECT self) -> wxPoint
2310 
2311  const wxPoint
2312  EDA_RECT::GetCenter() const
2313  """
2314  return _pcbnew.EDA_RECT_GetCenter(self)
2315 
2316 
2317  def GetWidth(self):
2318  """
2319  GetWidth(EDA_RECT self) -> int
2320 
2321  int EDA_RECT::GetWidth()
2322  const
2323  """
2324  return _pcbnew.EDA_RECT_GetWidth(self)
2325 
2326 
2327  def GetHeight(self):
2328  """
2329  GetHeight(EDA_RECT self) -> int
2330 
2331  int EDA_RECT::GetHeight()
2332  const
2333  """
2334  return _pcbnew.EDA_RECT_GetHeight(self)
2335 
2336 
2337  def GetRight(self):
2338  """
2339  GetRight(EDA_RECT self) -> int
2340 
2341  int EDA_RECT::GetRight()
2342  const
2343  """
2344  return _pcbnew.EDA_RECT_GetRight(self)
2345 
2346 
2347  def GetLeft(self):
2348  """
2349  GetLeft(EDA_RECT self) -> int
2350 
2351  int EDA_RECT::GetLeft()
2352  const
2353  """
2354  return _pcbnew.EDA_RECT_GetLeft(self)
2355 
2356 
2357  def GetTop(self):
2358  """
2359  GetTop(EDA_RECT self) -> int
2360 
2361  int EDA_RECT::GetTop() const
2362 
2363  """
2364  return _pcbnew.EDA_RECT_GetTop(self)
2365 
2366 
2367  def GetBottom(self):
2368  """
2369  GetBottom(EDA_RECT self) -> int
2370 
2371  int EDA_RECT::GetBottom()
2372  const
2373  """
2374  return _pcbnew.EDA_RECT_GetBottom(self)
2375 
2376 
2377  def SetOrigin(self, *args):
2378  """
2379  SetOrigin(EDA_RECT self, wxPoint pos)
2380  SetOrigin(EDA_RECT self, int x, int y)
2381 
2382  void
2383  EDA_RECT::SetOrigin(int x, int y)
2384  """
2385  return _pcbnew.EDA_RECT_SetOrigin(self, *args)
2386 
2387 
2388  def SetSize(self, *args):
2389  """
2390  SetSize(EDA_RECT self, wxSize size)
2391  SetSize(EDA_RECT self, int w, int h)
2392 
2393  void EDA_RECT::SetSize(int
2394  w, int h)
2395  """
2396  return _pcbnew.EDA_RECT_SetSize(self, *args)
2397 
2398 
2399  def Offset(self, *args):
2400  """
2401  Offset(EDA_RECT self, int dx, int dy)
2402  Offset(EDA_RECT self, wxPoint offset)
2403 
2404  void EDA_RECT::Offset(const
2405  wxPoint &offset)
2406  """
2407  return _pcbnew.EDA_RECT_Offset(self, *args)
2408 
2409 
2410  def SetX(self, val):
2411  """
2412  SetX(EDA_RECT self, int val)
2413 
2414  void EDA_RECT::SetX(int val)
2415 
2416  """
2417  return _pcbnew.EDA_RECT_SetX(self, val)
2418 
2419 
2420  def SetY(self, val):
2421  """
2422  SetY(EDA_RECT self, int val)
2423 
2424  void EDA_RECT::SetY(int val)
2425 
2426  """
2427  return _pcbnew.EDA_RECT_SetY(self, val)
2428 
2429 
2430  def SetWidth(self, val):
2431  """
2432  SetWidth(EDA_RECT self, int val)
2433 
2434  void
2435  EDA_RECT::SetWidth(int val)
2436  """
2437  return _pcbnew.EDA_RECT_SetWidth(self, val)
2438 
2439 
2440  def SetHeight(self, val):
2441  """
2442  SetHeight(EDA_RECT self, int val)
2443 
2444  void
2445  EDA_RECT::SetHeight(int val)
2446  """
2447  return _pcbnew.EDA_RECT_SetHeight(self, val)
2448 
2449 
2450  def SetEnd(self, *args):
2451  """
2452  SetEnd(EDA_RECT self, int x, int y)
2453  SetEnd(EDA_RECT self, wxPoint pos)
2454 
2455  void EDA_RECT::SetEnd(const
2456  wxPoint &pos)
2457  """
2458  return _pcbnew.EDA_RECT_SetEnd(self, *args)
2459 
2460 
2461  def RevertYAxis(self):
2462  """
2463  RevertYAxis(EDA_RECT self)
2464 
2465  void
2466  EDA_RECT::RevertYAxis()
2467 
2468  Function RevertYAxis Mirror the rectangle from the X axis (negate Y
2469  pos and size)
2470  """
2471  return _pcbnew.EDA_RECT_RevertYAxis(self)
2472 
2473 
2474  def Intersects(self, *args):
2475  """
2476  Intersects(EDA_RECT self, EDA_RECT aRect) -> bool
2477  Intersects(EDA_RECT self, EDA_RECT aRect, double aRot) -> bool
2478  Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2) -> bool
2479 
2480  bool
2481  EDA_RECT::Intersects(const wxPoint &aPoint1, const wxPoint &aPoint2)
2482  const
2483 
2484  Function Intersects tests for a common area between a segment and this
2485  rectangle.
2486 
2487  Parameters:
2488  -----------
2489 
2490  aPoint1: First point of the segment to test intersection with.
2491 
2492  aPoint2: Second point of the segment to test intersection with.
2493 
2494  bool - true if the argument segment intersects this rectangle. (i.e.
2495  if the segment and rectangle have at least a common point)
2496  """
2497  return _pcbnew.EDA_RECT_Intersects(self, *args)
2498 
2499 
2500  def ClosestPointTo(self, aPoint):
2501  """
2502  ClosestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint
2503 
2504  const wxPoint
2505  EDA_RECT::ClosestPointTo(const wxPoint &aPoint) const
2506 
2507  Return the point in this rect that is closest to the provided point.
2508 
2509  """
2510  return _pcbnew.EDA_RECT_ClosestPointTo(self, aPoint)
2511 
2512 
2513  def FarthestPointTo(self, aPoint):
2514  """
2515  FarthestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint
2516 
2517  const wxPoint
2518  EDA_RECT::FarthestPointTo(const wxPoint &aPoint) const
2519 
2520  Return the point in this rect that is farthest from the provided
2521  point.
2522  """
2523  return _pcbnew.EDA_RECT_FarthestPointTo(self, aPoint)
2524 
2525 
2526  def IntersectsCircle(self, aCenter, aRadius):
2527  """
2528  IntersectsCircle(EDA_RECT self, wxPoint aCenter, int const aRadius) -> bool
2529 
2530  bool
2531  EDA_RECT::IntersectsCircle(const wxPoint &aCenter, const int aRadius)
2532  const
2533 
2534  Function IntersectsCircle tests for a common area between a circle and
2535  this rectangle.
2536 
2537  Parameters:
2538  -----------
2539 
2540  aCenter: center of the circle
2541 
2542  aRadius: radius of the circle
2543  """
2544  return _pcbnew.EDA_RECT_IntersectsCircle(self, aCenter, aRadius)
2545 
2546 
2547  def IntersectsCircleEdge(self, aCenter, aRadius, aWidth):
2548  """
2549  IntersectsCircleEdge(EDA_RECT self, wxPoint aCenter, int const aRadius, int const aWidth) -> bool
2550 
2551  bool
2552  EDA_RECT::IntersectsCircleEdge(const wxPoint &aCenter, const int
2553  aRadius, const int aWidth) const
2554 
2555  IntersectsCircleEdge Tests for intersection between this rect and the
2556  edge (radius) of a circle.
2557 
2558  Parameters:
2559  -----------
2560 
2561  aCenter: center of the circle
2562 
2563  aRadius: radius of the circle
2564 
2565  aWidth: width of the circle edge
2566  """
2567  return _pcbnew.EDA_RECT_IntersectsCircleEdge(self, aCenter, aRadius, aWidth)
2568 
2569 
2570  def getWxRect(self):
2571  """getWxRect(EDA_RECT self) -> wxRect"""
2572  return _pcbnew.EDA_RECT_getWxRect(self)
2573 
2574 
2575  def getBOX2I(self):
2576  """getBOX2I(EDA_RECT self) -> BOX2I"""
2577  return _pcbnew.EDA_RECT_getBOX2I(self)
2578 
2579 
2580  def Inflate(self, *args):
2581  """
2582  Inflate(EDA_RECT self, wxCoord dx, wxCoord dy) -> EDA_RECT
2583  Inflate(EDA_RECT self, int aDelta) -> EDA_RECT
2584 
2585  EDA_RECT &
2586  EDA_RECT::Inflate(int aDelta)
2587 
2588  Function Inflate inflates the rectangle horizontally and vertically by
2589  aDelta.
2590 
2591  If aDelta is negative the rectangle is deflated.
2592  """
2593  return _pcbnew.EDA_RECT_Inflate(self, *args)
2594 
2595 
2596  def Merge(self, *args):
2597  """
2598  Merge(EDA_RECT self, EDA_RECT aRect)
2599  Merge(EDA_RECT self, wxPoint aPoint)
2600 
2601  void EDA_RECT::Merge(const
2602  wxPoint &aPoint)
2603 
2604  Function Merge modifies the position and size of the rectangle in
2605  order to contain the given point.
2606 
2607  Parameters:
2608  -----------
2609 
2610  aPoint: The point to merge with the rectangle.
2611  """
2612  return _pcbnew.EDA_RECT_Merge(self, *args)
2613 
2614 
2615  def GetArea(self):
2616  """
2617  GetArea(EDA_RECT self) -> double
2618 
2619  double EDA_RECT::GetArea()
2620  const
2621 
2622  Function GetArea returns the area of the rectangle.
2623 
2624  The area of the rectangle.
2625  """
2626  return _pcbnew.EDA_RECT_GetArea(self)
2627 
2628 
2629  def Common(self, aRect):
2630  """
2631  Common(EDA_RECT self, EDA_RECT aRect) -> EDA_RECT
2632 
2633  EDA_RECT
2634  EDA_RECT::Common(const EDA_RECT &aRect) const
2635 
2636  Function Common returns the area that is common with another
2637  rectangle.
2638 
2639  Parameters:
2640  -----------
2641 
2642  aRect: is the rectangle to find the common area with.
2643 
2644  The common area rect or 0-sized rectangle if there is no intersection.
2645 
2646  """
2647  return _pcbnew.EDA_RECT_Common(self, aRect)
2648 
2649 
2650  def GetBoundingBoxRotated(self, aRotCenter, aAngle):
2651  """
2652  GetBoundingBoxRotated(EDA_RECT self, wxPoint aRotCenter, double aAngle) -> EDA_RECT
2653 
2654  const
2655  EDA_RECT EDA_RECT::GetBoundingBoxRotated(wxPoint aRotCenter, double
2656  aAngle)
2657 
2658  Function GetBoundingBoxRotated.
2659 
2660  the bounding box of this, after rotation
2661 
2662  Parameters:
2663  -----------
2664 
2665  aAngle: = the rotation angle in 0.1 deg.
2666 
2667  aRotCenter: = the rotation point. useful to calculate bounding box of
2668  rotated items, when rotation if not k*90 degrees
2669  """
2670  return _pcbnew.EDA_RECT_GetBoundingBoxRotated(self, aRotCenter, aAngle)
2671 
2672  __swig_destroy__ = _pcbnew.delete_EDA_RECT
2673  __del__ = lambda self: None
2674 EDA_RECT_swigregister = _pcbnew.EDA_RECT_swigregister
2675 EDA_RECT_swigregister(EDA_RECT)
2676 
2677 
2678 _pcbnew.EDA_PANNING_UP_KEY_swigconstant(_pcbnew)
2679 EDA_PANNING_UP_KEY = _pcbnew.EDA_PANNING_UP_KEY
2680 
2681 _pcbnew.EDA_PANNING_DOWN_KEY_swigconstant(_pcbnew)
2682 EDA_PANNING_DOWN_KEY = _pcbnew.EDA_PANNING_DOWN_KEY
2683 
2684 _pcbnew.EDA_PANNING_LEFT_KEY_swigconstant(_pcbnew)
2685 EDA_PANNING_LEFT_KEY = _pcbnew.EDA_PANNING_LEFT_KEY
2686 
2687 _pcbnew.EDA_PANNING_RIGHT_KEY_swigconstant(_pcbnew)
2688 EDA_PANNING_RIGHT_KEY = _pcbnew.EDA_PANNING_RIGHT_KEY
2689 
2690 _pcbnew.EDA_ZOOM_IN_FROM_MOUSE_swigconstant(_pcbnew)
2691 EDA_ZOOM_IN_FROM_MOUSE = _pcbnew.EDA_ZOOM_IN_FROM_MOUSE
2692 
2693 _pcbnew.EDA_ZOOM_OUT_FROM_MOUSE_swigconstant(_pcbnew)
2694 EDA_ZOOM_OUT_FROM_MOUSE = _pcbnew.EDA_ZOOM_OUT_FROM_MOUSE
2695 
2696 _pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE_swigconstant(_pcbnew)
2697 EDA_ZOOM_CENTER_FROM_MOUSE = _pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE
2698 
2699 _pcbnew.ESC_swigconstant(_pcbnew)
2700 ESC = _pcbnew.ESC
2701 
2702 _pcbnew.TEXT_ANGLE_HORIZ_swigconstant(_pcbnew)
2703 TEXT_ANGLE_HORIZ = _pcbnew.TEXT_ANGLE_HORIZ
2704 
2705 _pcbnew.TEXT_ANGLE_VERT_swigconstant(_pcbnew)
2706 TEXT_ANGLE_VERT = _pcbnew.TEXT_ANGLE_VERT
2707 
2708 def KiROUND(v):
2709  """KiROUND(double v) -> int"""
2710  return _pcbnew.KiROUND(v)
2711 
2712 _pcbnew.INCHES_swigconstant(_pcbnew)
2713 INCHES = _pcbnew.INCHES
2714 
2715 _pcbnew.MILLIMETRES_swigconstant(_pcbnew)
2716 MILLIMETRES = _pcbnew.MILLIMETRES
2717 
2718 _pcbnew.UNSCALED_UNITS_swigconstant(_pcbnew)
2719 UNSCALED_UNITS = _pcbnew.UNSCALED_UNITS
2720 
2721 _pcbnew.DEGREES_swigconstant(_pcbnew)
2722 DEGREES = _pcbnew.DEGREES
2724  """
2725 
2726 
2727  Class LOCALE_IO is a class that can be instantiated within a scope in
2728  which you are expecting exceptions to be thrown.
2729 
2730  Its constructor set a "C" laguage locale option, to read/print files
2731  with fp numbers. Its destructor insures that the default locale is
2732  restored if an exception is thrown, or not.
2733 
2734  C++ includes: common.h
2735  """
2736  __swig_setmethods__ = {}
2737  __setattr__ = lambda self, name, value: _swig_setattr(self, LOCALE_IO, name, value)
2738  __swig_getmethods__ = {}
2739  __getattr__ = lambda self, name: _swig_getattr(self, LOCALE_IO, name)
2740  __repr__ = _swig_repr
2741 
2742  def __init__(self):
2743  """
2744  __init__(LOCALE_IO self) -> LOCALE_IO
2745 
2746  LOCALE_IO::LOCALE_IO()
2747 
2748  """
2749  this = _pcbnew.new_LOCALE_IO()
2750  try:
2751  self.this.append(this)
2752  except:
2753  self.this = this
2754  __swig_destroy__ = _pcbnew.delete_LOCALE_IO
2755  __del__ = lambda self: None
2756 LOCALE_IO_swigregister = _pcbnew.LOCALE_IO_swigregister
2757 LOCALE_IO_swigregister(LOCALE_IO)
2758 
2759 
2760 def GetTextSize(aSingleLine, aWindow):
2761  """GetTextSize(wxString aSingleLine, wxWindow * aWindow) -> wxSize"""
2762  return _pcbnew.GetTextSize(aSingleLine, aWindow)
2763 
2764 def EnsureTextCtrlWidth(aCtrl, aString=None):
2765  """
2766  EnsureTextCtrlWidth(wxTextCtrl * aCtrl, wxString aString=None) -> bool
2767  EnsureTextCtrlWidth(wxTextCtrl * aCtrl) -> bool
2768  """
2769  return _pcbnew.EnsureTextCtrlWidth(aCtrl, aString)
2770 
2771 def ProcessExecute(*args):
2772  """
2773  ProcessExecute(wxString aCommandLine, int aFlags, wxProcess * callback=None) -> int
2774  ProcessExecute(wxString aCommandLine, int aFlags) -> int
2775  ProcessExecute(wxString aCommandLine) -> int
2776  """
2777  return _pcbnew.ProcessExecute(*args)
2778 
2780  """GetNewTimeStamp() -> time_t"""
2781  return _pcbnew.GetNewTimeStamp()
2782 
2783 def RoundTo0(x, precision):
2784  """RoundTo0(double x, double precision) -> double"""
2785  return _pcbnew.RoundTo0(x, precision)
2786 
2787 def wxStringSplit(aText, aStrings, aSplitter):
2788  """wxStringSplit(wxString aText, wxArrayString & aStrings, wxChar aSplitter)"""
2789  return _pcbnew.wxStringSplit(aText, aStrings, aSplitter)
2790 
2791 def SearchHelpFileFullPath(aSearchStack, aBaseName):
2792  """SearchHelpFileFullPath(SEARCH_STACK const & aSearchStack, wxString aBaseName) -> wxString"""
2793  return _pcbnew.SearchHelpFileFullPath(aSearchStack, aBaseName)
2794 
2795 def EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter=None):
2796  """
2797  EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename, REPORTER * aReporter=None) -> bool
2798  EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename) -> bool
2799  """
2800  return _pcbnew.EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter)
2801 
2802 def PrePendPath(aEnvVar, aPriorityPath):
2803  """PrePendPath(wxString aEnvVar, wxString aPriorityPath) -> wxString"""
2804  return _pcbnew.PrePendPath(aEnvVar, aPriorityPath)
2805 
2806 def GetNewConfig(aProgName):
2807  """GetNewConfig(wxString aProgName) -> wxConfigBase *"""
2808  return _pcbnew.GetNewConfig(aProgName)
2809 
2811  """GetKicadConfigPath() -> wxString"""
2812  return _pcbnew.GetKicadConfigPath()
2813 
2815  """ExpandEnvVarSubstitutions(wxString aString) -> wxString"""
2816  return _pcbnew.ExpandEnvVarSubstitutions(aString)
2818  """
2819 
2820 
2821  Class TITLE_BLOCK holds the information shown in the lower right
2822  corner of a plot, printout, or editing view.
2823 
2824  Dick Hollenbeck
2825 
2826  C++ includes: class_title_block.h
2827  """
2828  __swig_setmethods__ = {}
2829  __setattr__ = lambda self, name, value: _swig_setattr(self, TITLE_BLOCK, name, value)
2830  __swig_getmethods__ = {}
2831  __getattr__ = lambda self, name: _swig_getattr(self, TITLE_BLOCK, name)
2832  __repr__ = _swig_repr
2833 
2834  def __init__(self):
2835  """
2836  __init__(TITLE_BLOCK self) -> TITLE_BLOCK
2837 
2838  TITLE_BLOCK::TITLE_BLOCK()
2839  """
2840  this = _pcbnew.new_TITLE_BLOCK()
2841  try:
2842  self.this.append(this)
2843  except:
2844  self.this = this
2845  __swig_destroy__ = _pcbnew.delete_TITLE_BLOCK
2846  __del__ = lambda self: None
2847 
2848  def SetTitle(self, aTitle):
2849  """
2850  SetTitle(TITLE_BLOCK self, wxString aTitle)
2851 
2852  void
2853  TITLE_BLOCK::SetTitle(const wxString &aTitle)
2854  """
2855  return _pcbnew.TITLE_BLOCK_SetTitle(self, aTitle)
2856 
2857 
2858  def GetTitle(self):
2859  """
2860  GetTitle(TITLE_BLOCK self) -> wxString
2861 
2862  const wxString&
2863  TITLE_BLOCK::GetTitle() const
2864  """
2865  return _pcbnew.TITLE_BLOCK_GetTitle(self)
2866 
2867 
2868  def SetDate(self, aDate):
2869  """
2870  SetDate(TITLE_BLOCK self, wxString aDate)
2871 
2872  void
2873  TITLE_BLOCK::SetDate(const wxString &aDate)
2874 
2875  Function SetDate sets the date field, and defaults to the current time
2876  and date.
2877  """
2878  return _pcbnew.TITLE_BLOCK_SetDate(self, aDate)
2879 
2880 
2881  def GetDate(self):
2882  """
2883  GetDate(TITLE_BLOCK self) -> wxString
2884 
2885  const wxString&
2886  TITLE_BLOCK::GetDate() const
2887  """
2888  return _pcbnew.TITLE_BLOCK_GetDate(self)
2889 
2890 
2891  def SetRevision(self, aRevision):
2892  """
2893  SetRevision(TITLE_BLOCK self, wxString aRevision)
2894 
2895  void
2896  TITLE_BLOCK::SetRevision(const wxString &aRevision)
2897  """
2898  return _pcbnew.TITLE_BLOCK_SetRevision(self, aRevision)
2899 
2900 
2901  def GetRevision(self):
2902  """
2903  GetRevision(TITLE_BLOCK self) -> wxString
2904 
2905  const wxString&
2906  TITLE_BLOCK::GetRevision() const
2907  """
2908  return _pcbnew.TITLE_BLOCK_GetRevision(self)
2909 
2910 
2911  def SetCompany(self, aCompany):
2912  """
2913  SetCompany(TITLE_BLOCK self, wxString aCompany)
2914 
2915  void
2916  TITLE_BLOCK::SetCompany(const wxString &aCompany)
2917  """
2918  return _pcbnew.TITLE_BLOCK_SetCompany(self, aCompany)
2919 
2920 
2921  def GetCompany(self):
2922  """
2923  GetCompany(TITLE_BLOCK self) -> wxString
2924 
2925  const wxString&
2926  TITLE_BLOCK::GetCompany() const
2927  """
2928  return _pcbnew.TITLE_BLOCK_GetCompany(self)
2929 
2930 
2931  def SetComment(self, aIdx, aComment):
2932  """
2933  SetComment(TITLE_BLOCK self, int aIdx, wxString aComment)
2934 
2935  void
2936  TITLE_BLOCK::SetComment(int aIdx, const wxString &aComment)
2937  """
2938  return _pcbnew.TITLE_BLOCK_SetComment(self, aIdx, aComment)
2939 
2940 
2941  def GetComment(self, aIdx):
2942  """
2943  GetComment(TITLE_BLOCK self, int aIdx) -> wxString
2944 
2945  const wxString&
2946  TITLE_BLOCK::GetComment(int aIdx) const
2947  """
2948  return _pcbnew.TITLE_BLOCK_GetComment(self, aIdx)
2949 
2950 
2951  def SetComment1(self, aComment):
2952  """
2953  SetComment1(TITLE_BLOCK self, wxString aComment)
2954 
2955  void
2956  TITLE_BLOCK::SetComment1(const wxString &aComment)
2957  """
2958  return _pcbnew.TITLE_BLOCK_SetComment1(self, aComment)
2959 
2960 
2961  def SetComment2(self, aComment):
2962  """
2963  SetComment2(TITLE_BLOCK self, wxString aComment)
2964 
2965  void
2966  TITLE_BLOCK::SetComment2(const wxString &aComment)
2967  """
2968  return _pcbnew.TITLE_BLOCK_SetComment2(self, aComment)
2969 
2970 
2971  def SetComment3(self, aComment):
2972  """
2973  SetComment3(TITLE_BLOCK self, wxString aComment)
2974 
2975  void
2976  TITLE_BLOCK::SetComment3(const wxString &aComment)
2977  """
2978  return _pcbnew.TITLE_BLOCK_SetComment3(self, aComment)
2979 
2980 
2981  def SetComment4(self, aComment):
2982  """
2983  SetComment4(TITLE_BLOCK self, wxString aComment)
2984 
2985  void
2986  TITLE_BLOCK::SetComment4(const wxString &aComment)
2987  """
2988  return _pcbnew.TITLE_BLOCK_SetComment4(self, aComment)
2989 
2990 
2991  def GetComment1(self):
2992  """
2993  GetComment1(TITLE_BLOCK self) -> wxString
2994 
2995  const wxString&
2996  TITLE_BLOCK::GetComment1() const
2997  """
2998  return _pcbnew.TITLE_BLOCK_GetComment1(self)
2999 
3000 
3001  def GetComment2(self):
3002  """
3003  GetComment2(TITLE_BLOCK self) -> wxString
3004 
3005  const wxString&
3006  TITLE_BLOCK::GetComment2() const
3007  """
3008  return _pcbnew.TITLE_BLOCK_GetComment2(self)
3009 
3010 
3011  def GetComment3(self):
3012  """
3013  GetComment3(TITLE_BLOCK self) -> wxString
3014 
3015  const wxString&
3016  TITLE_BLOCK::GetComment3() const
3017  """
3018  return _pcbnew.TITLE_BLOCK_GetComment3(self)
3019 
3020 
3021  def GetComment4(self):
3022  """
3023  GetComment4(TITLE_BLOCK self) -> wxString
3024 
3025  const wxString&
3026  TITLE_BLOCK::GetComment4() const
3027  """
3028  return _pcbnew.TITLE_BLOCK_GetComment4(self)
3029 
3030 
3031  def Clear(self):
3032  """
3033  Clear(TITLE_BLOCK self)
3034 
3035  void TITLE_BLOCK::Clear()
3036 
3037  """
3038  return _pcbnew.TITLE_BLOCK_Clear(self)
3039 
3040 
3041  def Format(self, aFormatter, aNestLevel, aControlBits):
3042  """
3043  Format(TITLE_BLOCK self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)
3044 
3045  void
3046  TITLE_BLOCK::Format(OUTPUTFORMATTER *aFormatter, int aNestLevel, int
3047  aControlBits) const throw ( IO_ERROR ) Function Format outputs the
3048  object to aFormatter in s-expression form.
3049 
3050  Parameters:
3051  -----------
3052 
3053  aFormatter: The OUTPUTFORMATTER object to write to.
3054 
3055  aNestLevel: The indentation next level.
3056 
3057  aControlBits: The control bit definition for object specific
3058  formatting.
3059 
3060  Parameters:
3061  -----------
3062 
3063  ???: on write error.
3064  """
3065  return _pcbnew.TITLE_BLOCK_Format(self, aFormatter, aNestLevel, aControlBits)
3066 
3067 TITLE_BLOCK_swigregister = _pcbnew.TITLE_BLOCK_swigregister
3068 TITLE_BLOCK_swigregister(TITLE_BLOCK)
3069 
3071  """Proxy of C++ KIGFX::COLOR4D class"""
3072  __swig_setmethods__ = {}
3073  __setattr__ = lambda self, name, value: _swig_setattr(self, COLOR4D, name, value)
3074  __swig_getmethods__ = {}
3075  __getattr__ = lambda self, name: _swig_getattr(self, COLOR4D, name)
3076  __repr__ = _swig_repr
3077 
3078  def __init__(self, *args):
3079  """
3080  __init__(KIGFX::COLOR4D self) -> COLOR4D
3081  __init__(KIGFX::COLOR4D self, double aRed, double aGreen, double aBlue, double aAlpha) -> COLOR4D
3082  __init__(KIGFX::COLOR4D self, EDA_COLOR_T aColor) -> COLOR4D
3083  __init__(KIGFX::COLOR4D self, wxColour const & aColor) -> COLOR4D
3084  """
3085  this = _pcbnew.new_COLOR4D(*args)
3086  try:
3087  self.this.append(this)
3088  except:
3089  self.this = this
3090 
3091  def SetFromWxString(self, aColorString):
3092  """SetFromWxString(COLOR4D self, wxString aColorString) -> bool"""
3093  return _pcbnew.COLOR4D_SetFromWxString(self, aColorString)
3094 
3095 
3096  def ToWxString(self, flags):
3097  """ToWxString(COLOR4D self, long flags) -> wxString"""
3098  return _pcbnew.COLOR4D_ToWxString(self, flags)
3099 
3100 
3101  def ToColour(self):
3102  """ToColour(COLOR4D self) -> wxColour"""
3103  return _pcbnew.COLOR4D_ToColour(self)
3104 
3105 
3106  def LegacyMix(self, aColor):
3107  """LegacyMix(COLOR4D self, COLOR4D aColor) -> COLOR4D"""
3108  return _pcbnew.COLOR4D_LegacyMix(self, aColor)
3109 
3110 
3112  """SetToLegacyHighlightColor(COLOR4D self) -> COLOR4D"""
3113  return _pcbnew.COLOR4D_SetToLegacyHighlightColor(self)
3114 
3115 
3117  """SetToNearestLegacyColor(COLOR4D self) -> COLOR4D"""
3118  return _pcbnew.COLOR4D_SetToNearestLegacyColor(self)
3119 
3120 
3121  def ToU32(self):
3122  """ToU32(COLOR4D self) -> unsigned int"""
3123  return _pcbnew.COLOR4D_ToU32(self)
3124 
3125 
3126  def FromU32(self, aPackedColor):
3127  """FromU32(COLOR4D self, unsigned int aPackedColor)"""
3128  return _pcbnew.COLOR4D_FromU32(self, aPackedColor)
3129 
3130 
3132  """GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
3133  return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
3134 
3135  if _newclass:
3136  GetNearestLegacyColor = staticmethod(GetNearestLegacyColor)
3137  __swig_getmethods__["GetNearestLegacyColor"] = lambda x: GetNearestLegacyColor
3138 
3139  def Brighten(self, aFactor):
3140  """Brighten(COLOR4D self, double aFactor) -> COLOR4D"""
3141  return _pcbnew.COLOR4D_Brighten(self, aFactor)
3142 
3143 
3144  def Darken(self, aFactor):
3145  """Darken(COLOR4D self, double aFactor) -> COLOR4D"""
3146  return _pcbnew.COLOR4D_Darken(self, aFactor)
3147 
3148 
3149  def Invert(self):
3150  """Invert(COLOR4D self) -> COLOR4D"""
3151  return _pcbnew.COLOR4D_Invert(self)
3152 
3153 
3154  def Saturate(self, aFactor):
3155  """Saturate(COLOR4D self, double aFactor) -> COLOR4D"""
3156  return _pcbnew.COLOR4D_Saturate(self, aFactor)
3157 
3158 
3159  def Brightened(self, aFactor):
3160  """Brightened(COLOR4D self, double aFactor) -> COLOR4D"""
3161  return _pcbnew.COLOR4D_Brightened(self, aFactor)
3162 
3163 
3164  def Darkened(self, aFactor):
3165  """Darkened(COLOR4D self, double aFactor) -> COLOR4D"""
3166  return _pcbnew.COLOR4D_Darkened(self, aFactor)
3167 
3168 
3169  def WithAlpha(self, aAlpha):
3170  """WithAlpha(COLOR4D self, double aAlpha) -> COLOR4D"""
3171  return _pcbnew.COLOR4D_WithAlpha(self, aAlpha)
3172 
3173 
3174  def Inverted(self):
3175  """Inverted(COLOR4D self) -> COLOR4D"""
3176  return _pcbnew.COLOR4D_Inverted(self)
3177 
3178 
3179  def GetBrightness(self):
3180  """GetBrightness(COLOR4D self) -> double"""
3181  return _pcbnew.COLOR4D_GetBrightness(self)
3182 
3183 
3184  def ToHSV(self, aOutH, aOutS, aOutV):
3185  """ToHSV(COLOR4D self, double & aOutH, double & aOutS, double & aOutV)"""
3186  return _pcbnew.COLOR4D_ToHSV(self, aOutH, aOutS, aOutV)
3187 
3188 
3189  def FromHSV(self, aInH, aInS, aInV):
3190  """FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
3191  return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)
3192 
3193  __swig_setmethods__["r"] = _pcbnew.COLOR4D_r_set
3194  __swig_getmethods__["r"] = _pcbnew.COLOR4D_r_get
3195  if _newclass:
3196  r = _swig_property(_pcbnew.COLOR4D_r_get, _pcbnew.COLOR4D_r_set)
3197  __swig_setmethods__["g"] = _pcbnew.COLOR4D_g_set
3198  __swig_getmethods__["g"] = _pcbnew.COLOR4D_g_get
3199  if _newclass:
3200  g = _swig_property(_pcbnew.COLOR4D_g_get, _pcbnew.COLOR4D_g_set)
3201  __swig_setmethods__["b"] = _pcbnew.COLOR4D_b_set
3202  __swig_getmethods__["b"] = _pcbnew.COLOR4D_b_get
3203  if _newclass:
3204  b = _swig_property(_pcbnew.COLOR4D_b_get, _pcbnew.COLOR4D_b_set)
3205  __swig_setmethods__["a"] = _pcbnew.COLOR4D_a_set
3206  __swig_getmethods__["a"] = _pcbnew.COLOR4D_a_get
3207  if _newclass:
3208  a = _swig_property(_pcbnew.COLOR4D_a_get, _pcbnew.COLOR4D_a_set)
3209  __swig_destroy__ = _pcbnew.delete_COLOR4D
3210  __del__ = lambda self: None
3211 COLOR4D_swigregister = _pcbnew.COLOR4D_swigregister
3212 COLOR4D_swigregister(COLOR4D)
3213 
3215  """COLOR4D_GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
3216  return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
3217 COLOR4D.UNSPECIFIED = _pcbnew.cvar.COLOR4D_UNSPECIFIED
3218 COLOR4D.WHITE = _pcbnew.cvar.COLOR4D_WHITE
3219 COLOR4D.BLACK = _pcbnew.cvar.COLOR4D_BLACK
3220 
3221 
3222 def __eq__(lhs, rhs):
3223  """__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
3224  return _pcbnew.__eq__(lhs, rhs)
3225 
3226 def __ne__(lhs, rhs):
3227  """__ne__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
3228  return _pcbnew.__ne__(lhs, rhs)
3229 
3230 def __lshift__(aStream, aColor):
3231  """__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
3232  return _pcbnew.__lshift__(aStream, aColor)
3234  """
3235 
3236 
3237  Class COLORS_DESIGN_SETTINGS is a list of color settings for designs
3238  in Eeschema, Pcbnew and GerbView.
3239 
3240  C++ includes: class_colors_design_settings.h
3241  """
3242  __swig_setmethods__ = {}
3243  __setattr__ = lambda self, name, value: _swig_setattr(self, COLORS_DESIGN_SETTINGS, name, value)
3244  __swig_getmethods__ = {}
3245  __getattr__ = lambda self, name: _swig_getattr(self, COLORS_DESIGN_SETTINGS, name)
3246  __repr__ = _swig_repr
3247  __swig_setmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set
3248  __swig_getmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get
3249  if _newclass:
3250  m_LayersColors = _swig_property(_pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get, _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set)
3251 
3252  def __init__(self):
3253  """
3254  __init__(COLORS_DESIGN_SETTINGS self) -> COLORS_DESIGN_SETTINGS
3255 
3256  COLORS_DESIGN_SETTINGS::COLORS_DESIGN_SETTINGS()
3257  """
3258  this = _pcbnew.new_COLORS_DESIGN_SETTINGS()
3259  try:
3260  self.this.append(this)
3261  except:
3262  self.this = this
3263 
3264  def GetLayerColor(self, aLayer):
3265  """
3266  GetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer) -> COLOR4D
3267 
3268  COLOR4D
3269  COLORS_DESIGN_SETTINGS::GetLayerColor(LAYER_NUM aLayer) const
3270 
3271  Function GetLayerColor.
3272 
3273  the color for aLayer which is one of the layer indices given in
3274  pcbstruct.h or in schematic
3275  """
3276  return _pcbnew.COLORS_DESIGN_SETTINGS_GetLayerColor(self, aLayer)
3277 
3278 
3279  def SetLayerColor(self, aLayer, aColor):
3280  """
3281  SetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer, COLOR4D aColor)
3282 
3283  void
3284  COLORS_DESIGN_SETTINGS::SetLayerColor(LAYER_NUM aLayer, COLOR4D
3285  aColor)
3286 
3287  Function SetLayerColor sets the color for aLayer which is one of the
3288  layer indices given in pcbstruct.h or in schematic.
3289  """
3290  return _pcbnew.COLORS_DESIGN_SETTINGS_SetLayerColor(self, aLayer, aColor)
3291 
3292 
3293  def GetItemColor(self, aItemIdx):
3294  """
3295  GetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx) -> COLOR4D
3296 
3297  COLOR4D
3298  COLORS_DESIGN_SETTINGS::GetItemColor(int aItemIdx) const
3299 
3300  Function GetItemColor.
3301 
3302  the color for an item which is one of the item indices given in enum
3303  PCB_LAYER_ID
3304  """
3305  return _pcbnew.COLORS_DESIGN_SETTINGS_GetItemColor(self, aItemIdx)
3306 
3307 
3308  def SetItemColor(self, aItemIdx, aColor):
3309  """
3310  SetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx, COLOR4D aColor)
3311 
3312  void
3313  COLORS_DESIGN_SETTINGS::SetItemColor(int aItemIdx, COLOR4D aColor)
3314 
3315  Function SetItemColor sets the color for an item which is one of the
3316  item indices given in enum PCB_LAYER_ID.
3317  """
3318  return _pcbnew.COLORS_DESIGN_SETTINGS_SetItemColor(self, aItemIdx, aColor)
3319 
3320 
3321  def SetAllColorsAs(self, aColor):
3322  """
3323  SetAllColorsAs(COLORS_DESIGN_SETTINGS self, COLOR4D aColor)
3324 
3325  void
3326  COLORS_DESIGN_SETTINGS::SetAllColorsAs(COLOR4D aColor)
3327 
3328  Function SetAllColorsAs sets alls colors to aColor Usefull to create a
3329  monochrome color selection for printing purpose.
3330  """
3331  return _pcbnew.COLORS_DESIGN_SETTINGS_SetAllColorsAs(self, aColor)
3332 
3333  __swig_destroy__ = _pcbnew.delete_COLORS_DESIGN_SETTINGS
3334  __del__ = lambda self: None
3335 COLORS_DESIGN_SETTINGS_swigregister = _pcbnew.COLORS_DESIGN_SETTINGS_swigregister
3336 COLORS_DESIGN_SETTINGS_swigregister(COLORS_DESIGN_SETTINGS)
3337 
3339  """
3340  C++ includes: class_marker_base.h
3341 
3342  """
3343  __swig_setmethods__ = {}
3344  __setattr__ = lambda self, name, value: _swig_setattr(self, MARKER_BASE, name, value)
3345  __swig_getmethods__ = {}
3346  __getattr__ = lambda self, name: _swig_getattr(self, MARKER_BASE, name)
3347  __repr__ = _swig_repr
3348  MARKER_UNSPEC = _pcbnew.MARKER_BASE_MARKER_UNSPEC
3349  MARKER_ERC = _pcbnew.MARKER_BASE_MARKER_ERC
3350  MARKER_PCB = _pcbnew.MARKER_BASE_MARKER_PCB
3351  MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
3352  MARKER_SEVERITY_UNSPEC = _pcbnew.MARKER_BASE_MARKER_SEVERITY_UNSPEC
3353  MARKER_SEVERITY_INFO = _pcbnew.MARKER_BASE_MARKER_SEVERITY_INFO
3354  MARKER_SEVERITY_WARNING = _pcbnew.MARKER_BASE_MARKER_SEVERITY_WARNING
3355  MARKER_SEVERITY_ERROR = _pcbnew.MARKER_BASE_MARKER_SEVERITY_ERROR
3356  __swig_setmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_set
3357  __swig_getmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_get
3358  if _newclass:
3359  m_Pos = _swig_property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set)
3360 
3361  def __init__(self, *args):
3362  """
3363  __init__(MARKER_BASE self) -> MARKER_BASE
3364  __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos) -> MARKER_BASE
3365  __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos) -> MARKER_BASE
3366  __init__(MARKER_BASE self, MARKER_BASE aMarker) -> MARKER_BASE
3367 
3368  MARKER_BASE::MARKER_BASE(const MARKER_BASE &aMarker)
3369 
3370  Contructor makes a copy of aMarker but does not copy the DRC_ITEM.
3371 
3372  Parameters:
3373  -----------
3374 
3375  aMarker: The marker to copy.
3376  """
3377  this = _pcbnew.new_MARKER_BASE(*args)
3378  try:
3379  self.this.append(this)
3380  except:
3381  self.this = this
3382  __swig_destroy__ = _pcbnew.delete_MARKER_BASE
3383  __del__ = lambda self: None
3384 
3385  def DrawMarker(self, aPanel, aDC, aDrawMode, aOffset):
3386  """
3387  DrawMarker(MARKER_BASE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
3388 
3389  void
3390  MARKER_BASE::DrawMarker(EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE
3391  aDrawMode, const wxPoint &aOffset)
3392 
3393  Function DrawMarker draws the shape is the polygon defined in
3394  m_Corners (array of wxPoints).
3395  """
3396  return _pcbnew.MARKER_BASE_DrawMarker(self, aPanel, aDC, aDrawMode, aOffset)
3397 
3398 
3399  def GetPos(self):
3400  """
3401  GetPos(MARKER_BASE self) -> wxPoint
3402 
3403  const wxPoint&
3404  MARKER_BASE::GetPos() const
3405 
3406  Function GetPos returns the position of this MARKER, const.
3407  """
3408  return _pcbnew.MARKER_BASE_GetPos(self)
3409 
3410 
3411  def SetColor(self, aColor):
3412  """
3413  SetColor(MARKER_BASE self, COLOR4D aColor)
3414 
3415  void
3416  MARKER_BASE::SetColor(COLOR4D aColor)
3417 
3418  Function SetColor Set the color of this marker.
3419  """
3420  return _pcbnew.MARKER_BASE_SetColor(self, aColor)
3421 
3422 
3423  def SetErrorLevel(self, aErrorLevel):
3424  """
3425  SetErrorLevel(MARKER_BASE self, MARKER_BASE::MARKER_SEVERITY aErrorLevel)
3426 
3427  void
3428  MARKER_BASE::SetErrorLevel(MARKER_SEVERITY aErrorLevel)
3429 
3430  accessors to set/get error levels (warning, error, fatal error..)
3431  """
3432  return _pcbnew.MARKER_BASE_SetErrorLevel(self, aErrorLevel)
3433 
3434 
3435  def GetErrorLevel(self):
3436  """
3437  GetErrorLevel(MARKER_BASE self) -> MARKER_BASE::MARKER_SEVERITY
3438 
3439  MARKER_SEVERITY
3440  MARKER_BASE::GetErrorLevel() const
3441  """
3442  return _pcbnew.MARKER_BASE_GetErrorLevel(self)
3443 
3444 
3445  def SetMarkerType(self, aMarkerType):
3446  """
3447  SetMarkerType(MARKER_BASE self, enum MARKER_BASE::TYPEMARKER aMarkerType)
3448 
3449  void
3450  MARKER_BASE::SetMarkerType(enum TYPEMARKER aMarkerType)
3451 
3452  accessors to set/get marker type ( DRC, ERC, or other)
3453  """
3454  return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)
3455 
3456 
3457  def GetMarkerType(self):
3458  """
3459  GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::TYPEMARKER
3460 
3461  enum TYPEMARKER
3462  MARKER_BASE::GetMarkerType() const
3463  """
3464  return _pcbnew.MARKER_BASE_GetMarkerType(self)
3465 
3466 
3467  def SetData(self, *args):
3468  """
3469  SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos)
3470  SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos)
3471 
3472  void
3473  MARKER_BASE::SetData(int aErrorCode, const wxPoint &aMarkerPos, const
3474  wxString &aText, const wxPoint &aPos)
3475 
3476  Function SetData fills in all the reportable data associated with a
3477  MARKER.
3478 
3479  Parameters:
3480  -----------
3481 
3482  aErrorCode: The categorizing identifier for an error
3483 
3484  aMarkerPos: The position of the MARKER on the BOARD
3485 
3486  aText: Text describing the object
3487 
3488  aPos: The position of the object
3489  """
3490  return _pcbnew.MARKER_BASE_SetData(self, *args)
3491 
3492 
3493  def SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos):
3494  """
3495  SetAuxiliaryData(MARKER_BASE self, wxString aAuxiliaryText, wxPoint aAuxiliaryPos)
3496 
3497  void
3498  MARKER_BASE::SetAuxiliaryData(const wxString &aAuxiliaryText, const
3499  wxPoint &aAuxiliaryPos)
3500 
3501  Function SetAuxiliaryData initialize data for the second (auxiliary)
3502  item.
3503 
3504  Parameters:
3505  -----------
3506 
3507  aAuxiliaryText: = the second text (main text) concerning the second
3508  schematic or board item
3509 
3510  aAuxiliaryPos: = position the second item
3511  """
3512  return _pcbnew.MARKER_BASE_SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos)
3513 
3514 
3516  """
3517  SetShowNoCoordinate(MARKER_BASE self)
3518 
3519  void
3520  MARKER_BASE::SetShowNoCoordinate()
3521  """
3522  return _pcbnew.MARKER_BASE_SetShowNoCoordinate(self)
3523 
3524 
3525  def GetReporter(self):
3526  """
3527  GetReporter(MARKER_BASE self) -> DRC_ITEM const &
3528 
3529  const DRC_ITEM&
3530  MARKER_BASE::GetReporter() const
3531 
3532  Function GetReporter returns the DRC_ITEM held within this MARKER so
3533  that its interface may be used.
3534 
3535  const& DRC_ITEM
3536  """
3537  return _pcbnew.MARKER_BASE_GetReporter(self)
3538 
3539 
3540  def DisplayMarkerInfo(self, aFrame):
3541  """
3542  DisplayMarkerInfo(MARKER_BASE self, EDA_DRAW_FRAME * aFrame)
3543 
3544  void
3545  MARKER_BASE::DisplayMarkerInfo(EDA_DRAW_FRAME *aFrame)
3546 
3547  Function DisplayMarkerInfo displays the full info of this marker, in a
3548  HTML window.
3549  """
3550  return _pcbnew.MARKER_BASE_DisplayMarkerInfo(self, aFrame)
3551 
3552 
3553  def HitTestMarker(self, ref_pos):
3554  """
3555  HitTestMarker(MARKER_BASE self, wxPoint ref_pos) -> bool
3556 
3557  bool
3558  MARKER_BASE::HitTestMarker(const wxPoint &ref_pos) const
3559 
3560  Function HitTestMarker tests if the given wxPoint is within the bounds
3561  of this object.
3562 
3563  Parameters:
3564  -----------
3565 
3566  ref_pos: A wxPoint to test
3567 
3568  bool - true if a hit, else false
3569  """
3570  return _pcbnew.MARKER_BASE_HitTestMarker(self, ref_pos)
3571 
3572 
3574  """
3575  GetBoundingBoxMarker(MARKER_BASE self) -> EDA_RECT
3576 
3577  EDA_RECT
3578  MARKER_BASE::GetBoundingBoxMarker() const
3579 
3580  Function GetBoundingBoxMarker returns the orthogonal, bounding box of
3581  this object for display purposes.
3582 
3583  This box should be an enclosing perimeter for visible components of
3584  this object, and the units should be in the pcb or schematic
3585  coordinate system. It is OK to overestimate the size by a few counts.
3586 
3587  """
3588  return _pcbnew.MARKER_BASE_GetBoundingBoxMarker(self)
3589 
3590 MARKER_BASE_swigregister = _pcbnew.MARKER_BASE_swigregister
3591 MARKER_BASE_swigregister(MARKER_BASE)
3592 
3593 
3594 _pcbnew.CTL_OMIT_HIDE_swigconstant(_pcbnew)
3595 CTL_OMIT_HIDE = _pcbnew.CTL_OMIT_HIDE
3596 
3597 _pcbnew.GR_TEXT_HJUSTIFY_LEFT_swigconstant(_pcbnew)
3598 GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT
3599 
3600 _pcbnew.GR_TEXT_HJUSTIFY_CENTER_swigconstant(_pcbnew)
3601 GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER
3602 
3603 _pcbnew.GR_TEXT_HJUSTIFY_RIGHT_swigconstant(_pcbnew)
3604 GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT
3605 
3606 _pcbnew.GR_TEXT_VJUSTIFY_TOP_swigconstant(_pcbnew)
3607 GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP
3608 
3609 _pcbnew.GR_TEXT_VJUSTIFY_CENTER_swigconstant(_pcbnew)
3610 GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER
3611 
3612 _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM_swigconstant(_pcbnew)
3613 GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM
3614 
3615 _pcbnew.FILLED_swigconstant(_pcbnew)
3616 FILLED = _pcbnew.FILLED
3617 
3618 _pcbnew.SKETCH_swigconstant(_pcbnew)
3619 SKETCH = _pcbnew.SKETCH
3620 
3621 _pcbnew.DEFAULT_SIZE_TEXT_swigconstant(_pcbnew)
3622 DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT
3623 
3624 _pcbnew.DIM_ANCRE_TEXTE_swigconstant(_pcbnew)
3625 DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE
3627  """Proxy of C++ TEXT_EFFECTS class"""
3628  __swig_setmethods__ = {}
3629  __setattr__ = lambda self, name, value: _swig_setattr(self, TEXT_EFFECTS, name, value)
3630  __swig_getmethods__ = {}
3631  __getattr__ = lambda self, name: _swig_getattr(self, TEXT_EFFECTS, name)
3632  __repr__ = _swig_repr
3633 
3634  def __init__(self, aSetOfBits=0):
3635  """
3636  __init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS
3637  __init__(TEXT_EFFECTS self) -> TEXT_EFFECTS
3638  """
3639  this = _pcbnew.new_TEXT_EFFECTS(aSetOfBits)
3640  try:
3641  self.this.append(this)
3642  except:
3643  self.this = this
3644  __swig_setmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_set
3645  __swig_getmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_get
3646  if _newclass:
3647  bits = _swig_property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set)
3648  __swig_setmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_set
3649  __swig_getmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_get
3650  if _newclass:
3651  hjustify = _swig_property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set)
3652  __swig_setmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_set
3653  __swig_getmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_get
3654  if _newclass:
3655  vjustify = _swig_property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set)
3656  __swig_setmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_set
3657  __swig_getmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_get
3658  if _newclass:
3659  size = _swig_property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set)
3660  __swig_setmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_set
3661  __swig_getmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_get
3662  if _newclass:
3663  penwidth = _swig_property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set)
3664  __swig_setmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_set
3665  __swig_getmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_get
3666  if _newclass:
3667  angle = _swig_property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set)
3668  __swig_setmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_set
3669  __swig_getmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_get
3670  if _newclass:
3671  pos = _swig_property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set)
3672 
3673  def Bit(self, *args):
3674  """
3675  Bit(TEXT_EFFECTS self, int aBit, bool aValue)
3676  Bit(TEXT_EFFECTS self, int aBit) -> bool
3677  """
3678  return _pcbnew.TEXT_EFFECTS_Bit(self, *args)
3679 
3680  __swig_destroy__ = _pcbnew.delete_TEXT_EFFECTS
3681  __del__ = lambda self: None
3682 TEXT_EFFECTS_swigregister = _pcbnew.TEXT_EFFECTS_swigregister
3683 TEXT_EFFECTS_swigregister(TEXT_EFFECTS)
3684 
3686  """
3687 
3688 
3689  Class EDA_TEXT is a mix-in class (via multiple inheritance) that
3690  handles texts such as labels, parts, components, or footprints.
3691 
3692  Because it's a mix-in class, care is used to provide function names
3693  (accessors) that to not collide with function names likely to be seen
3694  in the combined derived classes.
3695 
3696  C++ includes: eda_text.h
3697  """
3698  __swig_setmethods__ = {}
3699  __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_TEXT, name, value)
3700  __swig_getmethods__ = {}
3701  __getattr__ = lambda self, name: _swig_getattr(self, EDA_TEXT, name)
3702  __repr__ = _swig_repr
3703 
3704  def __init__(self, *args):
3705  """
3706  __init__(EDA_TEXT self, wxString text) -> EDA_TEXT
3707  __init__(EDA_TEXT self) -> EDA_TEXT
3708 
3709  EDA_TEXT::EDA_TEXT(const
3710  wxString &text=wxEmptyString)
3711  """
3712  this = _pcbnew.new_EDA_TEXT(*args)
3713  try:
3714  self.this.append(this)
3715  except:
3716  self.this = this
3717  __swig_destroy__ = _pcbnew.delete_EDA_TEXT
3718  __del__ = lambda self: None
3719 
3720  def GetText(self):
3721  """
3722  GetText(EDA_TEXT self) -> wxString
3723 
3724  const wxString&
3725  EDA_TEXT::GetText() const
3726 
3727  Function GetText returns the string associated with the text object.
3728 
3729  a const wxString reference containing the string of the item.
3730  """
3731  return _pcbnew.EDA_TEXT_GetText(self)
3732 
3733 
3734  def GetShownText(self):
3735  """
3736  GetShownText(EDA_TEXT self) -> wxString
3737 
3738  virtual wxString
3739  EDA_TEXT::GetShownText() const
3740 
3741  Returns the string actually shown after processing of the base text.
3742 
3743  Default is no processing
3744  """
3745  return _pcbnew.EDA_TEXT_GetShownText(self)
3746 
3747 
3749  """
3750  ShortenedShownText(EDA_TEXT self) -> wxString
3751 
3752  wxString
3753  EDA_TEXT::ShortenedShownText() const
3754 
3755  Returns a shortened version (max 15 characters) of the shown text.
3756  """
3757  return _pcbnew.EDA_TEXT_ShortenedShownText(self)
3758 
3759 
3760  def SetText(self, aText):
3761  """
3762  SetText(EDA_TEXT self, wxString aText)
3763 
3764  virtual void
3765  EDA_TEXT::SetText(const wxString &aText)
3766  """
3767  return _pcbnew.EDA_TEXT_SetText(self, aText)
3768 
3769 
3770  def SetThickness(self, aNewThickness):
3771  """
3772  SetThickness(EDA_TEXT self, int aNewThickness)
3773 
3774  void
3775  EDA_TEXT::SetThickness(int aNewThickness)
3776 
3777  Function SetThickness sets pen width.
3778 
3779  Parameters:
3780  -----------
3781 
3782  aNewThickness: is the new pen width
3783  """
3784  return _pcbnew.EDA_TEXT_SetThickness(self, aNewThickness)
3785 
3786 
3787  def GetThickness(self):
3788  """
3789  GetThickness(EDA_TEXT self) -> int
3790 
3791  int
3792  EDA_TEXT::GetThickness() const
3793 
3794  Function GetThickness returns pen width.
3795  """
3796  return _pcbnew.EDA_TEXT_GetThickness(self)
3797 
3798 
3799  def SetTextAngle(self, aAngle):
3800  """
3801  SetTextAngle(EDA_TEXT self, double aAngle)
3802 
3803  void
3804  EDA_TEXT::SetTextAngle(double aAngle)
3805  """
3806  return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)
3807 
3808 
3809  def GetTextAngle(self):
3810  """
3811  GetTextAngle(EDA_TEXT self) -> double
3812 
3813  double
3814  EDA_TEXT::GetTextAngle() const
3815  """
3816  return _pcbnew.EDA_TEXT_GetTextAngle(self)
3817 
3818 
3820  """
3821  GetTextAngleDegrees(EDA_TEXT self) -> double
3822 
3823  double
3824  EDA_TEXT::GetTextAngleDegrees() const
3825  """
3826  return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)
3827 
3828 
3830  """
3831  GetTextAngleRadians(EDA_TEXT self) -> double
3832 
3833  double
3834  EDA_TEXT::GetTextAngleRadians() const
3835  """
3836  return _pcbnew.EDA_TEXT_GetTextAngleRadians(self)
3837 
3838 
3839  def SetItalic(self, isItalic):
3840  """
3841  SetItalic(EDA_TEXT self, bool isItalic)
3842 
3843  void
3844  EDA_TEXT::SetItalic(bool isItalic)
3845  """
3846  return _pcbnew.EDA_TEXT_SetItalic(self, isItalic)
3847 
3848 
3849  def IsItalic(self):
3850  """
3851  IsItalic(EDA_TEXT self) -> bool
3852 
3853  bool EDA_TEXT::IsItalic()
3854  const
3855  """
3856  return _pcbnew.EDA_TEXT_IsItalic(self)
3857 
3858 
3859  def SetBold(self, aBold):
3860  """
3861  SetBold(EDA_TEXT self, bool aBold)
3862 
3863  void EDA_TEXT::SetBold(bool
3864  aBold)
3865  """
3866  return _pcbnew.EDA_TEXT_SetBold(self, aBold)
3867 
3868 
3869  def IsBold(self):
3870  """
3871  IsBold(EDA_TEXT self) -> bool
3872 
3873  bool EDA_TEXT::IsBold()
3874  const
3875  """
3876  return _pcbnew.EDA_TEXT_IsBold(self)
3877 
3878 
3879  def SetVisible(self, aVisible):
3880  """
3881  SetVisible(EDA_TEXT self, bool aVisible)
3882 
3883  void
3884  EDA_TEXT::SetVisible(bool aVisible)
3885  """
3886  return _pcbnew.EDA_TEXT_SetVisible(self, aVisible)
3887 
3888 
3889  def IsVisible(self):
3890  """
3891  IsVisible(EDA_TEXT self) -> bool
3892 
3893  bool
3894  EDA_TEXT::IsVisible() const
3895  """
3896  return _pcbnew.EDA_TEXT_IsVisible(self)
3897 
3898 
3899  def SetMirrored(self, isMirrored):
3900  """
3901  SetMirrored(EDA_TEXT self, bool isMirrored)
3902 
3903  void
3904  EDA_TEXT::SetMirrored(bool isMirrored)
3905  """
3906  return _pcbnew.EDA_TEXT_SetMirrored(self, isMirrored)
3907 
3908 
3909  def IsMirrored(self):
3910  """
3911  IsMirrored(EDA_TEXT self) -> bool
3912 
3913  bool
3914  EDA_TEXT::IsMirrored() const
3915  """
3916  return _pcbnew.EDA_TEXT_IsMirrored(self)
3917 
3918 
3919  def SetMultilineAllowed(self, aAllow):
3920  """
3921  SetMultilineAllowed(EDA_TEXT self, bool aAllow)
3922 
3923  void
3924  EDA_TEXT::SetMultilineAllowed(bool aAllow)
3925 
3926  Function SetMultiLineAllowed.
3927 
3928  Parameters:
3929  -----------
3930 
3931  aAllow: true if ok to use multiline option, false if ok to use only
3932  single line text. (Single line is faster in calculations than
3933  multiline.)
3934  """
3935  return _pcbnew.EDA_TEXT_SetMultilineAllowed(self, aAllow)
3936 
3937 
3939  """
3940  IsMultilineAllowed(EDA_TEXT self) -> bool
3941 
3942  bool
3943  EDA_TEXT::IsMultilineAllowed() const
3944  """
3945  return _pcbnew.EDA_TEXT_IsMultilineAllowed(self)
3946 
3947 
3948  def GetHorizJustify(self):
3949  """
3950  GetHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T
3951 
3952  EDA_TEXT_HJUSTIFY_T
3953  EDA_TEXT::GetHorizJustify() const
3954  """
3955  return _pcbnew.EDA_TEXT_GetHorizJustify(self)
3956 
3957 
3958  def GetVertJustify(self):
3959  """
3960  GetVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T
3961 
3962  EDA_TEXT_VJUSTIFY_T
3963  EDA_TEXT::GetVertJustify() const
3964  """
3965  return _pcbnew.EDA_TEXT_GetVertJustify(self)
3966 
3967 
3968  def SetHorizJustify(self, aType):
3969  """
3970  SetHorizJustify(EDA_TEXT self, EDA_TEXT_HJUSTIFY_T aType)
3971 
3972  void
3973  EDA_TEXT::SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
3974  """
3975  return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)
3976 
3977 
3978  def SetVertJustify(self, aType):
3979  """
3980  SetVertJustify(EDA_TEXT self, EDA_TEXT_VJUSTIFY_T aType)
3981 
3982  void
3983  EDA_TEXT::SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
3984  """
3985  return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)
3986 
3987 
3988  def SetEffects(self, aSrc):
3989  """
3990  SetEffects(EDA_TEXT self, EDA_TEXT aSrc)
3991 
3992  void
3993  EDA_TEXT::SetEffects(const EDA_TEXT &aSrc)
3994 
3995  Function SetEffects sets the text effects from another instance.
3996 
3997  ( TEXT_EFFECTS is not exposed in the public API, but includes
3998  everything except the actual text string itself.)
3999  """
4000  return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)
4001 
4002 
4003  def SwapEffects(self, aTradingPartner):
4004  """
4005  SwapEffects(EDA_TEXT self, EDA_TEXT aTradingPartner)
4006 
4007  void
4008  EDA_TEXT::SwapEffects(EDA_TEXT &aTradingPartner)
4009 
4010  Function SwapEffects swaps the text effects of the two involved
4011  instances.
4012 
4013  (TEXT_EFECTS is not exposed in the public API, but includes everything
4014  except the actual text string itself.)
4015  """
4016  return _pcbnew.EDA_TEXT_SwapEffects(self, aTradingPartner)
4017 
4018 
4020  """
4021  IsDefaultFormatting(EDA_TEXT self) -> bool
4022 
4023  bool
4024  EDA_TEXT::IsDefaultFormatting() const
4025  """
4026  return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)
4027 
4028 
4029  def SetTextSize(self, aNewSize):
4030  """
4031  SetTextSize(EDA_TEXT self, wxSize aNewSize)
4032 
4033  void
4034  EDA_TEXT::SetTextSize(const wxSize &aNewSize)
4035  """
4036  return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize)
4037 
4038 
4039  def GetTextSize(self):
4040  """
4041  GetTextSize(EDA_TEXT self) -> wxSize
4042 
4043  const wxSize&
4044  EDA_TEXT::GetTextSize() const
4045  """
4046  return _pcbnew.EDA_TEXT_GetTextSize(self)
4047 
4048 
4049  def SetTextWidth(self, aWidth):
4050  """
4051  SetTextWidth(EDA_TEXT self, int aWidth)
4052 
4053  void
4054  EDA_TEXT::SetTextWidth(int aWidth)
4055  """
4056  return _pcbnew.EDA_TEXT_SetTextWidth(self, aWidth)
4057 
4058 
4059  def GetTextWidth(self):
4060  """
4061  GetTextWidth(EDA_TEXT self) -> int
4062 
4063  int
4064  EDA_TEXT::GetTextWidth() const
4065  """
4066  return _pcbnew.EDA_TEXT_GetTextWidth(self)
4067 
4068 
4069  def SetTextHeight(self, aHeight):
4070  """
4071  SetTextHeight(EDA_TEXT self, int aHeight)
4072 
4073  void
4074  EDA_TEXT::SetTextHeight(int aHeight)
4075  """
4076  return _pcbnew.EDA_TEXT_SetTextHeight(self, aHeight)
4077 
4078 
4079  def GetTextHeight(self):
4080  """
4081  GetTextHeight(EDA_TEXT self) -> int
4082 
4083  int
4084  EDA_TEXT::GetTextHeight() const
4085  """
4086  return _pcbnew.EDA_TEXT_GetTextHeight(self)
4087 
4088 
4089  def SetTextPos(self, aPoint):
4090  """
4091  SetTextPos(EDA_TEXT self, wxPoint aPoint)
4092 
4093  void
4094  EDA_TEXT::SetTextPos(const wxPoint &aPoint)
4095  """
4096  return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)
4097 
4098 
4099  def GetTextPos(self):
4100  """
4101  GetTextPos(EDA_TEXT self) -> wxPoint
4102 
4103  const wxPoint&
4104  EDA_TEXT::GetTextPos() const
4105  """
4106  return _pcbnew.EDA_TEXT_GetTextPos(self)
4107 
4108 
4109  def SetTextX(self, aX):
4110  """
4111  SetTextX(EDA_TEXT self, int aX)
4112 
4113  void
4114  EDA_TEXT::SetTextX(int aX)
4115  """
4116  return _pcbnew.EDA_TEXT_SetTextX(self, aX)
4117 
4118 
4119  def SetTextY(self, aY):
4120  """
4121  SetTextY(EDA_TEXT self, int aY)
4122 
4123  void
4124  EDA_TEXT::SetTextY(int aY)
4125  """
4126  return _pcbnew.EDA_TEXT_SetTextY(self, aY)
4127 
4128 
4129  def Offset(self, aOffset):
4130  """
4131  Offset(EDA_TEXT self, wxPoint aOffset)
4132 
4133  void EDA_TEXT::Offset(const
4134  wxPoint &aOffset)
4135  """
4136  return _pcbnew.EDA_TEXT_Offset(self, aOffset)
4137 
4138 
4139  def Empty(self):
4140  """
4141  Empty(EDA_TEXT self)
4142 
4143  void EDA_TEXT::Empty()
4144  """
4145  return _pcbnew.EDA_TEXT_Empty(self)
4146 
4147 
4148  def Draw(self, *args):
4149  """
4150  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED, COLOR4D aAnchor_color)
4151  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED)
4152  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode)
4153 
4154  void EDA_TEXT::Draw(EDA_RECT
4155  *aClipBox, wxDC *aDC, const wxPoint &aOffset, COLOR4D aColor,
4156  GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED, COLOR4D
4157  aAnchor_color=COLOR4D::UNSPECIFIED)
4158 
4159  Function Draw.
4160 
4161  Parameters:
4162  -----------
4163 
4164  aClipBox: = the clipping rect, or NULL if no clipping
4165 
4166  aDC: = the current Device Context
4167 
4168  aOffset: = draw offset (usually (0,0))
4169 
4170  aColor: = text color
4171 
4172  aDrawMode: = GR_OR, GR_XOR.., -1 to use the current mode.
4173 
4174  aDisplay_mode: = FILLED or SKETCH
4175 
4176  aAnchor_color: = anchor color ( COLOR4D::UNSPECIFIED = do not draw
4177  anchor ).
4178  """
4179  return _pcbnew.EDA_TEXT_Draw(self, *args)
4180 
4181 
4182  def TransformTextShapeToSegmentList(self, aCornerBuffer):
4183  """
4184  TransformTextShapeToSegmentList(EDA_TEXT self, wxPoint_Vector aCornerBuffer)
4185 
4186  void EDA_TEXT::TransformTextShapeToSegmentList(std::vector< wxPoint >
4187  &aCornerBuffer) const
4188 
4189  Convert the text shape to a list of segment each segment is stored as
4190  2 wxPoints: the starting point and the ending point there are
4191  therefore 2*n points.
4192 
4193  Parameters:
4194  -----------
4195 
4196  aCornerBuffer: = a buffer to store the polygon
4197  """
4198  return _pcbnew.EDA_TEXT_TransformTextShapeToSegmentList(self, aCornerBuffer)
4199 
4200 
4201  def TextHitTest(self, *args):
4202  """
4203  TextHitTest(EDA_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
4204  TextHitTest(EDA_TEXT self, wxPoint aPoint) -> bool
4205  TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False, int aAccuracy=0) -> bool
4206  TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False) -> bool
4207  TextHitTest(EDA_TEXT self, EDA_RECT aRect) -> bool
4208 
4209  bool
4210  EDA_TEXT::TextHitTest(const EDA_RECT &aRect, bool aContains=false, int
4211  aAccuracy=0) const
4212 
4213  Function TextHitTest (overloaded) Tests if object bounding box is
4214  contained within or intersects aRect.
4215 
4216  Parameters:
4217  -----------
4218 
4219  aRect: - Rect to test against.
4220 
4221  aContains: - Test for containment instead of intersection if true.
4222 
4223  aAccuracy: - Amount to inflate the bounding box.
4224 
4225  bool - true if a hit, else false
4226  """
4227  return _pcbnew.EDA_TEXT_TextHitTest(self, *args)
4228 
4229 
4230  def LenSize(self, aLine):
4231  """
4232  LenSize(EDA_TEXT self, wxString aLine) -> int
4233 
4234  int EDA_TEXT::LenSize(const
4235  wxString &aLine) const
4236 
4237  Function LenSize.
4238 
4239  the text length in internal units
4240 
4241  Parameters:
4242  -----------
4243 
4244  aLine: : the line of text to consider. For single line text, this
4245  parameter is always m_Text
4246  """
4247  return _pcbnew.EDA_TEXT_LenSize(self, aLine)
4248 
4249 
4250  def GetTextBox(self, aLine=-1, aThickness=-1, aInvertY=False):
4251  """
4252  GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1, bool aInvertY=False) -> EDA_RECT
4253  GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1) -> EDA_RECT
4254  GetTextBox(EDA_TEXT self, int aLine=-1) -> EDA_RECT
4255  GetTextBox(EDA_TEXT self) -> EDA_RECT
4256 
4257  EDA_RECT
4258  EDA_TEXT::GetTextBox(int aLine=-1, int aThickness=-1, bool
4259  aInvertY=false) const
4260 
4261  Function GetTextBox useful in multiline texts to calculate the full
4262  text or a line area (for zones filling, locate functions....)
4263 
4264  the rect containing the line of text (i.e. the position and the size
4265  of one line) this rectangle is calculated for 0 orient text. If
4266  orientation is not 0 the rect must be rotated to match the physical
4267  area
4268 
4269  Parameters:
4270  -----------
4271 
4272  aLine: The line of text to consider. for single line text, aLine is
4273  unused If aLine == -1, the full area (considering all lines) is
4274  returned
4275 
4276  aThickness: Overrides the current penwidth when greater than 0. This
4277  is needed when the current penwidth is 0 and a default penwidth is
4278  used.
4279 
4280  aInvertY: Invert the Y axis when calculating bounding box.
4281  """
4282  return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aThickness, aInvertY)
4283 
4284 
4285  def GetInterline(self, aTextThickness=-1):
4286  """
4287  GetInterline(EDA_TEXT self, int aTextThickness=-1) -> int
4288  GetInterline(EDA_TEXT self) -> int
4289 
4290  int
4291  EDA_TEXT::GetInterline(int aTextThickness=-1) const
4292 
4293  Function GetInterline return the distance between 2 text lines has
4294  meaning only for multiline texts.
4295 
4296  Calculates the distance (pitch) between 2 text lines the distance
4297  includes the interline + room for chars like j { and [ Is used for
4298  multiline texts, but also for single line texts, to calculate the text
4299  bounding box
4300 
4301  Parameters:
4302  -----------
4303 
4304  aTextThickness: Overrides the current thickness when greater than 0.
4305  this is needed when the current m_Thickness is 0 and a default line
4306  thickness is used
4307  """
4308  return _pcbnew.EDA_TEXT_GetInterline(self, aTextThickness)
4309 
4310 
4311  def GetTextStyleName(self):
4312  """
4313  GetTextStyleName(EDA_TEXT self) -> wxString
4314 
4315  wxString
4316  EDA_TEXT::GetTextStyleName()
4317 
4318  Function GetTextStyleName.
4319 
4320  a wxString with the style name( Normal, Italic, Bold, Bold+Italic)
4321  """
4322  return _pcbnew.EDA_TEXT_GetTextStyleName(self)
4323 
4324 
4325  def GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount):
4326  """
4327  GetPositionsOfLinesOfMultilineText(EDA_TEXT self, wxPoint_Vector aPositions, int aLineCount)
4328 
4329  void EDA_TEXT::GetPositionsOfLinesOfMultilineText(std::vector< wxPoint
4330  > &aPositions, int aLineCount) const
4331 
4332  Function GetPositionsOfLinesOfMultilineText Populates aPositions with
4333  the position of each line of a multiline text, according to the
4334  vertical justification and the rotation of the whole text.
4335 
4336  Parameters:
4337  -----------
4338 
4339  aPositions: is the list to populate by the wxPoint positions
4340 
4341  aLineCount: is the number of lines (not recalculated here for
4342  efficiency reasons
4343  """
4344  return _pcbnew.EDA_TEXT_GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount)
4345 
4346 
4347  def Format(self, aFormatter, aNestLevel, aControlBits):
4348  """
4349  Format(EDA_TEXT self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)
4350 
4351  void
4352  EDA_TEXT::Format(OUTPUTFORMATTER *aFormatter, int aNestLevel, int
4353  aControlBits) const throw ( IO_ERROR ) Function Format outputs the
4354  object to aFormatter in s-expression form.
4355 
4356  Parameters:
4357  -----------
4358 
4359  aFormatter: The OUTPUTFORMATTER object to write to.
4360 
4361  aNestLevel: The indentation next level.
4362 
4363  aControlBits: The control bit definition for object specific
4364  formatting.
4365 
4366  Parameters:
4367  -----------
4368 
4369  ???: on write error.
4370  """
4371  return _pcbnew.EDA_TEXT_Format(self, aFormatter, aNestLevel, aControlBits)
4372 
4373 EDA_TEXT_swigregister = _pcbnew.EDA_TEXT_swigregister
4374 EDA_TEXT_swigregister(EDA_TEXT)
4375 
4377  """Proxy of C++ std::vector<(int)> class"""
4378  __swig_setmethods__ = {}
4379  __setattr__ = lambda self, name, value: _swig_setattr(self, intVector, name, value)
4380  __swig_getmethods__ = {}
4381  __getattr__ = lambda self, name: _swig_getattr(self, intVector, name)
4382  __repr__ = _swig_repr
4383 
4384  def iterator(self):
4385  """iterator(intVector self) -> SwigPyIterator"""
4386  return _pcbnew.intVector_iterator(self)
4387 
4388  def __iter__(self):
4389  return self.iterator()
4390 
4391  def __nonzero__(self):
4392  """__nonzero__(intVector self) -> bool"""
4393  return _pcbnew.intVector___nonzero__(self)
4394 
4395 
4396  def __bool__(self):
4397  """__bool__(intVector self) -> bool"""
4398  return _pcbnew.intVector___bool__(self)
4399 
4400 
4401  def __len__(self):
4402  """__len__(intVector self) -> std::vector< int >::size_type"""
4403  return _pcbnew.intVector___len__(self)
4404 
4405 
4406  def pop(self):
4407  """pop(intVector self) -> std::vector< int >::value_type"""
4408  return _pcbnew.intVector_pop(self)
4409 
4410 
4411  def __getslice__(self, i, j):
4412  """__getslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> intVector"""
4413  return _pcbnew.intVector___getslice__(self, i, j)
4414 
4415 
4416  def __setslice__(self, *args):
4417  """
4418  __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, intVector v)
4419  __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
4420  """
4421  return _pcbnew.intVector___setslice__(self, *args)
4422 
4423 
4424  def __delslice__(self, i, j):
4425  """__delslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
4426  return _pcbnew.intVector___delslice__(self, i, j)
4427 
4428 
4429  def __delitem__(self, *args):
4430  """
4431  __delitem__(intVector self, std::vector< int >::difference_type i)
4432  __delitem__(intVector self, PySliceObject * slice)
4433  """
4434  return _pcbnew.intVector___delitem__(self, *args)
4435 
4436 
4437  def __getitem__(self, *args):
4438  """
4439  __getitem__(intVector self, PySliceObject * slice) -> intVector
4440  __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
4441  """
4442  return _pcbnew.intVector___getitem__(self, *args)
4443 
4444 
4445  def __setitem__(self, *args):
4446  """
4447  __setitem__(intVector self, PySliceObject * slice, intVector v)
4448  __setitem__(intVector self, PySliceObject * slice)
4449  __setitem__(intVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
4450  """
4451  return _pcbnew.intVector___setitem__(self, *args)
4452 
4453 
4454  def append(self, x):
4455  """append(intVector self, std::vector< int >::value_type const & x)"""
4456  return _pcbnew.intVector_append(self, x)
4457 
4458 
4459  def empty(self):
4460  """empty(intVector self) -> bool"""
4461  return _pcbnew.intVector_empty(self)
4462 
4463 
4464  def size(self):
4465  """size(intVector self) -> std::vector< int >::size_type"""
4466  return _pcbnew.intVector_size(self)
4467 
4468 
4469  def clear(self):
4470  """clear(intVector self)"""
4471  return _pcbnew.intVector_clear(self)
4472 
4473 
4474  def swap(self, v):
4475  """swap(intVector self, intVector v)"""
4476  return _pcbnew.intVector_swap(self, v)
4477 
4478 
4479  def get_allocator(self):
4480  """get_allocator(intVector self) -> std::vector< int >::allocator_type"""
4481  return _pcbnew.intVector_get_allocator(self)
4482 
4483 
4484  def begin(self):
4485  """begin(intVector self) -> std::vector< int >::iterator"""
4486  return _pcbnew.intVector_begin(self)
4487 
4488 
4489  def end(self):
4490  """end(intVector self) -> std::vector< int >::iterator"""
4491  return _pcbnew.intVector_end(self)
4492 
4493 
4494  def rbegin(self):
4495  """rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
4496  return _pcbnew.intVector_rbegin(self)
4497 
4498 
4499  def rend(self):
4500  """rend(intVector self) -> std::vector< int >::reverse_iterator"""
4501  return _pcbnew.intVector_rend(self)
4502 
4503 
4504  def pop_back(self):
4505  """pop_back(intVector self)"""
4506  return _pcbnew.intVector_pop_back(self)
4507 
4508 
4509  def erase(self, *args):
4510  """
4511  erase(intVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
4512  erase(intVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
4513  """
4514  return _pcbnew.intVector_erase(self, *args)
4515 
4516 
4517  def __init__(self, *args):
4518  """
4519  __init__(std::vector<(int)> self) -> intVector
4520  __init__(std::vector<(int)> self, intVector arg2) -> intVector
4521  __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> intVector
4522  __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
4523  """
4524  this = _pcbnew.new_intVector(*args)
4525  try:
4526  self.this.append(this)
4527  except:
4528  self.this = this
4529 
4530  def push_back(self, x):
4531  """push_back(intVector self, std::vector< int >::value_type const & x)"""
4532  return _pcbnew.intVector_push_back(self, x)
4533 
4534 
4535  def front(self):
4536  """front(intVector self) -> std::vector< int >::value_type const &"""
4537  return _pcbnew.intVector_front(self)
4538 
4539 
4540  def back(self):
4541  """back(intVector self) -> std::vector< int >::value_type const &"""
4542  return _pcbnew.intVector_back(self)
4543 
4544 
4545  def assign(self, n, x):
4546  """assign(intVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
4547  return _pcbnew.intVector_assign(self, n, x)
4548 
4549 
4550  def resize(self, *args):
4551  """
4552  resize(intVector self, std::vector< int >::size_type new_size)
4553  resize(intVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
4554  """
4555  return _pcbnew.intVector_resize(self, *args)
4556 
4557 
4558  def insert(self, *args):
4559  """
4560  insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
4561  insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
4562  """
4563  return _pcbnew.intVector_insert(self, *args)
4564 
4565 
4566  def reserve(self, n):
4567  """reserve(intVector self, std::vector< int >::size_type n)"""
4568  return _pcbnew.intVector_reserve(self, n)
4569 
4570 
4571  def capacity(self):
4572  """capacity(intVector self) -> std::vector< int >::size_type"""
4573  return _pcbnew.intVector_capacity(self)
4574 
4575  __swig_destroy__ = _pcbnew.delete_intVector
4576  __del__ = lambda self: None
4577 intVector_swigregister = _pcbnew.intVector_swigregister
4578 intVector_swigregister(intVector)
4579 
4581  """Proxy of C++ std::map<(std::string,UTF8)> class"""
4582  __swig_setmethods__ = {}
4583  __setattr__ = lambda self, name, value: _swig_setattr(self, str_utf8_Map, name, value)
4584  __swig_getmethods__ = {}
4585  __getattr__ = lambda self, name: _swig_getattr(self, str_utf8_Map, name)
4586  __repr__ = _swig_repr
4587 
4588  def iterator(self):
4589  """iterator(str_utf8_Map self) -> SwigPyIterator"""
4590  return _pcbnew.str_utf8_Map_iterator(self)
4591 
4592  def __iter__(self):
4593  return self.iterator()
4594 
4595  def __nonzero__(self):
4596  """__nonzero__(str_utf8_Map self) -> bool"""
4597  return _pcbnew.str_utf8_Map___nonzero__(self)
4598 
4599 
4600  def __bool__(self):
4601  """__bool__(str_utf8_Map self) -> bool"""
4602  return _pcbnew.str_utf8_Map___bool__(self)
4603 
4604 
4605  def __len__(self):
4606  """__len__(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4607  return _pcbnew.str_utf8_Map___len__(self)
4608 
4609  def __iter__(self):
4610  return self.key_iterator()
4611  def iterkeys(self):
4612  return self.key_iterator()
4613  def itervalues(self):
4614  return self.value_iterator()
4615  def iteritems(self):
4616  return self.iterator()
4617 
4618  def __getitem__(self, key):
4619  """__getitem__(str_utf8_Map self, string key) -> UTF8"""
4620  return _pcbnew.str_utf8_Map___getitem__(self, key)
4621 
4622 
4623  def __delitem__(self, key):
4624  """__delitem__(str_utf8_Map self, string key)"""
4625  return _pcbnew.str_utf8_Map___delitem__(self, key)
4626 
4627 
4628  def has_key(self, key):
4629  """has_key(str_utf8_Map self, string key) -> bool"""
4630  return _pcbnew.str_utf8_Map_has_key(self, key)
4631 
4632 
4633  def keys(self):
4634  """keys(str_utf8_Map self) -> PyObject *"""
4635  return _pcbnew.str_utf8_Map_keys(self)
4636 
4637 
4638  def values(self):
4639  """values(str_utf8_Map self) -> PyObject *"""
4640  return _pcbnew.str_utf8_Map_values(self)
4641 
4642 
4643  def items(self):
4644  """items(str_utf8_Map self) -> PyObject *"""
4645  return _pcbnew.str_utf8_Map_items(self)
4646 
4647 
4648  def __contains__(self, key):
4649  """__contains__(str_utf8_Map self, string key) -> bool"""
4650  return _pcbnew.str_utf8_Map___contains__(self, key)
4651 
4652 
4653  def key_iterator(self):
4654  """key_iterator(str_utf8_Map self) -> SwigPyIterator"""
4655  return _pcbnew.str_utf8_Map_key_iterator(self)
4656 
4657 
4658  def value_iterator(self):
4659  """value_iterator(str_utf8_Map self) -> SwigPyIterator"""
4660  return _pcbnew.str_utf8_Map_value_iterator(self)
4661 
4662 
4663  def __setitem__(self, *args):
4664  """
4665  __setitem__(str_utf8_Map self, string key)
4666  __setitem__(str_utf8_Map self, string key, UTF8 x)
4667  """
4668  return _pcbnew.str_utf8_Map___setitem__(self, *args)
4669 
4670 
4671  def asdict(self):
4672  """asdict(str_utf8_Map self) -> PyObject *"""
4673  return _pcbnew.str_utf8_Map_asdict(self)
4674 
4675 
4676  def __init__(self, *args):
4677  """
4678  __init__(std::map<(std::string,UTF8)> self, std::less< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > const & arg2) -> str_utf8_Map
4679  __init__(std::map<(std::string,UTF8)> self) -> str_utf8_Map
4680  __init__(std::map<(std::string,UTF8)> self, str_utf8_Map arg2) -> str_utf8_Map
4681  """
4682  this = _pcbnew.new_str_utf8_Map(*args)
4683  try:
4684  self.this.append(this)
4685  except:
4686  self.this = this
4687 
4688  def empty(self):
4689  """empty(str_utf8_Map self) -> bool"""
4690  return _pcbnew.str_utf8_Map_empty(self)
4691 
4692 
4693  def size(self):
4694  """size(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4695  return _pcbnew.str_utf8_Map_size(self)
4696 
4697 
4698  def clear(self):
4699  """clear(str_utf8_Map self)"""
4700  return _pcbnew.str_utf8_Map_clear(self)
4701 
4702 
4703  def swap(self, v):
4704  """swap(str_utf8_Map self, str_utf8_Map v)"""
4705  return _pcbnew.str_utf8_Map_swap(self, v)
4706 
4707 
4708  def get_allocator(self):
4709  """get_allocator(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type"""
4710  return _pcbnew.str_utf8_Map_get_allocator(self)
4711 
4712 
4713  def begin(self):
4714  """begin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4715  return _pcbnew.str_utf8_Map_begin(self)
4716 
4717 
4718  def end(self):
4719  """end(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4720  return _pcbnew.str_utf8_Map_end(self)
4721 
4722 
4723  def rbegin(self):
4724  """rbegin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
4725  return _pcbnew.str_utf8_Map_rbegin(self)
4726 
4727 
4728  def rend(self):
4729  """rend(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
4730  return _pcbnew.str_utf8_Map_rend(self)
4731 
4732 
4733  def count(self, x):
4734  """count(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4735  return _pcbnew.str_utf8_Map_count(self, x)
4736 
4737 
4738  def erase(self, *args):
4739  """
4740  erase(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type
4741  erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator position)
4742  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)
4743  """
4744  return _pcbnew.str_utf8_Map_erase(self, *args)
4745 
4746 
4747  def find(self, x):
4748  """find(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4749  return _pcbnew.str_utf8_Map_find(self, x)
4750 
4751 
4752  def lower_bound(self, x):
4753  """lower_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4754  return _pcbnew.str_utf8_Map_lower_bound(self, x)
4755 
4756 
4757  def upper_bound(self, x):
4758  """upper_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4759  return _pcbnew.str_utf8_Map_upper_bound(self, x)
4760 
4761  __swig_destroy__ = _pcbnew.delete_str_utf8_Map
4762  __del__ = lambda self: None
4763 str_utf8_Map_swigregister = _pcbnew.str_utf8_Map_swigregister
4764 str_utf8_Map_swigregister(str_utf8_Map)
4765 
4767  """Proxy of C++ std::vector<(enum PCB_LAYER_ID)> class"""
4768  __swig_setmethods__ = {}
4769  __setattr__ = lambda self, name, value: _swig_setattr(self, base_seqVect, name, value)
4770  __swig_getmethods__ = {}
4771  __getattr__ = lambda self, name: _swig_getattr(self, base_seqVect, name)
4772  __repr__ = _swig_repr
4773 
4774  def iterator(self):
4775  """iterator(base_seqVect self) -> SwigPyIterator"""
4776  return _pcbnew.base_seqVect_iterator(self)
4777 
4778  def __iter__(self):
4779  return self.iterator()
4780 
4781  def __nonzero__(self):
4782  """__nonzero__(base_seqVect self) -> bool"""
4783  return _pcbnew.base_seqVect___nonzero__(self)
4784 
4785 
4786  def __bool__(self):
4787  """__bool__(base_seqVect self) -> bool"""
4788  return _pcbnew.base_seqVect___bool__(self)
4789 
4790 
4791  def __len__(self):
4792  """__len__(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4793  return _pcbnew.base_seqVect___len__(self)
4794 
4795 
4796  def pop(self):
4797  """pop(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type"""
4798  return _pcbnew.base_seqVect_pop(self)
4799 
4800 
4801  def __getslice__(self, i, j):
4802  """__getslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j) -> base_seqVect"""
4803  return _pcbnew.base_seqVect___getslice__(self, i, j)
4804 
4805 
4806  def __setslice__(self, *args):
4807  """
4808  __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)
4809  __setslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)
4810  """
4811  return _pcbnew.base_seqVect___setslice__(self, *args)
4812 
4813 
4814  def __delslice__(self, i, j):
4815  """__delslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)"""
4816  return _pcbnew.base_seqVect___delslice__(self, i, j)
4817 
4818 
4819  def __delitem__(self, *args):
4820  """
4821  __delitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i)
4822  __delitem__(base_seqVect self, PySliceObject * slice)
4823  """
4824  return _pcbnew.base_seqVect___delitem__(self, *args)
4825 
4826 
4827  def __getitem__(self, *args):
4828  """
4829  __getitem__(base_seqVect self, PySliceObject * slice) -> base_seqVect
4830  __getitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i) -> std::vector< enum PCB_LAYER_ID >::value_type const &
4831  """
4832  return _pcbnew.base_seqVect___getitem__(self, *args)
4833 
4834 
4835  def __setitem__(self, *args):
4836  """
4837  __setitem__(base_seqVect self, PySliceObject * slice, base_seqVect v)
4838  __setitem__(base_seqVect self, PySliceObject * slice)
4839  __setitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::value_type const & x)
4840  """
4841  return _pcbnew.base_seqVect___setitem__(self, *args)
4842 
4843 
4844  def append(self, x):
4845  """append(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4846  return _pcbnew.base_seqVect_append(self, x)
4847 
4848 
4849  def empty(self):
4850  """empty(base_seqVect self) -> bool"""
4851  return _pcbnew.base_seqVect_empty(self)
4852 
4853 
4854  def size(self):
4855  """size(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4856  return _pcbnew.base_seqVect_size(self)
4857 
4858 
4859  def clear(self):
4860  """clear(base_seqVect self)"""
4861  return _pcbnew.base_seqVect_clear(self)
4862 
4863 
4864  def swap(self, v):
4865  """swap(base_seqVect self, base_seqVect v)"""
4866  return _pcbnew.base_seqVect_swap(self, v)
4867 
4868 
4869  def get_allocator(self):
4870  """get_allocator(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::allocator_type"""
4871  return _pcbnew.base_seqVect_get_allocator(self)
4872 
4873 
4874  def begin(self):
4875  """begin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
4876  return _pcbnew.base_seqVect_begin(self)
4877 
4878 
4879  def end(self):
4880  """end(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
4881  return _pcbnew.base_seqVect_end(self)
4882 
4883 
4884  def rbegin(self):
4885  """rbegin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
4886  return _pcbnew.base_seqVect_rbegin(self)
4887 
4888 
4889  def rend(self):
4890  """rend(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
4891  return _pcbnew.base_seqVect_rend(self)
4892 
4893 
4894  def pop_back(self):
4895  """pop_back(base_seqVect self)"""
4896  return _pcbnew.base_seqVect_pop_back(self)
4897 
4898 
4899  def erase(self, *args):
4900  """
4901  erase(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator pos) -> std::vector< enum PCB_LAYER_ID >::iterator
4902  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
4903  """
4904  return _pcbnew.base_seqVect_erase(self, *args)
4905 
4906 
4907  def __init__(self, *args):
4908  """
4909  __init__(std::vector<(enum PCB_LAYER_ID)> self) -> base_seqVect
4910  __init__(std::vector<(enum PCB_LAYER_ID)> self, base_seqVect arg2) -> base_seqVect
4911  __init__(std::vector<(enum PCB_LAYER_ID)> self, std::vector< enum PCB_LAYER_ID >::size_type size) -> base_seqVect
4912  __init__(std::vector<(enum PCB_LAYER_ID)> self, std::vector< enum PCB_LAYER_ID >::size_type size, std::vector< enum PCB_LAYER_ID >::value_type const & value) -> base_seqVect
4913  """
4914  this = _pcbnew.new_base_seqVect(*args)
4915  try:
4916  self.this.append(this)
4917  except:
4918  self.this = this
4919 
4920  def push_back(self, x):
4921  """push_back(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4922  return _pcbnew.base_seqVect_push_back(self, x)
4923 
4924 
4925  def front(self):
4926  """front(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
4927  return _pcbnew.base_seqVect_front(self)
4928 
4929 
4930  def back(self):
4931  """back(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
4932  return _pcbnew.base_seqVect_back(self)
4933 
4934 
4935  def assign(self, n, x):
4936  """assign(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4937  return _pcbnew.base_seqVect_assign(self, n, x)
4938 
4939 
4940  def resize(self, *args):
4941  """
4942  resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size)
4943  resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size, std::vector< enum PCB_LAYER_ID >::value_type const & x)
4944  """
4945  return _pcbnew.base_seqVect_resize(self, *args)
4946 
4947 
4948  def insert(self, *args):
4949  """
4950  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
4951  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)
4952  """
4953  return _pcbnew.base_seqVect_insert(self, *args)
4954 
4955 
4956  def reserve(self, n):
4957  """reserve(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n)"""
4958  return _pcbnew.base_seqVect_reserve(self, n)
4959 
4960 
4961  def capacity(self):
4962  """capacity(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4963  return _pcbnew.base_seqVect_capacity(self)
4964 
4965  __swig_destroy__ = _pcbnew.delete_base_seqVect
4966  __del__ = lambda self: None
4967 base_seqVect_swigregister = _pcbnew.base_seqVect_swigregister
4968 base_seqVect_swigregister(base_seqVect)
4969 
4970 
4971 
4972 KICAD_PLUGINS={} # the list of loaded footprint wizards
4973 
4974 """ the list of not loaded python scripts
4975  (usually because there is a syntax error in python script)
4976  this is the python script full filenames list.
4977  filenames are separated by '\n'
4978 """
4979 NOT_LOADED_WIZARDS=""
4980 
4981 """ the list of paths used to search python scripts.
4982  Stored here to be displayed on request in Pcbnew
4983  paths are separated by '\n'
4984 """
4985 PLUGIN_DIRECTORIES_SEARCH=""
4986 
4987 """ the trace of errors during execution of footprint wizards scripts
4988 """
4989 FULL_BACK_TRACE=""
4990 
4992  global NOT_LOADED_WIZARDS
4993  return NOT_LOADED_WIZARDS
4994 
4996  global PLUGIN_DIRECTORIES_SEARCH
4997  return PLUGIN_DIRECTORIES_SEARCH
4998 
5000  global FULL_BACK_TRACE
5001  return FULL_BACK_TRACE
5002 
5003 
5004 def LoadPlugins(bundlepath=None):
5005  """
5006  Initialise Scripting/Plugin python environment and load plugins.
5007 
5008  Arguments:
5009  scriptpath -- The path to the bundled scripts.
5010  The bunbled Plugins are relative to this path, in the
5011  "plugins" subdirectory.
5012 
5013  NOTE: These are all of the possible "default" search paths for kicad
5014  python scripts. These paths will ONLY be added to the python
5015  search path ONLY IF they already exist.
5016 
5017  The Scripts bundled with the KiCad installation:
5018  <bundlepath>/
5019  <bundlepath>/plugins/
5020 
5021  The Scripts relative to the KiCad search path environment variable:
5022  [KICAD_PATH]/scripting/
5023  [KICAD_PATH]/scripting/plugins/
5024 
5025  The Scripts relative to the KiCad Users configuration:
5026  <kicad_config_path>/scripting/
5027  <kicad_config_path>/scripting/plugins/
5028 
5029  And on Linux ONLY, extra paths relative to the users home directory:
5030  ~/.kicad_plugins/
5031  ~/.kicad/scripting/
5032  ~/.kicad/scripting/plugins/
5033  """
5034  import os
5035  import sys
5036  import traceback
5037  import pcbnew
5038 
5039  kicad_path = os.environ.get('KICAD_PATH')
5040  config_path = pcbnew.GetKicadConfigPath()
5041  plugin_directories=[]
5042 
5043  if bundlepath:
5044  plugin_directories.append(bundlepath)
5045  plugin_directories.append(os.path.join(bundlepath, 'plugins'))
5046 
5047  if kicad_path:
5048  plugin_directories.append(os.path.join(kicad_path, 'scripting'))
5049  plugin_directories.append(os.path.join(kicad_path, 'scripting', 'plugins'))
5050 
5051  if config_path:
5052  plugin_directories.append(os.path.join(config_path, 'scripting'))
5053  plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))
5054 
5055  if sys.platform.startswith('linux'):
5056  plugin_directories.append(os.environ['HOME']+'/.kicad_plugins/')
5057  plugin_directories.append(os.environ['HOME']+'/.kicad/scripting/')
5058  plugin_directories.append(os.environ['HOME']+'/.kicad/scripting/plugins/')
5059 
5060  global PLUGIN_DIRECTORIES_SEARCH
5061  PLUGIN_DIRECTORIES_SEARCH=""
5062  for plugins_dir in plugin_directories: # save search path list for later use
5063  if PLUGIN_DIRECTORIES_SEARCH != "" :
5064  PLUGIN_DIRECTORIES_SEARCH += "\n"
5065  PLUGIN_DIRECTORIES_SEARCH += plugins_dir
5066 
5067  global FULL_BACK_TRACE
5068  FULL_BACK_TRACE="" # clear any existing trace
5069  failed_wizards_list=""
5070 
5071  global KICAD_PLUGINS
5072 
5073  for plugins_dir in plugin_directories:
5074  if not os.path.isdir(plugins_dir):
5075  continue
5076 
5077  sys.path.append(plugins_dir)
5078 
5079  for module in os.listdir(plugins_dir):
5080  if os.path.isdir(plugins_dir+module):
5081  __import__(module, locals(), globals())
5082 
5083  if module == '__init__.py' or module[-3:] != '.py':
5084  continue
5085 
5086  try: # If there is an error loading the script, skip it
5087  module_filename = plugins_dir + "/" + module
5088  mtime = os.path.getmtime(module_filename)
5089 
5090  if KICAD_PLUGINS.has_key(module):
5091  plugin = KICAD_PLUGINS[module]
5092  if not plugin["modification_time"] == mtime:
5093  mod = reload(plugin["module"])
5094  plugin["modification_time"] = mtime
5095  else:
5096  mod = plugin["module"]
5097  else:
5098  mod = __import__(module[:-3], locals(), globals() )
5099 
5100  KICAD_PLUGINS[module]={"filename":module_filename,
5101  "modification_time":mtime,
5102  "module":mod}
5103 
5104  except:
5105  if failed_wizards_list != "" :
5106  failed_wizards_list += "\n"
5107  failed_wizards_list += module_filename
5108  FULL_BACK_TRACE += traceback.format_exc(sys.exc_info())
5109  pass
5110 
5111  global NOT_LOADED_WIZARDS
5112  NOT_LOADED_WIZARDS = failed_wizards_list # save not loaded wizards names list for later use
5113 
5114 
5116  def __init__(self):
5117  pass
5118 
5119  def register(self):
5120  if isinstance(self,FilePlugin):
5121  pass # register to file plugins in C++
5122 
5123  if isinstance(self,FootprintWizardPlugin):
5124  PYTHON_FOOTPRINT_WIZARDS.register_wizard(self)
5125  return
5126 
5127  if isinstance(self,ActionPlugin):
5128  PYTHON_ACTION_PLUGINS.register_action(self)
5129  return
5130 
5131  return
5132 
5133  def deregister(self):
5134  if isinstance(self,FilePlugin):
5135  pass # deregister to file plugins in C++
5136 
5137  if isinstance(self,FootprintWizardPlugin):
5138  PYTHON_FOOTPRINT_WIZARDS.deregister_wizard(self)
5139  return
5140 
5141  if isinstance(self,ActionPlugin):
5142  PYTHON_ACTION_PLUGINS.deregister_action(self)
5143  return
5144 
5145  return
5146 
5147 
5149  def __init__(self):
5150  KiCadPlugin.__init__(self)
5151 
5152 
5153 from math import ceil, floor, sqrt
5154 
5155 uMM = "mm" # Millimetres
5156 uMils = "mils" # Mils
5157 uFloat = "float" # Natural number units (dimensionless)
5158 uInteger = "integer" # Integer (no decimals, numeric, dimensionless)
5159 uBool = "bool" # Boolean value
5160 uRadians = "radians" # Angular units (radians)
5161 uDegrees = "degrees" # Angular units (degrees)
5162 uPercent = "%" # Percent (0% -> 100%)
5163 uString = "string" # Raw string
5164 
5165 uNumeric = [uMM, uMils, uFloat, uInteger, uDegrees, uRadians, uPercent] # List of numeric types
5166 uUnits = [uMM, uMils, uFloat, uInteger, uBool, uDegrees, uRadians, uPercent, uString] # List of allowable types
5167 
5169  _true = ['true','t','y','yes','on','1',1,]
5170  _false = ['false','f','n','no','off','0',0,'',None]
5171 
5172  _bools = _true + _false
5173 
5174  def __init__(self, page, name, units, default, **kwarg):
5175  self.page = page
5176  self.name = name
5177  self.hint = kwarg.get('hint','') # Parameter hint (shown as mouse-over text)
5178  self.designator = kwarg.get('designator',' ') # Parameter designator such as "e, D, p" (etc)
5179 
5180  if units.lower() in uUnits:
5181  self.units = units.lower()
5182  elif units.lower() == 'percent':
5183  self.units = uPercent
5184  elif type(units) in [list, tuple]: # Convert a list of options into a single string
5185  self.units = ",".join([str(el).strip() for el in units])
5186  else:
5187  self.units = units
5188 
5189  self.multiple = int(kwarg.get('multiple',1)) # Check integer values are multiples of this number
5190  self.min_value = kwarg.get('min_value',None) # Check numeric values are above or equal to this number
5191  self.max_value = kwarg.get('max_value',None) # Check numeric values are below or equal to this number
5192 
5193  self.SetValue(default)
5194  self.default = self.raw_value # Save value as default
5195 
5196  def ClearErrors(self):
5197  self.error_list = []
5198 
5199  def AddError(self, err, info=None):
5200 
5201  if err in self.error_list: # prevent duplicate error messages
5202  return
5203  if info is not None:
5204  err = err + " (" + str(info) + ")"
5205 
5206  self.error_list.append(err)
5207 
5208  def Check(self, min_value=None, max_value=None, multiple=None, info=None):
5209 
5210  if min_value is None:
5211  min_value = self.min_value
5212  if max_value is None:
5213  max_value = self.max_value
5214  if multiple is None:
5215  multiple = self.multiple
5216 
5217  if self.units not in uUnits and ',' not in self.units: # Allow either valid units or a list of strings
5218  self.AddError("type '{t}' unknown".format(t=self.units),info)
5219  self.AddError("Allowable types: " + str(self.units),info)
5220 
5221  if self.units in uNumeric:
5222  try:
5223  to_num = float(self.raw_value)
5224 
5225  if min_value is not None: # Check minimum value if it is present
5226  if to_num < min_value:
5227  self.AddError("value '{v}' is below minimum ({m})".format(v=self.raw_value,m=min_value),info)
5228 
5229  if max_value is not None: # Check maximum value if it is present
5230  if to_num > max_value:
5231  self.AddError("value '{v}' is above maximum ({m})".format(v=self.raw_value,m=max_value),info)
5232 
5233  except:
5234  self.AddError("value '{v}' is not of type '{t}'".format(v = self.raw_value, t=self.units),info)
5235 
5236  if self.units == uInteger: # Perform integer specific checks
5237  try:
5238  to_int = int(self.raw_value)
5239 
5240  if multiple is not None and multiple > 1:
5241  if (to_int % multiple) > 0:
5242  self.AddError("value '{v}' is not a multiple of {m}".format(v=self.raw_value,m=multiple),info)
5243  except:
5244  self.AddError("value {'v}' is not an integer".format(v=self.raw_value),info)
5245 
5246  if self.units == uBool: # Check that the value is of a correct boolean format
5247  if self.raw_value in [True,False] or str(self.raw_value).lower() in self._bools:
5248  pass
5249  else:
5250  self.AddError("value '{v}' is not a boolean value".format(v = self.raw_value),info)
5251 
5252  @property
5253  def value(self): # Return the current value, converted to appropriate units (from string representation) if required
5254  v = str(self.raw_value) # Enforce string type for known starting point
5255 
5256  if self.units == uInteger: # Integer values
5257  return int(v)
5258  elif self.units in uNumeric: # Any values that use floating points
5259  v = v.replace(",",".") # Replace "," separators with "."
5260  v = float(v)
5261 
5262  if self.units == uMM: # Convert from millimetres to nanometres
5263  return FromMM(v)
5264 
5265  elif self.units == uMils: # Convert from mils to nanometres
5266  return FromMils(v)
5267 
5268  else: # Any other floating-point values
5269  return v
5270 
5271  elif self.units == uBool:
5272  if v.lower() in self._true:
5273  return True
5274  else:
5275  return False
5276  else:
5277  return v
5278 
5279  def DefaultValue(self): # Reset the value of the parameter to its default
5280  self.raw_value = str(self.default)
5281 
5282  def SetValue(self, new_value): # Update the value
5283  new_value = str(new_value)
5284 
5285  if len(new_value.strip()) == 0:
5286  if not self.units in [uString, uBool]:
5287  return # Ignore empty values unless for strings or bools
5288 
5289  if self.units == uBool: # Enforce the same boolean representation as is used in KiCad
5290  new_value = "1" if new_value.lower() in self._true else "0"
5291  elif self.units in uNumeric:
5292  new_value = new_value.replace(",", ".") # Enforce decimal point separators
5293  elif ',' in self.units: # Select from a list of values
5294  if new_value not in self.units.split(','):
5295  new_value = self.units.split(',')[0]
5296 
5297  self.raw_value = new_value
5298 
5299  def __str__(self): # pretty-print the parameter
5300 
5301  s = self.name + ": " + str(self.raw_value)
5302 
5303  if self.units in [uMM, uMils, uPercent, uRadians, uDegrees]:
5304  s += self.units
5305  elif self.units == uBool: # Special case for Boolean values
5306  s = self.name + ": {b}".format(b = "True" if self.value else "False")
5307  elif self.units == uString:
5308  s = self.name + ": '" + self.raw_value + "'"
5309 
5310  return s
5311 
5312 
5314  def __init__(self):
5315  KiCadPlugin.__init__(self)
5316  self.defaults()
5317 
5318  def defaults(self):
5319  self.module = None
5320  self.params = [] # List of added parameters that observes addition order
5321 
5322  self.name = "KiCad FP Wizard"
5323  self.description = "Undefined Footprint Wizard plugin"
5324  self.image = ""
5325  self.buildmessages = ""
5326 
5327  def AddParam(self, page, name, unit, default, **kwarg):
5328 
5329  if self.GetParam(page,name) is not None: # Param already exists!
5330  return
5331 
5332  param = FootprintWizardParameter(page, name, unit, default, **kwarg) # Create a new parameter
5333  self.params.append(param)
5334 
5335  @property
5336  def parameters(self): # This is a helper function that returns a nested (unordered) dict of the VALUES of parameters
5337  pages = {} # Page dict
5338  for p in self.params:
5339  if p.page not in pages:
5340  pages[p.page] = {}
5341 
5342  pages[p.page][p.name] = p.value # Return the 'converted' value (convert from string to actual useful units)
5343 
5344  return pages
5345 
5346  @property
5347  def values(self): # Same as above
5348  return self.parameters
5349 
5350  def ResetWizard(self): # Reset all parameters to default values
5351  for p in self.params:
5352  p.DefaultValue()
5353 
5354  def GetName(self): # Return the name of this wizard
5355  return self.name
5356 
5357  def GetImage(self): # Return the filename of the preview image associated with this wizard
5358  return self.image
5359 
5360  def GetDescription(self): # Return the description text
5361  return self.description
5362 
5363  def GetValue(self):
5364  raise NotImplementedError
5365 
5367  return "REF" # Default reference prefix for any footprint
5368 
5369  def GetParam(self, page, name): # Grab a parameter
5370  for p in self.params:
5371  if p.page == page and p.name == name:
5372  return p
5373 
5374  return None
5375 
5376  def CheckParam(self, page, name, **kwarg):
5377  self.GetParam(page,name).Check(**kwarg)
5378 
5379  def AnyErrors(self):
5380  return any([len(p.error_list) > 0 for p in self.params])
5381 
5382  @property
5383  def pages(self): # Return an (ordered) list of the available page names
5384  page_list = []
5385  for p in self.params:
5386  if p.page not in page_list:
5387  page_list.append(p.page)
5388 
5389  return page_list
5390 
5391  def GetNumParameterPages(self): # Return the number of parameter pages
5392  return len(self.pages)
5393 
5394  def GetParameterPageName(self,page_n): # Return the name of a page at a given index
5395  return self.pages[page_n]
5396 
5397  def GetParametersByPageName(self, page_name): # Return a list of parameters on a given page
5398  params = []
5399 
5400  for p in self.params:
5401  if p.page == page_name:
5402  params.append(p)
5403 
5404  return params
5405 
5406  def GetParametersByPageIndex(self, page_index): # Return an ordered list of parameters on a given page
5407  return self.GetParametersByPageName(self.GetParameterPageName(page_index))
5408 
5409  def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
5410  params = self.GetParametersByPageIndex(page_index)
5411  return [p.designator for p in params]
5412 
5413  def GetParameterNames(self,page_index): # Return the list of names associated with a given page
5414  params = self.GetParametersByPageIndex(page_index)
5415  return [p.name for p in params]
5416 
5417  def GetParameterValues(self,page_index): # Return the list of values associated with a given page
5418  params = self.GetParametersByPageIndex(page_index)
5419  return [str(p.raw_value) for p in params]
5420 
5421  def GetParameterErrors(self,page_index): # Return list of errors associated with a given page
5422  params = self.GetParametersByPageIndex(page_index)
5423  return [str("\n".join(p.error_list)) for p in params]
5424 
5425  def GetParameterTypes(self, page_index): # Return list of units associated with a given page
5426  params = self.GetParametersByPageIndex(page_index)
5427  return [str(p.units) for p in params]
5428 
5429  def GetParameterHints(self, page_index): # Return a list of units associated with a given page
5430  params = self.GetParametersByPageIndex(page_index)
5431  return [str(p.hint) for p in params]
5432 
5433  def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
5434  params = self.GetParametersByPageIndex(page_index)
5435  return [str(p.designator) for p in params]
5436 
5437  def SetParameterValues(self, page_index, list_of_values): # Update values on a given page
5438 
5439  params = self.GetParametersByPageIndex(page_index)
5440 
5441  for i, param in enumerate(params):
5442  if i >= len(list_of_values):
5443  break
5444  param.SetValue(list_of_values[i])
5445 
5446  def GetFootprint( self ):
5447  self.BuildFootprint()
5448  return self.module
5449 
5450  def BuildFootprint(self):
5451  return
5452 
5453  def GetBuildMessages( self ):
5454  return self.buildmessages
5455 
5456  def Show(self):
5457  text = "Footprint Wizard Name: {name}\n".format(name=self.GetName())
5458  text += "Footprint Wizard Description: {desc}\n".format(desc=self.GetDescription())
5459 
5460  n_pages = self.GetNumParameterPages()
5461 
5462  text += "Pages: {n}\n".format(n=n_pages)
5463 
5464  for i in range(n_pages):
5465  name = self.GetParameterPageName(i)
5466 
5467  params = self.GetParametersByPageName(name)
5468 
5469  text += "{name}\n".format(name=name)
5470 
5471  for j in range(len(params)):
5472  text += ("\t{param}{err}\n".format(
5473  param = str(params[j]),
5474  err = ' *' if len(params[j].error_list) > 0 else ''
5475  ))
5476 
5477  if self.AnyErrors():
5478  text += " * Errors exist for these parameters"
5479 
5480  return text
5481 
5483  def __init__( self ):
5484  KiCadPlugin.__init__( self )
5485  self.defaults()
5486 
5487  def defaults( self ):
5488  self.name = "Undefined Action plugin"
5489  self.category = "Undefined"
5490  self.description = ""
5491 
5492  def GetName( self ):
5493  return self.name
5494 
5495  def GetCategoryName( self ):
5496  return self.category
5497 
5498  def GetDescription( self ):
5499  return self.description
5500 
5501  def Run(self):
5502  return
5503 
5504 
5505 class CSegment(_object):
5506  """C++ includes: PolyLine.h """
5507  __swig_setmethods__ = {}
5508  __setattr__ = lambda self, name, value: _swig_setattr(self, CSegment, name, value)
5509  __swig_getmethods__ = {}
5510  __getattr__ = lambda self, name: _swig_getattr(self, CSegment, name)
5511  __repr__ = _swig_repr
5512  __swig_setmethods__["m_Start"] = _pcbnew.CSegment_m_Start_set
5513  __swig_getmethods__["m_Start"] = _pcbnew.CSegment_m_Start_get
5514  if _newclass:
5515  m_Start = _swig_property(_pcbnew.CSegment_m_Start_get, _pcbnew.CSegment_m_Start_set)
5516  __swig_setmethods__["m_End"] = _pcbnew.CSegment_m_End_set
5517  __swig_getmethods__["m_End"] = _pcbnew.CSegment_m_End_get
5518  if _newclass:
5519  m_End = _swig_property(_pcbnew.CSegment_m_End_get, _pcbnew.CSegment_m_End_set)
5520 
5521  def __init__(self, *args):
5522  """
5523  __init__(CSegment self) -> CSegment
5524  __init__(CSegment self, wxPoint aStart, wxPoint aEnd) -> CSegment
5525  __init__(CSegment self, int x0, int y0, int x1, int y1) -> CSegment
5526 
5527  CSegment::CSegment(int x0,
5528  int y0, int x1, int y1)
5529  """
5530  this = _pcbnew.new_CSegment(*args)
5531  try:
5532  self.this.append(this)
5533  except:
5534  self.this = this
5535  __swig_destroy__ = _pcbnew.delete_CSegment
5536  __del__ = lambda self: None
5537 CSegment_swigregister = _pcbnew.CSegment_swigregister
5538 CSegment_swigregister(CSegment)
5539 
5541  """C++ includes: PolyLine.h """
5542  __swig_setmethods__ = {}
5543  for _s in [wxPoint]:
5544  __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
5545  __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyPt, name, value)
5546  __swig_getmethods__ = {}
5547  for _s in [wxPoint]:
5548  __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
5549  __getattr__ = lambda self, name: _swig_getattr(self, CPolyPt, name)
5550  __repr__ = _swig_repr
5551 
5552  def __init__(self, *args):
5553  """
5554  __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False, int aUtility=0) -> CPolyPt
5555  __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False) -> CPolyPt
5556  __init__(CPolyPt self, int aX=0, int aY=0) -> CPolyPt
5557  __init__(CPolyPt self, int aX=0) -> CPolyPt
5558  __init__(CPolyPt self) -> CPolyPt
5559  __init__(CPolyPt self, CPolyPt aPt) -> CPolyPt
5560  __init__(CPolyPt self, wxPoint aPoint) -> CPolyPt
5561 
5562  CPolyPt::CPolyPt(const
5563  wxPoint &aPoint)
5564  """
5565  this = _pcbnew.new_CPolyPt(*args)
5566  try:
5567  self.this.append(this)
5568  except:
5569  self.this = this
5570  __swig_setmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_set
5571  __swig_getmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_get
5572  if _newclass:
5573  end_contour = _swig_property(_pcbnew.CPolyPt_end_contour_get, _pcbnew.CPolyPt_end_contour_set)
5574  __swig_setmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_set
5575  __swig_getmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_get
5576  if _newclass:
5577  m_flags = _swig_property(_pcbnew.CPolyPt_m_flags_get, _pcbnew.CPolyPt_m_flags_set)
5578 
5579  def __eq__(self, cpt2):
5580  """__eq__(CPolyPt self, CPolyPt cpt2) -> bool"""
5581  return _pcbnew.CPolyPt___eq__(self, cpt2)
5582 
5583 
5584  def __ne__(self, cpt2):
5585  """__ne__(CPolyPt self, CPolyPt cpt2) -> bool"""
5586  return _pcbnew.CPolyPt___ne__(self, cpt2)
5587 
5588  __swig_destroy__ = _pcbnew.delete_CPolyPt
5589  __del__ = lambda self: None
5590 CPolyPt_swigregister = _pcbnew.CPolyPt_swigregister
5591 CPolyPt_swigregister(CPolyPt)
5592 
5594  """C++ includes: PolyLine.h """
5595  __swig_setmethods__ = {}
5596  __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyLine, name, value)
5597  __swig_getmethods__ = {}
5598  __getattr__ = lambda self, name: _swig_getattr(self, CPolyLine, name)
5599  __repr__ = _swig_repr
5600  NO_HATCH = _pcbnew.CPolyLine_NO_HATCH
5601  DIAGONAL_FULL = _pcbnew.CPolyLine_DIAGONAL_FULL
5602  DIAGONAL_EDGE = _pcbnew.CPolyLine_DIAGONAL_EDGE
5603 
5604  def __init__(self, *args):
5605  """
5606  __init__(CPolyLine self) -> CPolyLine
5607  __init__(CPolyLine self, CPolyLine aCPolyLine) -> CPolyLine
5608 
5609  CPolyLine::CPolyLine(const CPolyLine &aCPolyLine)
5610  """
5611  this = _pcbnew.new_CPolyLine(*args)
5612  try:
5613  self.this.append(this)
5614  except:
5615  self.this = this
5616  __swig_destroy__ = _pcbnew.delete_CPolyLine
5617  __del__ = lambda self: None
5618 
5619  def ImportSettings(self, aPoly):
5620  """
5621  ImportSettings(CPolyLine self, CPolyLine aPoly)
5622 
5623  void
5624  CPolyLine::ImportSettings(const CPolyLine *aPoly)
5625 
5626  Function ImportSettings Copy settings (layer, hatch styles) from
5627  aPoly.
5628 
5629  Parameters:
5630  -----------
5631 
5632  aPoly: is the CPolyLine to import settings
5633  """
5634  return _pcbnew.CPolyLine_ImportSettings(self, aPoly)
5635 
5636 
5637  def Start(self, layer, x, y, hatch):
5638  """
5639  Start(CPolyLine self, LAYER_NUM layer, int x, int y, int hatch)
5640 
5641  void
5642  CPolyLine::Start(LAYER_NUM layer, int x, int y, int hatch)
5643  """
5644  return _pcbnew.CPolyLine_Start(self, layer, x, y, hatch)
5645 
5646 
5647  def AppendCorner(self, x, y):
5648  """
5649  AppendCorner(CPolyLine self, int x, int y)
5650 
5651  void
5652  CPolyLine::AppendCorner(int x, int y)
5653  """
5654  return _pcbnew.CPolyLine_AppendCorner(self, x, y)
5655 
5656 
5657  def InsertCorner(self, ic, x, y):
5658  """
5659  InsertCorner(CPolyLine self, int ic, int x, int y)
5660 
5661  void
5662  CPolyLine::InsertCorner(int ic, int x, int y)
5663 
5664  Function InsertCorner insert a new corner between two existing
5665  corners.
5666 
5667  Parameters:
5668  -----------
5669 
5670  ic: = index for the insertion point: the corner is inserted AFTER ic
5671 
5672  x: y: = coordinates corner to insert
5673  """
5674  return _pcbnew.CPolyLine_InsertCorner(self, ic, x, y)
5675 
5676 
5677  def DeleteCorner(self, ic):
5678  """
5679  DeleteCorner(CPolyLine self, int ic)
5680 
5681  void
5682  CPolyLine::DeleteCorner(int ic)
5683 
5684  Function DeleteCorner remove the given corner.
5685 
5686  if it is the last point of a contour keep the controur closed by
5687  modifying the previous corner
5688 
5689  Parameters:
5690  -----------
5691 
5692  ic: = the index of the corner to delete
5693  """
5694  return _pcbnew.CPolyLine_DeleteCorner(self, ic)
5695 
5696 
5697  def MoveCorner(self, ic, x, y):
5698  """
5699  MoveCorner(CPolyLine self, int ic, int x, int y)
5700 
5701  void
5702  CPolyLine::MoveCorner(int ic, int x, int y)
5703  """
5704  return _pcbnew.CPolyLine_MoveCorner(self, ic, x, y)
5705 
5706 
5707  def CloseLastContour(self):
5708  """
5709  CloseLastContour(CPolyLine self)
5710 
5711  void
5712  CPolyLine::CloseLastContour()
5713 
5714  function CloseLastContour Set the .end_contour member of the last
5715  corner of the last contour to true
5716  """
5717  return _pcbnew.CPolyLine_CloseLastContour(self)
5718 
5719 
5720  def RemoveContour(self, icont):
5721  """
5722  RemoveContour(CPolyLine self, int icont)
5723 
5724  void
5725  CPolyLine::RemoveContour(int icont)
5726 
5727  Function RemoveContour.
5728 
5729  Parameters:
5730  -----------
5731 
5732  icont: = contour number to remove remove a contour only if there is
5733  more than 1 contour
5734  """
5735  return _pcbnew.CPolyLine_RemoveContour(self, icont)
5736 
5737 
5739  """
5740  IsPolygonSelfIntersecting(CPolyLine self) -> bool
5741 
5742  bool
5743  CPolyLine::IsPolygonSelfIntersecting()
5744 
5745  Function IsPolygonSelfIntersecting Test a CPolyLine for self-
5746  intersection of vertex (all contours).
5747 
5748  : false if no intersecting sides true if intersecting sides When a
5749  CPolyLine is self intersectic, it need to be normalized. (converted to
5750  non intersecting polygons)
5751  """
5752  return _pcbnew.CPolyLine_IsPolygonSelfIntersecting(self)
5753 
5754 
5755  def Chamfer(self, aDistance):
5756  """
5757  Chamfer(CPolyLine self, unsigned int aDistance) -> CPolyLine
5758 
5759  CPolyLine *
5760  CPolyLine::Chamfer(unsigned int aDistance)
5761 
5762  Function Chamfer returns a chamfered version of a polygon.
5763 
5764  Parameters:
5765  -----------
5766 
5767  aDistance: is the chamfering distance.
5768 
5769  CPolyLine* - Pointer to new polygon.
5770  """
5771  return _pcbnew.CPolyLine_Chamfer(self, aDistance)
5772 
5773 
5774  def Fillet(self, aRadius, aSegments):
5775  """
5776  Fillet(CPolyLine self, unsigned int aRadius, unsigned int aSegments) -> CPolyLine
5777 
5778  CPolyLine *
5779  CPolyLine::Fillet(unsigned int aRadius, unsigned int aSegments)
5780 
5781  Function Fillet returns a filleted version of a polygon.
5782 
5783  Parameters:
5784  -----------
5785 
5786  aRadius: is the fillet radius.
5787 
5788  aSegments: is the number of segments / fillet.
5789 
5790  CPolyLine* - Pointer to new polygon.
5791  """
5792  return _pcbnew.CPolyLine_Fillet(self, aRadius, aSegments)
5793 
5794 
5796  """
5797  RemoveNullSegments(CPolyLine self) -> int
5798 
5799  int
5800  CPolyLine::RemoveNullSegments()
5801 
5802  Function RemoveNullSegments Removes corners which create a null
5803  segment edge (i.e.
5804 
5805  when 2 successive corners are at the same location) the count of
5806  removed corners.
5807  """
5808  return _pcbnew.CPolyLine_RemoveNullSegments(self)
5809 
5810 
5812  """
5813  RemoveAllContours(CPolyLine self)
5814 
5815  void
5816  CPolyLine::RemoveAllContours(void)
5817 
5818  function RemoveAllContours removes all corners from the list.
5819 
5820  Others params are not changed
5821  """
5822  return _pcbnew.CPolyLine_RemoveAllContours(self)
5823 
5824 
5825  def UnHatch(self):
5826  """
5827  UnHatch(CPolyLine self)
5828 
5829  void CPolyLine::UnHatch()
5830 
5831  """
5832  return _pcbnew.CPolyLine_UnHatch(self)
5833 
5834 
5835  def Hatch(self):
5836  """
5837  Hatch(CPolyLine self)
5838 
5839  void CPolyLine::Hatch()
5840  """
5841  return _pcbnew.CPolyLine_Hatch(self)
5842 
5843 
5844  def MoveOrigin(self, x_off, y_off):
5845  """
5846  MoveOrigin(CPolyLine self, int x_off, int y_off)
5847 
5848  void
5849  CPolyLine::MoveOrigin(int x_off, int y_off)
5850  """
5851  return _pcbnew.CPolyLine_MoveOrigin(self, x_off, y_off)
5852 
5853 
5854  def GetBoundingBox(self, *args):
5855  """
5856  GetBoundingBox(CPolyLine self) -> EDA_RECT
5857  GetBoundingBox(CPolyLine self, int icont) -> EDA_RECT
5858 
5859  const EDA_RECT
5860  CPolyLine::GetBoundingBox(int icont)
5861 
5862  the bounding box of a given polygon
5863 
5864  Parameters:
5865  -----------
5866 
5867  icont: = the index of the polygon contour (0 = main contour, 1 ... n
5868  = other contours, usually holes)
5869  """
5870  return _pcbnew.CPolyLine_GetBoundingBox(self, *args)
5871 
5872 
5873  def Copy(self, src):
5874  """
5875  Copy(CPolyLine self, CPolyLine src)
5876 
5877  void CPolyLine::Copy(const
5878  CPolyLine *src)
5879  """
5880  return _pcbnew.CPolyLine_Copy(self, src)
5881 
5882 
5883  def TestPointInside(self, x, y):
5884  """
5885  TestPointInside(CPolyLine self, int x, int y) -> bool
5886 
5887  bool
5888  CPolyLine::TestPointInside(int x, int y)
5889  """
5890  return _pcbnew.CPolyLine_TestPointInside(self, x, y)
5891 
5892 
5893  def IsCutoutContour(self, aCornerIdx):
5894  """
5895  IsCutoutContour(CPolyLine self, int aCornerIdx) -> bool
5896 
5897  bool
5898  CPolyLine::IsCutoutContour(int aCornerIdx)
5899 
5900  true if the corner aCornerIdx is on a hole inside the main outline and
5901  false if it is on the main outline
5902  """
5903  return _pcbnew.CPolyLine_IsCutoutContour(self, aCornerIdx)
5904 
5905 
5906  def AppendArc(self, xi, yi, xf, yf, xc, yc, num):
5907  """
5908  AppendArc(CPolyLine self, int xi, int yi, int xf, int yf, int xc, int yc, int num)
5909 
5910  void
5911  CPolyLine::AppendArc(int xi, int yi, int xf, int yf, int xc, int yc,
5912  int num)
5913 
5914  Function AppendArc.
5915 
5916  Adds segments to current contour to approximate the given arc
5917  """
5918  return _pcbnew.CPolyLine_AppendArc(self, xi, yi, xf, yf, xc, yc, num)
5919 
5920 
5921  def SetLayer(self, aLayer):
5922  """
5923  SetLayer(CPolyLine self, LAYER_NUM aLayer)
5924 
5925  void
5926  CPolyLine::SetLayer(LAYER_NUM aLayer)
5927  """
5928  return _pcbnew.CPolyLine_SetLayer(self, aLayer)
5929 
5930 
5931  def GetLayer(self):
5932  """
5933  GetLayer(CPolyLine self) -> LAYER_NUM
5934 
5935  LAYER_NUM
5936  CPolyLine::GetLayer() const
5937  """
5938  return _pcbnew.CPolyLine_GetLayer(self)
5939 
5940 
5941  def GetCornersCount(self):
5942  """
5943  GetCornersCount(CPolyLine self) -> int
5944 
5945  int
5946  CPolyLine::GetCornersCount() const
5947  """
5948  return _pcbnew.CPolyLine_GetCornersCount(self)
5949 
5950 
5951  def GetClosed(self):
5952  """
5953  GetClosed(CPolyLine self) -> bool
5954 
5955  bool
5956  CPolyLine::GetClosed()
5957 
5958  true if the last corner in corners list is flagged end_contour
5959  """
5960  return _pcbnew.CPolyLine_GetClosed(self)
5961 
5962 
5963  def GetContoursCount(self):
5964  """
5965  GetContoursCount(CPolyLine self) -> int
5966 
5967  int
5968  CPolyLine::GetContoursCount() const
5969 
5970  Function GetContoursCount.
5971 
5972  the number of polygons stored in list (number of corners flagged
5973  "end_contour"
5974  """
5975  return _pcbnew.CPolyLine_GetContoursCount(self)
5976 
5977 
5978  def GetContour(self, ic):
5979  """
5980  GetContour(CPolyLine self, int ic) -> int
5981 
5982  int
5983  CPolyLine::GetContour(int ic)
5984 
5985  Function GetContour.
5986 
5987  the contour number containing the corner ic
5988 
5989  Parameters:
5990  -----------
5991 
5992  ic: = the index of the corner in the corner list
5993  """
5994  return _pcbnew.CPolyLine_GetContour(self, ic)
5995 
5996 
5997  def GetContourStart(self, icont):
5998  """
5999  GetContourStart(CPolyLine self, int icont) -> int
6000 
6001  int
6002  CPolyLine::GetContourStart(int icont)
6003 
6004  Function GetContourStart.
6005 
6006  the index of the first corner (in corners list) of a contour
6007 
6008  Parameters:
6009  -----------
6010 
6011  icont: = the index of the contour
6012  """
6013  return _pcbnew.CPolyLine_GetContourStart(self, icont)
6014 
6015 
6016  def GetContourEnd(self, icont):
6017  """
6018  GetContourEnd(CPolyLine self, int icont) -> int
6019 
6020  int
6021  CPolyLine::GetContourEnd(int icont)
6022 
6023  Function GetContourEnd.
6024 
6025  the index of the last corner (in corners list) of a contour
6026 
6027  Parameters:
6028  -----------
6029 
6030  icont: = the index of the contour
6031  """
6032  return _pcbnew.CPolyLine_GetContourEnd(self, icont)
6033 
6034 
6035  def GetContourSize(self, icont):
6036  """
6037  GetContourSize(CPolyLine self, int icont) -> int
6038 
6039  int
6040  CPolyLine::GetContourSize(int icont)
6041 
6042  Function GetContourSize.
6043 
6044  the corners count of a contour
6045 
6046  Parameters:
6047  -----------
6048 
6049  icont: = the index of the contour
6050  """
6051  return _pcbnew.CPolyLine_GetContourSize(self, icont)
6052 
6053 
6054  def GetX(self, ic):
6055  """
6056  GetX(CPolyLine self, int ic) -> int
6057 
6058  int CPolyLine::GetX(int ic)
6059  const
6060  """
6061  return _pcbnew.CPolyLine_GetX(self, ic)
6062 
6063 
6064  def GetY(self, ic):
6065  """
6066  GetY(CPolyLine self, int ic) -> int
6067 
6068  int CPolyLine::GetY(int ic)
6069  const
6070  """
6071  return _pcbnew.CPolyLine_GetY(self, ic)
6072 
6073 
6074  def IsEndContour(self, ic):
6075  """
6076  IsEndContour(CPolyLine self, int ic) -> bool
6077 
6078  bool
6079  CPolyLine::IsEndContour(int ic) const
6080 
6081  Function IsEndContour.
6082 
6083  true if a corner is flagged end_contour
6084 
6085  Parameters:
6086  -----------
6087 
6088  ic=: the index (in corners list) of the corner
6089  """
6090  return _pcbnew.CPolyLine_IsEndContour(self, ic)
6091 
6092 
6093  def GetPos(self, ic):
6094  """
6095  GetPos(CPolyLine self, int ic) -> wxPoint
6096 
6097  const wxPoint&
6098  CPolyLine::GetPos(int ic) const
6099  """
6100  return _pcbnew.CPolyLine_GetPos(self, ic)
6101 
6102 
6103  def GetHatchPitch(self):
6104  """
6105  GetHatchPitch(CPolyLine self) -> int
6106 
6107  int
6108  CPolyLine::GetHatchPitch() const
6109  """
6110  return _pcbnew.CPolyLine_GetHatchPitch(self)
6111 
6112 
6114  """GetDefaultHatchPitchMils() -> int"""
6115  return _pcbnew.CPolyLine_GetDefaultHatchPitchMils()
6116 
6117  if _newclass:
6118  GetDefaultHatchPitchMils = staticmethod(GetDefaultHatchPitchMils)
6119  __swig_getmethods__["GetDefaultHatchPitchMils"] = lambda x: GetDefaultHatchPitchMils
6120 
6121  def GetHatchStyle(self):
6122  """
6123  GetHatchStyle(CPolyLine self) -> enum CPolyLine::HATCH_STYLE
6124 
6125  enum HATCH_STYLE
6126  CPolyLine::GetHatchStyle() const
6127  """
6128  return _pcbnew.CPolyLine_GetHatchStyle(self)
6129 
6130 
6131  def SetHatch(self, aHatchStyle, aHatchPitch, aRebuildHatch):
6132  """
6133  SetHatch(CPolyLine self, int aHatchStyle, int aHatchPitch, bool aRebuildHatch)
6134 
6135  void
6136  CPolyLine::SetHatch(int aHatchStyle, int aHatchPitch, bool
6137  aRebuildHatch)
6138  """
6139  return _pcbnew.CPolyLine_SetHatch(self, aHatchStyle, aHatchPitch, aRebuildHatch)
6140 
6141 
6142  def SetX(self, ic, x):
6143  """
6144  SetX(CPolyLine self, int ic, int x)
6145 
6146  void CPolyLine::SetX(int ic,
6147  int x)
6148  """
6149  return _pcbnew.CPolyLine_SetX(self, ic, x)
6150 
6151 
6152  def SetY(self, ic, y):
6153  """
6154  SetY(CPolyLine self, int ic, int y)
6155 
6156  void CPolyLine::SetY(int ic,
6157  int y)
6158  """
6159  return _pcbnew.CPolyLine_SetY(self, ic, y)
6160 
6161 
6162  def SetHatchStyle(self, style):
6163  """
6164  SetHatchStyle(CPolyLine self, enum CPolyLine::HATCH_STYLE style)
6165 
6166  void
6167  CPolyLine::SetHatchStyle(enum HATCH_STYLE style)
6168  """
6169  return _pcbnew.CPolyLine_SetHatchStyle(self, style)
6170 
6171 
6172  def SetHatchPitch(self, pitch):
6173  """
6174  SetHatchPitch(CPolyLine self, int pitch)
6175 
6176  void
6177  CPolyLine::SetHatchPitch(int pitch)
6178  """
6179  return _pcbnew.CPolyLine_SetHatchPitch(self, pitch)
6180 
6181 
6182  def NormalizeAreaOutlines(self, aNewPolygonList):
6183  """
6184  NormalizeAreaOutlines(CPolyLine self, std::vector< CPolyLine *,std::allocator< CPolyLine * > > * aNewPolygonList) -> int
6185 
6186  int
6187  CPolyLine::Normaliz