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  Function ViewBBox() returns the bounding box of the item covering all
2115  its layers.
2116 
2117  BOX2I - the current bounding box
2118  """
2119  return _pcbnew.EDA_ITEM_ViewBBox(self)
2120 
2121 
2122  def ViewGetLayers(self, aLayers, aCount):
2123  """
2124  ViewGetLayers(EDA_ITEM self, int [] aLayers, int & aCount)
2125 
2126  void
2127  EDA_ITEM::ViewGetLayers(int aLayers[], int &aCount) const override
2128 
2129  Function ViewGetLayers() Returns the all the layers within the VIEW
2130  the object is painted on.
2131 
2132  For instance, a D_PAD spans zero or more copper layers and a few
2133  technical layers. ViewDraw() or PAINTER::Draw() is repeatedly called
2134  for each of the layers returned by ViewGetLayers(), depending on the
2135  rendering order.
2136 
2137  Parameters:
2138  -----------
2139 
2140  aLayers[]: output layer index array
2141 
2142  aCount: number of layer indices in aLayers[]
2143  """
2144  return _pcbnew.EDA_ITEM_ViewGetLayers(self, aLayers, aCount)
2145 
2146 EDA_ITEM_swigregister = _pcbnew.EDA_ITEM_swigregister
2147 EDA_ITEM_swigregister(EDA_ITEM)
2148 traceFindReplace = cvar.traceFindReplace
2149 
2150 def EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes):
2151  """EDA_ITEM_IterateForward(EDA_ITEM listStart, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
2152  return _pcbnew.EDA_ITEM_IterateForward(listStart, inspector, testData, scanTypes)
2153 
2154 def EDA_ITEM_Sort(aLeft, aRight):
2155  """EDA_ITEM_Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
2156  return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)
2157 
2158 
2159 def new_clone(aItem):
2160  """new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
2161  return _pcbnew.new_clone(aItem)
2163  """
2164 
2165 
2166  Class EDA_RECT handles the component boundary box.
2167 
2168  This class is similar to wxRect, but some wxRect functions are very
2169  curious, and are working only if dimensions are >= 0 (not always the
2170  case in KiCad) and also KiCad needs some specific method. so I prefer
2171  this more suitable class
2172 
2173  C++ includes: class_eda_rect.h
2174  """
2175  __swig_setmethods__ = {}
2176  __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_RECT, name, value)
2177  __swig_getmethods__ = {}
2178  __getattr__ = lambda self, name: _swig_getattr(self, EDA_RECT, name)
2179  __repr__ = _swig_repr
2180 
2181  def __init__(self, *args):
2182  """
2183  __init__(EDA_RECT self) -> EDA_RECT
2184  __init__(EDA_RECT self, wxPoint aPos, wxSize aSize) -> EDA_RECT
2185 
2186  EDA_RECT::EDA_RECT(const
2187  wxPoint &aPos, const wxSize &aSize)
2188  """
2189  this = _pcbnew.new_EDA_RECT(*args)
2190  try:
2191  self.this.append(this)
2192  except:
2193  self.this = this
2194 
2195  def Centre(self):
2196  """
2197  Centre(EDA_RECT self) -> wxPoint
2198 
2199  wxPoint EDA_RECT::Centre()
2200  const
2201  """
2202  return _pcbnew.EDA_RECT_Centre(self)
2203 
2204 
2205  def Move(self, aMoveVector):
2206  """
2207  Move(EDA_RECT self, wxPoint aMoveVector)
2208 
2209  void EDA_RECT::Move(const
2210  wxPoint &aMoveVector)
2211 
2212  Function Move moves the rectangle by the aMoveVector.
2213 
2214  Parameters:
2215  -----------
2216 
2217  aMoveVector: A wxPoint that is the value to move this rectangle
2218  """
2219  return _pcbnew.EDA_RECT_Move(self, aMoveVector)
2220 
2221 
2222  def Normalize(self):
2223  """
2224  Normalize(EDA_RECT self)
2225 
2226  void
2227  EDA_RECT::Normalize()
2228 
2229  Function Normalize ensures that the height ant width are positive.
2230  """
2231  return _pcbnew.EDA_RECT_Normalize(self)
2232 
2233 
2234  def Contains(self, *args):
2235  """
2236  Contains(EDA_RECT self, wxPoint aPoint) -> bool
2237  Contains(EDA_RECT self, int x, int y) -> bool
2238  Contains(EDA_RECT self, EDA_RECT aRect) -> bool
2239 
2240  bool
2241  EDA_RECT::Contains(const EDA_RECT &aRect) const
2242 
2243  Function Contains.
2244 
2245  Parameters:
2246  -----------
2247 
2248  aRect: = the EDA_RECT to test
2249 
2250  true if aRect is Contained. A common edge is seen as contained
2251  """
2252  return _pcbnew.EDA_RECT_Contains(self, *args)
2253 
2254 
2255  def GetSize(self):
2256  """
2257  GetSize(EDA_RECT self) -> wxSize
2258 
2259  const wxSize&
2260  EDA_RECT::GetSize() const
2261  """
2262  return _pcbnew.EDA_RECT_GetSize(self)
2263 
2264 
2265  def GetSizeMax(self):
2266  """
2267  GetSizeMax(EDA_RECT self) -> int
2268 
2269  int
2270  EDA_RECT::GetSizeMax() const
2271 
2272  GetSizeMax.
2273 
2274  the max size dimension
2275  """
2276  return _pcbnew.EDA_RECT_GetSizeMax(self)
2277 
2278 
2279  def GetX(self):
2280  """
2281  GetX(EDA_RECT self) -> int
2282 
2283  int EDA_RECT::GetX() const
2284  """
2285  return _pcbnew.EDA_RECT_GetX(self)
2286 
2287 
2288  def GetY(self):
2289  """
2290  GetY(EDA_RECT self) -> int
2291 
2292  int EDA_RECT::GetY() const
2293  """
2294  return _pcbnew.EDA_RECT_GetY(self)
2295 
2296 
2297  def GetOrigin(self):
2298  """
2299  GetOrigin(EDA_RECT self) -> wxPoint
2300 
2301  const wxPoint&
2302  EDA_RECT::GetOrigin() const
2303  """
2304  return _pcbnew.EDA_RECT_GetOrigin(self)
2305 
2306 
2307  def GetPosition(self):
2308  """
2309  GetPosition(EDA_RECT self) -> wxPoint
2310 
2311  const wxPoint&
2312  EDA_RECT::GetPosition() const
2313  """
2314  return _pcbnew.EDA_RECT_GetPosition(self)
2315 
2316 
2317  def GetEnd(self):
2318  """
2319  GetEnd(EDA_RECT self) -> wxPoint
2320 
2321  const wxPoint
2322  EDA_RECT::GetEnd() const
2323  """
2324  return _pcbnew.EDA_RECT_GetEnd(self)
2325 
2326 
2327  def GetCenter(self):
2328  """
2329  GetCenter(EDA_RECT self) -> wxPoint
2330 
2331  const wxPoint
2332  EDA_RECT::GetCenter() const
2333  """
2334  return _pcbnew.EDA_RECT_GetCenter(self)
2335 
2336 
2337  def GetWidth(self):
2338  """
2339  GetWidth(EDA_RECT self) -> int
2340 
2341  int EDA_RECT::GetWidth()
2342  const
2343  """
2344  return _pcbnew.EDA_RECT_GetWidth(self)
2345 
2346 
2347  def GetHeight(self):
2348  """
2349  GetHeight(EDA_RECT self) -> int
2350 
2351  int EDA_RECT::GetHeight()
2352  const
2353  """
2354  return _pcbnew.EDA_RECT_GetHeight(self)
2355 
2356 
2357  def GetRight(self):
2358  """
2359  GetRight(EDA_RECT self) -> int
2360 
2361  int EDA_RECT::GetRight()
2362  const
2363  """
2364  return _pcbnew.EDA_RECT_GetRight(self)
2365 
2366 
2367  def GetLeft(self):
2368  """
2369  GetLeft(EDA_RECT self) -> int
2370 
2371  int EDA_RECT::GetLeft()
2372  const
2373  """
2374  return _pcbnew.EDA_RECT_GetLeft(self)
2375 
2376 
2377  def GetTop(self):
2378  """
2379  GetTop(EDA_RECT self) -> int
2380 
2381  int EDA_RECT::GetTop() const
2382 
2383  """
2384  return _pcbnew.EDA_RECT_GetTop(self)
2385 
2386 
2387  def GetBottom(self):
2388  """
2389  GetBottom(EDA_RECT self) -> int
2390 
2391  int EDA_RECT::GetBottom()
2392  const
2393  """
2394  return _pcbnew.EDA_RECT_GetBottom(self)
2395 
2396 
2397  def SetOrigin(self, *args):
2398  """
2399  SetOrigin(EDA_RECT self, wxPoint pos)
2400  SetOrigin(EDA_RECT self, int x, int y)
2401 
2402  void
2403  EDA_RECT::SetOrigin(int x, int y)
2404  """
2405  return _pcbnew.EDA_RECT_SetOrigin(self, *args)
2406 
2407 
2408  def SetSize(self, *args):
2409  """
2410  SetSize(EDA_RECT self, wxSize size)
2411  SetSize(EDA_RECT self, int w, int h)
2412 
2413  void EDA_RECT::SetSize(int
2414  w, int h)
2415  """
2416  return _pcbnew.EDA_RECT_SetSize(self, *args)
2417 
2418 
2419  def Offset(self, *args):
2420  """
2421  Offset(EDA_RECT self, int dx, int dy)
2422  Offset(EDA_RECT self, wxPoint offset)
2423 
2424  void EDA_RECT::Offset(const
2425  wxPoint &offset)
2426  """
2427  return _pcbnew.EDA_RECT_Offset(self, *args)
2428 
2429 
2430  def SetX(self, val):
2431  """
2432  SetX(EDA_RECT self, int val)
2433 
2434  void EDA_RECT::SetX(int val)
2435 
2436  """
2437  return _pcbnew.EDA_RECT_SetX(self, val)
2438 
2439 
2440  def SetY(self, val):
2441  """
2442  SetY(EDA_RECT self, int val)
2443 
2444  void EDA_RECT::SetY(int val)
2445 
2446  """
2447  return _pcbnew.EDA_RECT_SetY(self, val)
2448 
2449 
2450  def SetWidth(self, val):
2451  """
2452  SetWidth(EDA_RECT self, int val)
2453 
2454  void
2455  EDA_RECT::SetWidth(int val)
2456  """
2457  return _pcbnew.EDA_RECT_SetWidth(self, val)
2458 
2459 
2460  def SetHeight(self, val):
2461  """
2462  SetHeight(EDA_RECT self, int val)
2463 
2464  void
2465  EDA_RECT::SetHeight(int val)
2466  """
2467  return _pcbnew.EDA_RECT_SetHeight(self, val)
2468 
2469 
2470  def SetEnd(self, *args):
2471  """
2472  SetEnd(EDA_RECT self, int x, int y)
2473  SetEnd(EDA_RECT self, wxPoint pos)
2474 
2475  void EDA_RECT::SetEnd(const
2476  wxPoint &pos)
2477  """
2478  return _pcbnew.EDA_RECT_SetEnd(self, *args)
2479 
2480 
2481  def RevertYAxis(self):
2482  """
2483  RevertYAxis(EDA_RECT self)
2484 
2485  void
2486  EDA_RECT::RevertYAxis()
2487 
2488  Function RevertYAxis Mirror the rectangle from the X axis (negate Y
2489  pos and size)
2490  """
2491  return _pcbnew.EDA_RECT_RevertYAxis(self)
2492 
2493 
2494  def Intersects(self, *args):
2495  """
2496  Intersects(EDA_RECT self, EDA_RECT aRect) -> bool
2497  Intersects(EDA_RECT self, EDA_RECT aRect, double aRot) -> bool
2498  Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2) -> bool
2499 
2500  bool
2501  EDA_RECT::Intersects(const wxPoint &aPoint1, const wxPoint &aPoint2)
2502  const
2503 
2504  Function Intersects tests for a common area between a segment and this
2505  rectangle.
2506 
2507  Parameters:
2508  -----------
2509 
2510  aPoint1: First point of the segment to test intersection with.
2511 
2512  aPoint2: Second point of the segment to test intersection with.
2513 
2514  bool - true if the argument segment intersects this rectangle. (i.e.
2515  if the segment and rectangle have at least a common point)
2516  """
2517  return _pcbnew.EDA_RECT_Intersects(self, *args)
2518 
2519 
2520  def ClosestPointTo(self, aPoint):
2521  """
2522  ClosestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint
2523 
2524  const wxPoint
2525  EDA_RECT::ClosestPointTo(const wxPoint &aPoint) const
2526 
2527  Return the point in this rect that is closest to the provided point.
2528 
2529  """
2530  return _pcbnew.EDA_RECT_ClosestPointTo(self, aPoint)
2531 
2532 
2533  def FarthestPointTo(self, aPoint):
2534  """
2535  FarthestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint
2536 
2537  const wxPoint
2538  EDA_RECT::FarthestPointTo(const wxPoint &aPoint) const
2539 
2540  Return the point in this rect that is farthest from the provided
2541  point.
2542  """
2543  return _pcbnew.EDA_RECT_FarthestPointTo(self, aPoint)
2544 
2545 
2546  def IntersectsCircle(self, aCenter, aRadius):
2547  """
2548  IntersectsCircle(EDA_RECT self, wxPoint aCenter, int const aRadius) -> bool
2549 
2550  bool
2551  EDA_RECT::IntersectsCircle(const wxPoint &aCenter, const int aRadius)
2552  const
2553 
2554  Function IntersectsCircle tests for a common area between a circle and
2555  this rectangle.
2556 
2557  Parameters:
2558  -----------
2559 
2560  aCenter: center of the circle
2561 
2562  aRadius: radius of the circle
2563  """
2564  return _pcbnew.EDA_RECT_IntersectsCircle(self, aCenter, aRadius)
2565 
2566 
2567  def IntersectsCircleEdge(self, aCenter, aRadius, aWidth):
2568  """
2569  IntersectsCircleEdge(EDA_RECT self, wxPoint aCenter, int const aRadius, int const aWidth) -> bool
2570 
2571  bool
2572  EDA_RECT::IntersectsCircleEdge(const wxPoint &aCenter, const int
2573  aRadius, const int aWidth) const
2574 
2575  IntersectsCircleEdge Tests for intersection between this rect and the
2576  edge (radius) of a circle.
2577 
2578  Parameters:
2579  -----------
2580 
2581  aCenter: center of the circle
2582 
2583  aRadius: radius of the circle
2584 
2585  aWidth: width of the circle edge
2586  """
2587  return _pcbnew.EDA_RECT_IntersectsCircleEdge(self, aCenter, aRadius, aWidth)
2588 
2589 
2590  def getWxRect(self):
2591  """getWxRect(EDA_RECT self) -> wxRect"""
2592  return _pcbnew.EDA_RECT_getWxRect(self)
2593 
2594 
2595  def getBOX2I(self):
2596  """getBOX2I(EDA_RECT self) -> BOX2I"""
2597  return _pcbnew.EDA_RECT_getBOX2I(self)
2598 
2599 
2600  def Inflate(self, *args):
2601  """
2602  Inflate(EDA_RECT self, wxCoord dx, wxCoord dy) -> EDA_RECT
2603  Inflate(EDA_RECT self, int aDelta) -> EDA_RECT
2604 
2605  EDA_RECT &
2606  EDA_RECT::Inflate(int aDelta)
2607 
2608  Function Inflate inflates the rectangle horizontally and vertically by
2609  aDelta.
2610 
2611  If aDelta is negative the rectangle is deflated.
2612  """
2613  return _pcbnew.EDA_RECT_Inflate(self, *args)
2614 
2615 
2616  def Merge(self, *args):
2617  """
2618  Merge(EDA_RECT self, EDA_RECT aRect)
2619  Merge(EDA_RECT self, wxPoint aPoint)
2620 
2621  void EDA_RECT::Merge(const
2622  wxPoint &aPoint)
2623 
2624  Function Merge modifies the position and size of the rectangle in
2625  order to contain the given point.
2626 
2627  Parameters:
2628  -----------
2629 
2630  aPoint: The point to merge with the rectangle.
2631  """
2632  return _pcbnew.EDA_RECT_Merge(self, *args)
2633 
2634 
2635  def GetArea(self):
2636  """
2637  GetArea(EDA_RECT self) -> double
2638 
2639  double EDA_RECT::GetArea()
2640  const
2641 
2642  Function GetArea returns the area of the rectangle.
2643 
2644  The area of the rectangle.
2645  """
2646  return _pcbnew.EDA_RECT_GetArea(self)
2647 
2648 
2649  def Common(self, aRect):
2650  """
2651  Common(EDA_RECT self, EDA_RECT aRect) -> EDA_RECT
2652 
2653  EDA_RECT
2654  EDA_RECT::Common(const EDA_RECT &aRect) const
2655 
2656  Function Common returns the area that is common with another
2657  rectangle.
2658 
2659  Parameters:
2660  -----------
2661 
2662  aRect: is the rectangle to find the common area with.
2663 
2664  The common area rect or 0-sized rectangle if there is no intersection.
2665 
2666  """
2667  return _pcbnew.EDA_RECT_Common(self, aRect)
2668 
2669 
2670  def GetBoundingBoxRotated(self, aRotCenter, aAngle):
2671  """
2672  GetBoundingBoxRotated(EDA_RECT self, wxPoint aRotCenter, double aAngle) -> EDA_RECT
2673 
2674  const
2675  EDA_RECT EDA_RECT::GetBoundingBoxRotated(wxPoint aRotCenter, double
2676  aAngle)
2677 
2678  Function GetBoundingBoxRotated.
2679 
2680  the bounding box of this, after rotation
2681 
2682  Parameters:
2683  -----------
2684 
2685  aAngle: = the rotation angle in 0.1 deg.
2686 
2687  aRotCenter: = the rotation point. useful to calculate bounding box of
2688  rotated items, when rotation if not k*90 degrees
2689  """
2690  return _pcbnew.EDA_RECT_GetBoundingBoxRotated(self, aRotCenter, aAngle)
2691 
2692  __swig_destroy__ = _pcbnew.delete_EDA_RECT
2693  __del__ = lambda self: None
2694 EDA_RECT_swigregister = _pcbnew.EDA_RECT_swigregister
2695 EDA_RECT_swigregister(EDA_RECT)
2696 
2697 
2698 _pcbnew.EDA_PANNING_UP_KEY_swigconstant(_pcbnew)
2699 EDA_PANNING_UP_KEY = _pcbnew.EDA_PANNING_UP_KEY
2700 
2701 _pcbnew.EDA_PANNING_DOWN_KEY_swigconstant(_pcbnew)
2702 EDA_PANNING_DOWN_KEY = _pcbnew.EDA_PANNING_DOWN_KEY
2703 
2704 _pcbnew.EDA_PANNING_LEFT_KEY_swigconstant(_pcbnew)
2705 EDA_PANNING_LEFT_KEY = _pcbnew.EDA_PANNING_LEFT_KEY
2706 
2707 _pcbnew.EDA_PANNING_RIGHT_KEY_swigconstant(_pcbnew)
2708 EDA_PANNING_RIGHT_KEY = _pcbnew.EDA_PANNING_RIGHT_KEY
2709 
2710 _pcbnew.EDA_ZOOM_IN_FROM_MOUSE_swigconstant(_pcbnew)
2711 EDA_ZOOM_IN_FROM_MOUSE = _pcbnew.EDA_ZOOM_IN_FROM_MOUSE
2712 
2713 _pcbnew.EDA_ZOOM_OUT_FROM_MOUSE_swigconstant(_pcbnew)
2714 EDA_ZOOM_OUT_FROM_MOUSE = _pcbnew.EDA_ZOOM_OUT_FROM_MOUSE
2715 
2716 _pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE_swigconstant(_pcbnew)
2717 EDA_ZOOM_CENTER_FROM_MOUSE = _pcbnew.EDA_ZOOM_CENTER_FROM_MOUSE
2718 
2719 _pcbnew.ESC_swigconstant(_pcbnew)
2720 ESC = _pcbnew.ESC
2721 
2722 _pcbnew.TEXT_ANGLE_HORIZ_swigconstant(_pcbnew)
2723 TEXT_ANGLE_HORIZ = _pcbnew.TEXT_ANGLE_HORIZ
2724 
2725 _pcbnew.TEXT_ANGLE_VERT_swigconstant(_pcbnew)
2726 TEXT_ANGLE_VERT = _pcbnew.TEXT_ANGLE_VERT
2727 
2728 def KiROUND(v):
2729  """KiROUND(double v) -> int"""
2730  return _pcbnew.KiROUND(v)
2731 
2732 _pcbnew.INCHES_swigconstant(_pcbnew)
2733 INCHES = _pcbnew.INCHES
2734 
2735 _pcbnew.MILLIMETRES_swigconstant(_pcbnew)
2736 MILLIMETRES = _pcbnew.MILLIMETRES
2737 
2738 _pcbnew.UNSCALED_UNITS_swigconstant(_pcbnew)
2739 UNSCALED_UNITS = _pcbnew.UNSCALED_UNITS
2740 
2741 _pcbnew.DEGREES_swigconstant(_pcbnew)
2742 DEGREES = _pcbnew.DEGREES
2744  """
2745 
2746 
2747  Class LOCALE_IO is a class that can be instantiated within a scope in
2748  which you are expecting exceptions to be thrown.
2749 
2750  Its constructor set a "C" laguage locale option, to read/print files
2751  with fp numbers. Its destructor insures that the default locale is
2752  restored if an exception is thrown, or not.
2753 
2754  C++ includes: common.h
2755  """
2756  __swig_setmethods__ = {}
2757  __setattr__ = lambda self, name, value: _swig_setattr(self, LOCALE_IO, name, value)
2758  __swig_getmethods__ = {}
2759  __getattr__ = lambda self, name: _swig_getattr(self, LOCALE_IO, name)
2760  __repr__ = _swig_repr
2761 
2762  def __init__(self):
2763  """
2764  __init__(LOCALE_IO self) -> LOCALE_IO
2765 
2766  LOCALE_IO::LOCALE_IO()
2767 
2768  """
2769  this = _pcbnew.new_LOCALE_IO()
2770  try:
2771  self.this.append(this)
2772  except:
2773  self.this = this
2774  __swig_destroy__ = _pcbnew.delete_LOCALE_IO
2775  __del__ = lambda self: None
2776 LOCALE_IO_swigregister = _pcbnew.LOCALE_IO_swigregister
2777 LOCALE_IO_swigregister(LOCALE_IO)
2778 
2779 
2780 def GetTextSize(aSingleLine, aWindow):
2781  """GetTextSize(wxString aSingleLine, wxWindow * aWindow) -> wxSize"""
2782  return _pcbnew.GetTextSize(aSingleLine, aWindow)
2783 
2784 def EnsureTextCtrlWidth(aCtrl, aString=None):
2785  """
2786  EnsureTextCtrlWidth(wxTextCtrl * aCtrl, wxString aString=None) -> bool
2787  EnsureTextCtrlWidth(wxTextCtrl * aCtrl) -> bool
2788  """
2789  return _pcbnew.EnsureTextCtrlWidth(aCtrl, aString)
2790 
2791 def ProcessExecute(*args):
2792  """
2793  ProcessExecute(wxString aCommandLine, int aFlags, wxProcess * callback=None) -> int
2794  ProcessExecute(wxString aCommandLine, int aFlags) -> int
2795  ProcessExecute(wxString aCommandLine) -> int
2796  """
2797  return _pcbnew.ProcessExecute(*args)
2798 
2800  """GetNewTimeStamp() -> time_t"""
2801  return _pcbnew.GetNewTimeStamp()
2802 
2803 def RoundTo0(x, precision):
2804  """RoundTo0(double x, double precision) -> double"""
2805  return _pcbnew.RoundTo0(x, precision)
2806 
2807 def wxStringSplit(aText, aStrings, aSplitter):
2808  """wxStringSplit(wxString aText, wxArrayString & aStrings, wxChar aSplitter)"""
2809  return _pcbnew.wxStringSplit(aText, aStrings, aSplitter)
2810 
2811 def SearchHelpFileFullPath(aSearchStack, aBaseName):
2812  """SearchHelpFileFullPath(SEARCH_STACK const & aSearchStack, wxString aBaseName) -> wxString"""
2813  return _pcbnew.SearchHelpFileFullPath(aSearchStack, aBaseName)
2814 
2815 def EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter=None):
2816  """
2817  EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename, REPORTER * aReporter=None) -> bool
2818  EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename) -> bool
2819  """
2820  return _pcbnew.EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter)
2821 
2822 def PrePendPath(aEnvVar, aPriorityPath):
2823  """PrePendPath(wxString aEnvVar, wxString aPriorityPath) -> wxString"""
2824  return _pcbnew.PrePendPath(aEnvVar, aPriorityPath)
2825 
2826 def GetNewConfig(aProgName):
2827  """GetNewConfig(wxString aProgName) -> wxConfigBase *"""
2828  return _pcbnew.GetNewConfig(aProgName)
2829 
2831  """GetKicadConfigPath() -> wxString"""
2832  return _pcbnew.GetKicadConfigPath()
2833 
2835  """ExpandEnvVarSubstitutions(wxString aString) -> wxString"""
2836  return _pcbnew.ExpandEnvVarSubstitutions(aString)
2838  """
2839 
2840 
2841  Class TITLE_BLOCK holds the information shown in the lower right
2842  corner of a plot, printout, or editing view.
2843 
2844  Dick Hollenbeck
2845 
2846  C++ includes: class_title_block.h
2847  """
2848  __swig_setmethods__ = {}
2849  __setattr__ = lambda self, name, value: _swig_setattr(self, TITLE_BLOCK, name, value)
2850  __swig_getmethods__ = {}
2851  __getattr__ = lambda self, name: _swig_getattr(self, TITLE_BLOCK, name)
2852  __repr__ = _swig_repr
2853 
2854  def __init__(self):
2855  """
2856  __init__(TITLE_BLOCK self) -> TITLE_BLOCK
2857 
2858  TITLE_BLOCK::TITLE_BLOCK()
2859  """
2860  this = _pcbnew.new_TITLE_BLOCK()
2861  try:
2862  self.this.append(this)
2863  except:
2864  self.this = this
2865  __swig_destroy__ = _pcbnew.delete_TITLE_BLOCK
2866  __del__ = lambda self: None
2867 
2868  def SetTitle(self, aTitle):
2869  """
2870  SetTitle(TITLE_BLOCK self, wxString aTitle)
2871 
2872  void
2873  TITLE_BLOCK::SetTitle(const wxString &aTitle)
2874  """
2875  return _pcbnew.TITLE_BLOCK_SetTitle(self, aTitle)
2876 
2877 
2878  def GetTitle(self):
2879  """
2880  GetTitle(TITLE_BLOCK self) -> wxString
2881 
2882  const wxString&
2883  TITLE_BLOCK::GetTitle() const
2884  """
2885  return _pcbnew.TITLE_BLOCK_GetTitle(self)
2886 
2887 
2888  def SetDate(self, aDate):
2889  """
2890  SetDate(TITLE_BLOCK self, wxString aDate)
2891 
2892  void
2893  TITLE_BLOCK::SetDate(const wxString &aDate)
2894 
2895  Function SetDate sets the date field, and defaults to the current time
2896  and date.
2897  """
2898  return _pcbnew.TITLE_BLOCK_SetDate(self, aDate)
2899 
2900 
2901  def GetDate(self):
2902  """
2903  GetDate(TITLE_BLOCK self) -> wxString
2904 
2905  const wxString&
2906  TITLE_BLOCK::GetDate() const
2907  """
2908  return _pcbnew.TITLE_BLOCK_GetDate(self)
2909 
2910 
2911  def SetRevision(self, aRevision):
2912  """
2913  SetRevision(TITLE_BLOCK self, wxString aRevision)
2914 
2915  void
2916  TITLE_BLOCK::SetRevision(const wxString &aRevision)
2917  """
2918  return _pcbnew.TITLE_BLOCK_SetRevision(self, aRevision)
2919 
2920 
2921  def GetRevision(self):
2922  """
2923  GetRevision(TITLE_BLOCK self) -> wxString
2924 
2925  const wxString&
2926  TITLE_BLOCK::GetRevision() const
2927  """
2928  return _pcbnew.TITLE_BLOCK_GetRevision(self)
2929 
2930 
2931  def SetCompany(self, aCompany):
2932  """
2933  SetCompany(TITLE_BLOCK self, wxString aCompany)
2934 
2935  void
2936  TITLE_BLOCK::SetCompany(const wxString &aCompany)
2937  """
2938  return _pcbnew.TITLE_BLOCK_SetCompany(self, aCompany)
2939 
2940 
2941  def GetCompany(self):
2942  """
2943  GetCompany(TITLE_BLOCK self) -> wxString
2944 
2945  const wxString&
2946  TITLE_BLOCK::GetCompany() const
2947  """
2948  return _pcbnew.TITLE_BLOCK_GetCompany(self)
2949 
2950 
2951  def SetComment(self, aIdx, aComment):
2952  """
2953  SetComment(TITLE_BLOCK self, int aIdx, wxString aComment)
2954 
2955  void
2956  TITLE_BLOCK::SetComment(int aIdx, const wxString &aComment)
2957  """
2958  return _pcbnew.TITLE_BLOCK_SetComment(self, aIdx, aComment)
2959 
2960 
2961  def GetComment(self, aIdx):
2962  """
2963  GetComment(TITLE_BLOCK self, int aIdx) -> wxString
2964 
2965  const wxString&
2966  TITLE_BLOCK::GetComment(int aIdx) const
2967  """
2968  return _pcbnew.TITLE_BLOCK_GetComment(self, aIdx)
2969 
2970 
2971  def SetComment1(self, aComment):
2972  """
2973  SetComment1(TITLE_BLOCK self, wxString aComment)
2974 
2975  void
2976  TITLE_BLOCK::SetComment1(const wxString &aComment)
2977  """
2978  return _pcbnew.TITLE_BLOCK_SetComment1(self, aComment)
2979 
2980 
2981  def SetComment2(self, aComment):
2982  """
2983  SetComment2(TITLE_BLOCK self, wxString aComment)
2984 
2985  void
2986  TITLE_BLOCK::SetComment2(const wxString &aComment)
2987  """
2988  return _pcbnew.TITLE_BLOCK_SetComment2(self, aComment)
2989 
2990 
2991  def SetComment3(self, aComment):
2992  """
2993  SetComment3(TITLE_BLOCK self, wxString aComment)
2994 
2995  void
2996  TITLE_BLOCK::SetComment3(const wxString &aComment)
2997  """
2998  return _pcbnew.TITLE_BLOCK_SetComment3(self, aComment)
2999 
3000 
3001  def SetComment4(self, aComment):
3002  """
3003  SetComment4(TITLE_BLOCK self, wxString aComment)
3004 
3005  void
3006  TITLE_BLOCK::SetComment4(const wxString &aComment)
3007  """
3008  return _pcbnew.TITLE_BLOCK_SetComment4(self, aComment)
3009 
3010 
3011  def GetComment1(self):
3012  """
3013  GetComment1(TITLE_BLOCK self) -> wxString
3014 
3015  const wxString&
3016  TITLE_BLOCK::GetComment1() const
3017  """
3018  return _pcbnew.TITLE_BLOCK_GetComment1(self)
3019 
3020 
3021  def GetComment2(self):
3022  """
3023  GetComment2(TITLE_BLOCK self) -> wxString
3024 
3025  const wxString&
3026  TITLE_BLOCK::GetComment2() const
3027  """
3028  return _pcbnew.TITLE_BLOCK_GetComment2(self)
3029 
3030 
3031  def GetComment3(self):
3032  """
3033  GetComment3(TITLE_BLOCK self) -> wxString
3034 
3035  const wxString&
3036  TITLE_BLOCK::GetComment3() const
3037  """
3038  return _pcbnew.TITLE_BLOCK_GetComment3(self)
3039 
3040 
3041  def GetComment4(self):
3042  """
3043  GetComment4(TITLE_BLOCK self) -> wxString
3044 
3045  const wxString&
3046  TITLE_BLOCK::GetComment4() const
3047  """
3048  return _pcbnew.TITLE_BLOCK_GetComment4(self)
3049 
3050 
3051  def Clear(self):
3052  """
3053  Clear(TITLE_BLOCK self)
3054 
3055  void TITLE_BLOCK::Clear()
3056 
3057  """
3058  return _pcbnew.TITLE_BLOCK_Clear(self)
3059 
3060 
3061  def Format(self, aFormatter, aNestLevel, aControlBits):
3062  """
3063  Format(TITLE_BLOCK self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)
3064 
3065  void
3066  TITLE_BLOCK::Format(OUTPUTFORMATTER *aFormatter, int aNestLevel, int
3067  aControlBits) const
3068 
3069  Function Format outputs the object to aFormatter in s-expression form.
3070 
3071  Parameters:
3072  -----------
3073 
3074  aFormatter: The OUTPUTFORMATTER object to write to.
3075 
3076  aNestLevel: The indentation next level.
3077 
3078  aControlBits: The control bit definition for object specific
3079  formatting.
3080 
3081  Parameters:
3082  -----------
3083 
3084  ???: on write error.
3085  """
3086  return _pcbnew.TITLE_BLOCK_Format(self, aFormatter, aNestLevel, aControlBits)
3087 
3088 TITLE_BLOCK_swigregister = _pcbnew.TITLE_BLOCK_swigregister
3089 TITLE_BLOCK_swigregister(TITLE_BLOCK)
3090 
3092  """Proxy of C++ KIGFX::COLOR4D class"""
3093  __swig_setmethods__ = {}
3094  __setattr__ = lambda self, name, value: _swig_setattr(self, COLOR4D, name, value)
3095  __swig_getmethods__ = {}
3096  __getattr__ = lambda self, name: _swig_getattr(self, COLOR4D, name)
3097  __repr__ = _swig_repr
3098 
3099  def __init__(self, *args):
3100  """
3101  __init__(KIGFX::COLOR4D self) -> COLOR4D
3102  __init__(KIGFX::COLOR4D self, double aRed, double aGreen, double aBlue, double aAlpha) -> COLOR4D
3103  __init__(KIGFX::COLOR4D self, EDA_COLOR_T aColor) -> COLOR4D
3104  __init__(KIGFX::COLOR4D self, wxColour const & aColor) -> COLOR4D
3105  """
3106  this = _pcbnew.new_COLOR4D(*args)
3107  try:
3108  self.this.append(this)
3109  except:
3110  self.this = this
3111 
3112  def SetFromWxString(self, aColorString):
3113  """SetFromWxString(COLOR4D self, wxString aColorString) -> bool"""
3114  return _pcbnew.COLOR4D_SetFromWxString(self, aColorString)
3115 
3116 
3117  def ToWxString(self, flags):
3118  """ToWxString(COLOR4D self, long flags) -> wxString"""
3119  return _pcbnew.COLOR4D_ToWxString(self, flags)
3120 
3121 
3122  def ToColour(self):
3123  """ToColour(COLOR4D self) -> wxColour"""
3124  return _pcbnew.COLOR4D_ToColour(self)
3125 
3126 
3127  def LegacyMix(self, aColor):
3128  """LegacyMix(COLOR4D self, COLOR4D aColor) -> COLOR4D"""
3129  return _pcbnew.COLOR4D_LegacyMix(self, aColor)
3130 
3131 
3133  """SetToLegacyHighlightColor(COLOR4D self) -> COLOR4D"""
3134  return _pcbnew.COLOR4D_SetToLegacyHighlightColor(self)
3135 
3136 
3138  """SetToNearestLegacyColor(COLOR4D self) -> COLOR4D"""
3139  return _pcbnew.COLOR4D_SetToNearestLegacyColor(self)
3140 
3141 
3142  def ToU32(self):
3143  """ToU32(COLOR4D self) -> unsigned int"""
3144  return _pcbnew.COLOR4D_ToU32(self)
3145 
3146 
3147  def FromU32(self, aPackedColor):
3148  """FromU32(COLOR4D self, unsigned int aPackedColor)"""
3149  return _pcbnew.COLOR4D_FromU32(self, aPackedColor)
3150 
3151 
3153  """GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
3154  return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
3155 
3156  if _newclass:
3157  GetNearestLegacyColor = staticmethod(GetNearestLegacyColor)
3158  __swig_getmethods__["GetNearestLegacyColor"] = lambda x: GetNearestLegacyColor
3159 
3160  def Brighten(self, aFactor):
3161  """Brighten(COLOR4D self, double aFactor) -> COLOR4D"""
3162  return _pcbnew.COLOR4D_Brighten(self, aFactor)
3163 
3164 
3165  def Darken(self, aFactor):
3166  """Darken(COLOR4D self, double aFactor) -> COLOR4D"""
3167  return _pcbnew.COLOR4D_Darken(self, aFactor)
3168 
3169 
3170  def Invert(self):
3171  """Invert(COLOR4D self) -> COLOR4D"""
3172  return _pcbnew.COLOR4D_Invert(self)
3173 
3174 
3175  def Saturate(self, aFactor):
3176  """Saturate(COLOR4D self, double aFactor) -> COLOR4D"""
3177  return _pcbnew.COLOR4D_Saturate(self, aFactor)
3178 
3179 
3180  def Brightened(self, aFactor):
3181  """Brightened(COLOR4D self, double aFactor) -> COLOR4D"""
3182  return _pcbnew.COLOR4D_Brightened(self, aFactor)
3183 
3184 
3185  def Darkened(self, aFactor):
3186  """Darkened(COLOR4D self, double aFactor) -> COLOR4D"""
3187  return _pcbnew.COLOR4D_Darkened(self, aFactor)
3188 
3189 
3190  def WithAlpha(self, aAlpha):
3191  """WithAlpha(COLOR4D self, double aAlpha) -> COLOR4D"""
3192  return _pcbnew.COLOR4D_WithAlpha(self, aAlpha)
3193 
3194 
3195  def Inverted(self):
3196  """Inverted(COLOR4D self) -> COLOR4D"""
3197  return _pcbnew.COLOR4D_Inverted(self)
3198 
3199 
3200  def GetBrightness(self):
3201  """GetBrightness(COLOR4D self) -> double"""
3202  return _pcbnew.COLOR4D_GetBrightness(self)
3203 
3204 
3205  def ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue=False):
3206  """
3207  ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue, bool aAlwaysDefineHue=False)
3208  ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue)
3209  """
3210  return _pcbnew.COLOR4D_ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue)
3211 
3212 
3213  def FromHSV(self, aInH, aInS, aInV):
3214  """FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
3215  return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)
3216 
3217  __swig_setmethods__["r"] = _pcbnew.COLOR4D_r_set
3218  __swig_getmethods__["r"] = _pcbnew.COLOR4D_r_get
3219  if _newclass:
3220  r = _swig_property(_pcbnew.COLOR4D_r_get, _pcbnew.COLOR4D_r_set)
3221  __swig_setmethods__["g"] = _pcbnew.COLOR4D_g_set
3222  __swig_getmethods__["g"] = _pcbnew.COLOR4D_g_get
3223  if _newclass:
3224  g = _swig_property(_pcbnew.COLOR4D_g_get, _pcbnew.COLOR4D_g_set)
3225  __swig_setmethods__["b"] = _pcbnew.COLOR4D_b_set
3226  __swig_getmethods__["b"] = _pcbnew.COLOR4D_b_get
3227  if _newclass:
3228  b = _swig_property(_pcbnew.COLOR4D_b_get, _pcbnew.COLOR4D_b_set)
3229  __swig_setmethods__["a"] = _pcbnew.COLOR4D_a_set
3230  __swig_getmethods__["a"] = _pcbnew.COLOR4D_a_get
3231  if _newclass:
3232  a = _swig_property(_pcbnew.COLOR4D_a_get, _pcbnew.COLOR4D_a_set)
3233  __swig_destroy__ = _pcbnew.delete_COLOR4D
3234  __del__ = lambda self: None
3235 COLOR4D_swigregister = _pcbnew.COLOR4D_swigregister
3236 COLOR4D_swigregister(COLOR4D)
3237 
3239  """COLOR4D_GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
3240  return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
3241 COLOR4D.UNSPECIFIED = _pcbnew.cvar.COLOR4D_UNSPECIFIED
3242 COLOR4D.WHITE = _pcbnew.cvar.COLOR4D_WHITE
3243 COLOR4D.BLACK = _pcbnew.cvar.COLOR4D_BLACK
3244 
3245 
3246 def __eq__(lhs, rhs):
3247  """__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
3248  return _pcbnew.__eq__(lhs, rhs)
3249 
3250 def __ne__(lhs, rhs):
3251  """__ne__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
3252  return _pcbnew.__ne__(lhs, rhs)
3253 
3254 def __lshift__(aStream, aColor):
3255  """__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
3256  return _pcbnew.__lshift__(aStream, aColor)
3258  """
3259 
3260 
3261  Class COLORS_DESIGN_SETTINGS is a list of color settings for designs
3262  in Eeschema, Pcbnew and GerbView.
3263 
3264  C++ includes: class_colors_design_settings.h
3265  """
3266  __swig_setmethods__ = {}
3267  __setattr__ = lambda self, name, value: _swig_setattr(self, COLORS_DESIGN_SETTINGS, name, value)
3268  __swig_getmethods__ = {}
3269  __getattr__ = lambda self, name: _swig_getattr(self, COLORS_DESIGN_SETTINGS, name)
3270  __repr__ = _swig_repr
3271  __swig_setmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set
3272  __swig_getmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get
3273  if _newclass:
3274  m_LayersColors = _swig_property(_pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get, _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set)
3275 
3276  def __init__(self):
3277  """
3278  __init__(COLORS_DESIGN_SETTINGS self) -> COLORS_DESIGN_SETTINGS
3279 
3280  COLORS_DESIGN_SETTINGS::COLORS_DESIGN_SETTINGS()
3281  """
3282  this = _pcbnew.new_COLORS_DESIGN_SETTINGS()
3283  try:
3284  self.this.append(this)
3285  except:
3286  self.this = this
3287  __swig_destroy__ = _pcbnew.delete_COLORS_DESIGN_SETTINGS
3288  __del__ = lambda self: None
3289 
3290  def Load(self, aConfig):
3291  """
3292  Load(COLORS_DESIGN_SETTINGS self, wxConfigBase * aConfig)
3293 
3294  void
3295  COLORS_DESIGN_SETTINGS::Load(wxConfigBase *aConfig) override
3296  """
3297  return _pcbnew.COLORS_DESIGN_SETTINGS_Load(self, aConfig)
3298 
3299 
3300  def Save(self, aConfig):
3301  """
3302  Save(COLORS_DESIGN_SETTINGS self, wxConfigBase * aConfig)
3303 
3304  void
3305  COLORS_DESIGN_SETTINGS::Save(wxConfigBase *aConfig) override
3306  """
3307  return _pcbnew.COLORS_DESIGN_SETTINGS_Save(self, aConfig)
3308 
3309 
3310  def GetLayerColor(self, aLayer):
3311  """
3312  GetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer) -> COLOR4D
3313 
3314  COLOR4D
3315  COLORS_DESIGN_SETTINGS::GetLayerColor(LAYER_NUM aLayer) const
3316 
3317  Function GetLayerColor.
3318 
3319  the color for aLayer which is one of the layer indices given in
3320  pcbstruct.h or in schematic
3321  """
3322  return _pcbnew.COLORS_DESIGN_SETTINGS_GetLayerColor(self, aLayer)
3323 
3324 
3325  def SetLayerColor(self, aLayer, aColor):
3326  """
3327  SetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer, COLOR4D aColor)
3328 
3329  void
3330  COLORS_DESIGN_SETTINGS::SetLayerColor(LAYER_NUM aLayer, COLOR4D
3331  aColor)
3332 
3333  Function SetLayerColor sets the color for aLayer which is one of the
3334  layer indices given in pcbstruct.h or in schematic.
3335  """
3336  return _pcbnew.COLORS_DESIGN_SETTINGS_SetLayerColor(self, aLayer, aColor)
3337 
3338 
3339  def GetItemColor(self, aItemIdx):
3340  """
3341  GetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx) -> COLOR4D
3342 
3343  COLOR4D
3344  COLORS_DESIGN_SETTINGS::GetItemColor(int aItemIdx) const
3345 
3346  Function GetItemColor.
3347 
3348  the color for an item which is one of the item indices given in enum
3349  PCB_LAYER_ID
3350  """
3351  return _pcbnew.COLORS_DESIGN_SETTINGS_GetItemColor(self, aItemIdx)
3352 
3353 
3354  def SetItemColor(self, aItemIdx, aColor):
3355  """
3356  SetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx, COLOR4D aColor)
3357 
3358  void
3359  COLORS_DESIGN_SETTINGS::SetItemColor(int aItemIdx, COLOR4D aColor)
3360 
3361  Function SetItemColor sets the color for an item which is one of the
3362  item indices given in enum PCB_LAYER_ID.
3363  """
3364  return _pcbnew.COLORS_DESIGN_SETTINGS_SetItemColor(self, aItemIdx, aColor)
3365 
3366 
3367  def SetAllColorsAs(self, aColor):
3368  """
3369  SetAllColorsAs(COLORS_DESIGN_SETTINGS self, COLOR4D aColor)
3370 
3371  void
3372  COLORS_DESIGN_SETTINGS::SetAllColorsAs(COLOR4D aColor)
3373 
3374  Function SetAllColorsAs sets alls colors to aColor Usefull to create a
3375  monochrome color selection for printing purpose.
3376  """
3377  return _pcbnew.COLORS_DESIGN_SETTINGS_SetAllColorsAs(self, aColor)
3378 
3379 COLORS_DESIGN_SETTINGS_swigregister = _pcbnew.COLORS_DESIGN_SETTINGS_swigregister
3380 COLORS_DESIGN_SETTINGS_swigregister(COLORS_DESIGN_SETTINGS)
3381 
3383  """
3384  C++ includes: class_marker_base.h
3385 
3386  """
3387  __swig_setmethods__ = {}
3388  __setattr__ = lambda self, name, value: _swig_setattr(self, MARKER_BASE, name, value)
3389  __swig_getmethods__ = {}
3390  __getattr__ = lambda self, name: _swig_getattr(self, MARKER_BASE, name)
3391  __repr__ = _swig_repr
3392  MARKER_UNSPEC = _pcbnew.MARKER_BASE_MARKER_UNSPEC
3393  MARKER_ERC = _pcbnew.MARKER_BASE_MARKER_ERC
3394  MARKER_PCB = _pcbnew.MARKER_BASE_MARKER_PCB
3395  MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
3396  MARKER_SEVERITY_UNSPEC = _pcbnew.MARKER_BASE_MARKER_SEVERITY_UNSPEC
3397  MARKER_SEVERITY_INFO = _pcbnew.MARKER_BASE_MARKER_SEVERITY_INFO
3398  MARKER_SEVERITY_WARNING = _pcbnew.MARKER_BASE_MARKER_SEVERITY_WARNING
3399  MARKER_SEVERITY_ERROR = _pcbnew.MARKER_BASE_MARKER_SEVERITY_ERROR
3400  __swig_setmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_set
3401  __swig_getmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_get
3402  if _newclass:
3403  m_Pos = _swig_property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set)
3404 
3405  def __init__(self, *args):
3406  """
3407  __init__(MARKER_BASE self) -> MARKER_BASE
3408  __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos) -> MARKER_BASE
3409  __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos) -> MARKER_BASE
3410  __init__(MARKER_BASE self, MARKER_BASE aMarker) -> MARKER_BASE
3411 
3412  MARKER_BASE::MARKER_BASE(const MARKER_BASE &aMarker)
3413 
3414  Contructor makes a copy of aMarker but does not copy the DRC_ITEM.
3415 
3416  Parameters:
3417  -----------
3418 
3419  aMarker: The marker to copy.
3420  """
3421  this = _pcbnew.new_MARKER_BASE(*args)
3422  try:
3423  self.this.append(this)
3424  except:
3425  self.this = this
3426  __swig_destroy__ = _pcbnew.delete_MARKER_BASE
3427  __del__ = lambda self: None
3428 
3429  def DrawMarker(self, aPanel, aDC, aDrawMode, aOffset):
3430  """
3431  DrawMarker(MARKER_BASE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
3432 
3433  void
3434  MARKER_BASE::DrawMarker(EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE
3435  aDrawMode, const wxPoint &aOffset)
3436 
3437  Function DrawMarker draws the shape is the polygon defined in
3438  m_Corners (array of wxPoints).
3439  """
3440  return _pcbnew.MARKER_BASE_DrawMarker(self, aPanel, aDC, aDrawMode, aOffset)
3441 
3442 
3443  def GetPos(self):
3444  """
3445  GetPos(MARKER_BASE self) -> wxPoint
3446 
3447  const wxPoint&
3448  MARKER_BASE::GetPos() const
3449 
3450  Function GetPos returns the position of this MARKER, const.
3451  """
3452  return _pcbnew.MARKER_BASE_GetPos(self)
3453 
3454 
3455  def SetColor(self, aColor):
3456  """
3457  SetColor(MARKER_BASE self, COLOR4D aColor)
3458 
3459  void
3460  MARKER_BASE::SetColor(COLOR4D aColor)
3461 
3462  Function SetColor Set the color of this marker.
3463  """
3464  return _pcbnew.MARKER_BASE_SetColor(self, aColor)
3465 
3466 
3467  def SetErrorLevel(self, aErrorLevel):
3468  """
3469  SetErrorLevel(MARKER_BASE self, MARKER_BASE::MARKER_SEVERITY aErrorLevel)
3470 
3471  void
3472  MARKER_BASE::SetErrorLevel(MARKER_SEVERITY aErrorLevel)
3473 
3474  accessors to set/get error levels (warning, error, fatal error..)
3475  """
3476  return _pcbnew.MARKER_BASE_SetErrorLevel(self, aErrorLevel)
3477 
3478 
3479  def GetErrorLevel(self):
3480  """
3481  GetErrorLevel(MARKER_BASE self) -> MARKER_BASE::MARKER_SEVERITY
3482 
3483  MARKER_SEVERITY
3484  MARKER_BASE::GetErrorLevel() const
3485  """
3486  return _pcbnew.MARKER_BASE_GetErrorLevel(self)
3487 
3488 
3489  def SetMarkerType(self, aMarkerType):
3490  """
3491  SetMarkerType(MARKER_BASE self, enum MARKER_BASE::TYPEMARKER aMarkerType)
3492 
3493  void
3494  MARKER_BASE::SetMarkerType(enum TYPEMARKER aMarkerType)
3495 
3496  accessors to set/get marker type ( DRC, ERC, or other)
3497  """
3498  return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)
3499 
3500 
3501  def GetMarkerType(self):
3502  """
3503  GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::TYPEMARKER
3504 
3505  enum TYPEMARKER
3506  MARKER_BASE::GetMarkerType() const
3507  """
3508  return _pcbnew.MARKER_BASE_GetMarkerType(self)
3509 
3510 
3511  def SetData(self, *args):
3512  """
3513  SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos)
3514  SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos)
3515 
3516  void
3517  MARKER_BASE::SetData(int aErrorCode, const wxPoint &aMarkerPos, const
3518  wxString &aText, const wxPoint &aPos)
3519 
3520  Function SetData fills in all the reportable data associated with a
3521  MARKER.
3522 
3523  Parameters:
3524  -----------
3525 
3526  aErrorCode: The categorizing identifier for an error
3527 
3528  aMarkerPos: The position of the MARKER on the BOARD
3529 
3530  aText: Text describing the object
3531 
3532  aPos: The position of the object
3533  """
3534  return _pcbnew.MARKER_BASE_SetData(self, *args)
3535 
3536 
3537  def SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos):
3538  """
3539  SetAuxiliaryData(MARKER_BASE self, wxString aAuxiliaryText, wxPoint aAuxiliaryPos)
3540 
3541  void
3542  MARKER_BASE::SetAuxiliaryData(const wxString &aAuxiliaryText, const
3543  wxPoint &aAuxiliaryPos)
3544 
3545  Function SetAuxiliaryData initialize data for the second (auxiliary)
3546  item.
3547 
3548  Parameters:
3549  -----------
3550 
3551  aAuxiliaryText: = the second text (main text) concerning the second
3552  schematic or board item
3553 
3554  aAuxiliaryPos: = position the second item
3555  """
3556  return _pcbnew.MARKER_BASE_SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos)
3557 
3558 
3560  """
3561  SetShowNoCoordinate(MARKER_BASE self)
3562 
3563  void
3564  MARKER_BASE::SetShowNoCoordinate()
3565  """
3566  return _pcbnew.MARKER_BASE_SetShowNoCoordinate(self)
3567 
3568 
3569  def GetReporter(self):
3570  """
3571  GetReporter(MARKER_BASE self) -> DRC_ITEM const &
3572 
3573  const DRC_ITEM&
3574  MARKER_BASE::GetReporter() const
3575 
3576  Function GetReporter returns the DRC_ITEM held within this MARKER so
3577  that its interface may be used.
3578 
3579  const& DRC_ITEM
3580  """
3581  return _pcbnew.MARKER_BASE_GetReporter(self)
3582 
3583 
3584  def DisplayMarkerInfo(self, aFrame):
3585  """
3586  DisplayMarkerInfo(MARKER_BASE self, EDA_DRAW_FRAME * aFrame)
3587 
3588  void
3589  MARKER_BASE::DisplayMarkerInfo(EDA_DRAW_FRAME *aFrame)
3590 
3591  Function DisplayMarkerInfo displays the full info of this marker, in a
3592  HTML window.
3593  """
3594  return _pcbnew.MARKER_BASE_DisplayMarkerInfo(self, aFrame)
3595 
3596 
3597  def HitTestMarker(self, ref_pos):
3598  """
3599  HitTestMarker(MARKER_BASE self, wxPoint ref_pos) -> bool
3600 
3601  bool
3602  MARKER_BASE::HitTestMarker(const wxPoint &ref_pos) const
3603 
3604  Function HitTestMarker tests if the given wxPoint is within the bounds
3605  of this object.
3606 
3607  Parameters:
3608  -----------
3609 
3610  ref_pos: A wxPoint to test
3611 
3612  bool - true if a hit, else false
3613  """
3614  return _pcbnew.MARKER_BASE_HitTestMarker(self, ref_pos)
3615 
3616 
3618  """
3619  GetBoundingBoxMarker(MARKER_BASE self) -> EDA_RECT
3620 
3621  EDA_RECT
3622  MARKER_BASE::GetBoundingBoxMarker() const
3623 
3624  Function GetBoundingBoxMarker returns the orthogonal, bounding box of
3625  this object for display purposes.
3626 
3627  This box should be an enclosing perimeter for visible components of
3628  this object, and the units should be in the pcb or schematic
3629  coordinate system. It is OK to overestimate the size by a few counts.
3630 
3631  """
3632  return _pcbnew.MARKER_BASE_GetBoundingBoxMarker(self)
3633 
3634 MARKER_BASE_swigregister = _pcbnew.MARKER_BASE_swigregister
3635 MARKER_BASE_swigregister(MARKER_BASE)
3636 
3637 
3638 _pcbnew.CTL_OMIT_HIDE_swigconstant(_pcbnew)
3639 CTL_OMIT_HIDE = _pcbnew.CTL_OMIT_HIDE
3640 
3641 _pcbnew.GR_TEXT_HJUSTIFY_LEFT_swigconstant(_pcbnew)
3642 GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT
3643 
3644 _pcbnew.GR_TEXT_HJUSTIFY_CENTER_swigconstant(_pcbnew)
3645 GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER
3646 
3647 _pcbnew.GR_TEXT_HJUSTIFY_RIGHT_swigconstant(_pcbnew)
3648 GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT
3649 
3650 _pcbnew.GR_TEXT_VJUSTIFY_TOP_swigconstant(_pcbnew)
3651 GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP
3652 
3653 _pcbnew.GR_TEXT_VJUSTIFY_CENTER_swigconstant(_pcbnew)
3654 GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER
3655 
3656 _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM_swigconstant(_pcbnew)
3657 GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM
3658 
3659 _pcbnew.FILLED_swigconstant(_pcbnew)
3660 FILLED = _pcbnew.FILLED
3661 
3662 _pcbnew.SKETCH_swigconstant(_pcbnew)
3663 SKETCH = _pcbnew.SKETCH
3664 
3665 _pcbnew.DEFAULT_SIZE_TEXT_swigconstant(_pcbnew)
3666 DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT
3667 
3668 _pcbnew.DIM_ANCRE_TEXTE_swigconstant(_pcbnew)
3669 DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE
3671  """Proxy of C++ TEXT_EFFECTS class"""
3672  __swig_setmethods__ = {}
3673  __setattr__ = lambda self, name, value: _swig_setattr(self, TEXT_EFFECTS, name, value)
3674  __swig_getmethods__ = {}
3675  __getattr__ = lambda self, name: _swig_getattr(self, TEXT_EFFECTS, name)
3676  __repr__ = _swig_repr
3677 
3678  def __init__(self, aSetOfBits=0):
3679  """
3680  __init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS
3681  __init__(TEXT_EFFECTS self) -> TEXT_EFFECTS
3682  """
3683  this = _pcbnew.new_TEXT_EFFECTS(aSetOfBits)
3684  try:
3685  self.this.append(this)
3686  except:
3687  self.this = this
3688  __swig_setmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_set
3689  __swig_getmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_get
3690  if _newclass:
3691  bits = _swig_property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set)
3692  __swig_setmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_set
3693  __swig_getmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_get
3694  if _newclass:
3695  hjustify = _swig_property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set)
3696  __swig_setmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_set
3697  __swig_getmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_get
3698  if _newclass:
3699  vjustify = _swig_property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set)
3700  __swig_setmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_set
3701  __swig_getmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_get
3702  if _newclass:
3703  size = _swig_property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set)
3704  __swig_setmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_set
3705  __swig_getmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_get
3706  if _newclass:
3707  penwidth = _swig_property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set)
3708  __swig_setmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_set
3709  __swig_getmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_get
3710  if _newclass:
3711  angle = _swig_property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set)
3712  __swig_setmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_set
3713  __swig_getmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_get
3714  if _newclass:
3715  pos = _swig_property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set)
3716 
3717  def Bit(self, *args):
3718  """
3719  Bit(TEXT_EFFECTS self, int aBit, bool aValue)
3720  Bit(TEXT_EFFECTS self, int aBit) -> bool
3721  """
3722  return _pcbnew.TEXT_EFFECTS_Bit(self, *args)
3723 
3724  __swig_destroy__ = _pcbnew.delete_TEXT_EFFECTS
3725  __del__ = lambda self: None
3726 TEXT_EFFECTS_swigregister = _pcbnew.TEXT_EFFECTS_swigregister
3727 TEXT_EFFECTS_swigregister(TEXT_EFFECTS)
3728 
3730  """
3731 
3732 
3733  Class EDA_TEXT is a mix-in class (via multiple inheritance) that
3734  handles texts such as labels, parts, components, or footprints.
3735 
3736  Because it's a mix-in class, care is used to provide function names
3737  (accessors) that to not collide with function names likely to be seen
3738  in the combined derived classes.
3739 
3740  C++ includes: eda_text.h
3741  """
3742  __swig_setmethods__ = {}
3743  __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_TEXT, name, value)
3744  __swig_getmethods__ = {}
3745  __getattr__ = lambda self, name: _swig_getattr(self, EDA_TEXT, name)
3746  __repr__ = _swig_repr
3747 
3748  def __init__(self, *args):
3749  """
3750  __init__(EDA_TEXT self, wxString text) -> EDA_TEXT
3751  __init__(EDA_TEXT self) -> EDA_TEXT
3752 
3753  EDA_TEXT::EDA_TEXT(const
3754  wxString &text=wxEmptyString)
3755  """
3756  this = _pcbnew.new_EDA_TEXT(*args)
3757  try:
3758  self.this.append(this)
3759  except:
3760  self.this = this
3761  __swig_destroy__ = _pcbnew.delete_EDA_TEXT
3762  __del__ = lambda self: None
3763 
3764  def GetText(self):
3765  """
3766  GetText(EDA_TEXT self) -> wxString
3767 
3768  const wxString&
3769  EDA_TEXT::GetText() const
3770 
3771  Function GetText returns the string associated with the text object.
3772 
3773  a const wxString reference containing the string of the item.
3774  """
3775  return _pcbnew.EDA_TEXT_GetText(self)
3776 
3777 
3778  def GetShownText(self):
3779  """
3780  GetShownText(EDA_TEXT self) -> wxString
3781 
3782  virtual wxString
3783  EDA_TEXT::GetShownText() const
3784 
3785  Returns the string actually shown after processing of the base text.
3786 
3787  Default is no processing
3788  """
3789  return _pcbnew.EDA_TEXT_GetShownText(self)
3790 
3791 
3793  """
3794  ShortenedShownText(EDA_TEXT self) -> wxString
3795 
3796  wxString
3797  EDA_TEXT::ShortenedShownText() const
3798 
3799  Returns a shortened version (max 15 characters) of the shown text.
3800  """
3801  return _pcbnew.EDA_TEXT_ShortenedShownText(self)
3802 
3803 
3804  def SetText(self, aText):
3805  """
3806  SetText(EDA_TEXT self, wxString aText)
3807 
3808  virtual void
3809  EDA_TEXT::SetText(const wxString &aText)
3810  """
3811  return _pcbnew.EDA_TEXT_SetText(self, aText)
3812 
3813 
3814  def SetThickness(self, aNewThickness):
3815  """
3816  SetThickness(EDA_TEXT self, int aNewThickness)
3817 
3818  void
3819  EDA_TEXT::SetThickness(int aNewThickness)
3820 
3821  Function SetThickness sets pen width.
3822 
3823  Parameters:
3824  -----------
3825 
3826  aNewThickness: is the new pen width
3827  """
3828  return _pcbnew.EDA_TEXT_SetThickness(self, aNewThickness)
3829 
3830 
3831  def GetThickness(self):
3832  """
3833  GetThickness(EDA_TEXT self) -> int
3834 
3835  int
3836  EDA_TEXT::GetThickness() const
3837 
3838  Function GetThickness returns pen width.
3839  """
3840  return _pcbnew.EDA_TEXT_GetThickness(self)
3841 
3842 
3843  def SetTextAngle(self, aAngle):
3844  """
3845  SetTextAngle(EDA_TEXT self, double aAngle)
3846 
3847  void
3848  EDA_TEXT::SetTextAngle(double aAngle)
3849  """
3850  return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)
3851 
3852 
3853  def GetTextAngle(self):
3854  """
3855  GetTextAngle(EDA_TEXT self) -> double
3856 
3857  double
3858  EDA_TEXT::GetTextAngle() const
3859  """
3860  return _pcbnew.EDA_TEXT_GetTextAngle(self)
3861 
3862 
3864  """
3865  GetTextAngleDegrees(EDA_TEXT self) -> double
3866 
3867  double
3868  EDA_TEXT::GetTextAngleDegrees() const
3869  """
3870  return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)
3871 
3872 
3874  """
3875  GetTextAngleRadians(EDA_TEXT self) -> double
3876 
3877  double
3878  EDA_TEXT::GetTextAngleRadians() const
3879  """
3880  return _pcbnew.EDA_TEXT_GetTextAngleRadians(self)
3881 
3882 
3883  def SetItalic(self, isItalic):
3884  """
3885  SetItalic(EDA_TEXT self, bool isItalic)
3886 
3887  void
3888  EDA_TEXT::SetItalic(bool isItalic)
3889  """
3890  return _pcbnew.EDA_TEXT_SetItalic(self, isItalic)
3891 
3892 
3893  def IsItalic(self):
3894  """
3895  IsItalic(EDA_TEXT self) -> bool
3896 
3897  bool EDA_TEXT::IsItalic()
3898  const
3899  """
3900  return _pcbnew.EDA_TEXT_IsItalic(self)
3901 
3902 
3903  def SetBold(self, aBold):
3904  """
3905  SetBold(EDA_TEXT self, bool aBold)
3906 
3907  void EDA_TEXT::SetBold(bool
3908  aBold)
3909  """
3910  return _pcbnew.EDA_TEXT_SetBold(self, aBold)
3911 
3912 
3913  def IsBold(self):
3914  """
3915  IsBold(EDA_TEXT self) -> bool
3916 
3917  bool EDA_TEXT::IsBold()
3918  const
3919  """
3920  return _pcbnew.EDA_TEXT_IsBold(self)
3921 
3922 
3923  def SetVisible(self, aVisible):
3924  """
3925  SetVisible(EDA_TEXT self, bool aVisible)
3926 
3927  void
3928  EDA_TEXT::SetVisible(bool aVisible)
3929  """
3930  return _pcbnew.EDA_TEXT_SetVisible(self, aVisible)
3931 
3932 
3933  def IsVisible(self):
3934  """
3935  IsVisible(EDA_TEXT self) -> bool
3936 
3937  bool
3938  EDA_TEXT::IsVisible() const
3939  """
3940  return _pcbnew.EDA_TEXT_IsVisible(self)
3941 
3942 
3943  def SetMirrored(self, isMirrored):
3944  """
3945  SetMirrored(EDA_TEXT self, bool isMirrored)
3946 
3947  void
3948  EDA_TEXT::SetMirrored(bool isMirrored)
3949  """
3950  return _pcbnew.EDA_TEXT_SetMirrored(self, isMirrored)
3951 
3952 
3953  def IsMirrored(self):
3954  """
3955  IsMirrored(EDA_TEXT self) -> bool
3956 
3957  bool
3958  EDA_TEXT::IsMirrored() const
3959  """
3960  return _pcbnew.EDA_TEXT_IsMirrored(self)
3961 
3962 
3963  def SetMultilineAllowed(self, aAllow):
3964  """
3965  SetMultilineAllowed(EDA_TEXT self, bool aAllow)
3966 
3967  void
3968  EDA_TEXT::SetMultilineAllowed(bool aAllow)
3969 
3970  Function SetMultiLineAllowed.
3971 
3972  Parameters:
3973  -----------
3974 
3975  aAllow: true if ok to use multiline option, false if ok to use only
3976  single line text. (Single line is faster in calculations than
3977  multiline.)
3978  """
3979  return _pcbnew.EDA_TEXT_SetMultilineAllowed(self, aAllow)
3980 
3981 
3983  """
3984  IsMultilineAllowed(EDA_TEXT self) -> bool
3985 
3986  bool
3987  EDA_TEXT::IsMultilineAllowed() const
3988  """
3989  return _pcbnew.EDA_TEXT_IsMultilineAllowed(self)
3990 
3991 
3992  def GetHorizJustify(self):
3993  """
3994  GetHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T
3995 
3996  EDA_TEXT_HJUSTIFY_T
3997  EDA_TEXT::GetHorizJustify() const
3998  """
3999  return _pcbnew.EDA_TEXT_GetHorizJustify(self)
4000 
4001 
4002  def GetVertJustify(self):
4003  """
4004  GetVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T
4005 
4006  EDA_TEXT_VJUSTIFY_T
4007  EDA_TEXT::GetVertJustify() const
4008  """
4009  return _pcbnew.EDA_TEXT_GetVertJustify(self)
4010 
4011 
4012  def SetHorizJustify(self, aType):
4013  """
4014  SetHorizJustify(EDA_TEXT self, EDA_TEXT_HJUSTIFY_T aType)
4015 
4016  void
4017  EDA_TEXT::SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
4018  """
4019  return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)
4020 
4021 
4022  def SetVertJustify(self, aType):
4023  """
4024  SetVertJustify(EDA_TEXT self, EDA_TEXT_VJUSTIFY_T aType)
4025 
4026  void
4027  EDA_TEXT::SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
4028  """
4029  return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)
4030 
4031 
4032  def SetEffects(self, aSrc):
4033  """
4034  SetEffects(EDA_TEXT self, EDA_TEXT aSrc)
4035 
4036  void
4037  EDA_TEXT::SetEffects(const EDA_TEXT &aSrc)
4038 
4039  Function SetEffects sets the text effects from another instance.
4040 
4041  ( TEXT_EFFECTS is not exposed in the public API, but includes
4042  everything except the actual text string itself.)
4043  """
4044  return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)
4045 
4046 
4047  def SwapEffects(self, aTradingPartner):
4048  """
4049  SwapEffects(EDA_TEXT self, EDA_TEXT aTradingPartner)
4050 
4051  void
4052  EDA_TEXT::SwapEffects(EDA_TEXT &aTradingPartner)
4053 
4054  Function SwapEffects swaps the text effects of the two involved
4055  instances.
4056 
4057  (TEXT_EFECTS is not exposed in the public API, but includes everything
4058  except the actual text string itself.)
4059  """
4060  return _pcbnew.EDA_TEXT_SwapEffects(self, aTradingPartner)
4061 
4062 
4064  """
4065  IsDefaultFormatting(EDA_TEXT self) -> bool
4066 
4067  bool
4068  EDA_TEXT::IsDefaultFormatting() const
4069  """
4070  return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)
4071 
4072 
4073  def SetTextSize(self, aNewSize):
4074  """
4075  SetTextSize(EDA_TEXT self, wxSize aNewSize)
4076 
4077  void
4078  EDA_TEXT::SetTextSize(const wxSize &aNewSize)
4079  """
4080  return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize)
4081 
4082 
4083  def GetTextSize(self):
4084  """
4085  GetTextSize(EDA_TEXT self) -> wxSize
4086 
4087  const wxSize&
4088  EDA_TEXT::GetTextSize() const
4089  """
4090  return _pcbnew.EDA_TEXT_GetTextSize(self)
4091 
4092 
4093  def SetTextWidth(self, aWidth):
4094  """
4095  SetTextWidth(EDA_TEXT self, int aWidth)
4096 
4097  void
4098  EDA_TEXT::SetTextWidth(int aWidth)
4099  """
4100  return _pcbnew.EDA_TEXT_SetTextWidth(self, aWidth)
4101 
4102 
4103  def GetTextWidth(self):
4104  """
4105  GetTextWidth(EDA_TEXT self) -> int
4106 
4107  int
4108  EDA_TEXT::GetTextWidth() const
4109  """
4110  return _pcbnew.EDA_TEXT_GetTextWidth(self)
4111 
4112 
4113  def SetTextHeight(self, aHeight):
4114  """
4115  SetTextHeight(EDA_TEXT self, int aHeight)
4116 
4117  void
4118  EDA_TEXT::SetTextHeight(int aHeight)
4119  """
4120  return _pcbnew.EDA_TEXT_SetTextHeight(self, aHeight)
4121 
4122 
4123  def GetTextHeight(self):
4124  """
4125  GetTextHeight(EDA_TEXT self) -> int
4126 
4127  int
4128  EDA_TEXT::GetTextHeight() const
4129  """
4130  return _pcbnew.EDA_TEXT_GetTextHeight(self)
4131 
4132 
4133  def SetTextPos(self, aPoint):
4134  """
4135  SetTextPos(EDA_TEXT self, wxPoint aPoint)
4136 
4137  void
4138  EDA_TEXT::SetTextPos(const wxPoint &aPoint)
4139  """
4140  return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)
4141 
4142 
4143  def GetTextPos(self):
4144  """
4145  GetTextPos(EDA_TEXT self) -> wxPoint
4146 
4147  const wxPoint&
4148  EDA_TEXT::GetTextPos() const
4149  """
4150  return _pcbnew.EDA_TEXT_GetTextPos(self)
4151 
4152 
4153  def SetTextX(self, aX):
4154  """
4155  SetTextX(EDA_TEXT self, int aX)
4156 
4157  void
4158  EDA_TEXT::SetTextX(int aX)
4159  """
4160  return _pcbnew.EDA_TEXT_SetTextX(self, aX)
4161 
4162 
4163  def SetTextY(self, aY):
4164  """
4165  SetTextY(EDA_TEXT self, int aY)
4166 
4167  void
4168  EDA_TEXT::SetTextY(int aY)
4169  """
4170  return _pcbnew.EDA_TEXT_SetTextY(self, aY)
4171 
4172 
4173  def Offset(self, aOffset):
4174  """
4175  Offset(EDA_TEXT self, wxPoint aOffset)
4176 
4177  void EDA_TEXT::Offset(const
4178  wxPoint &aOffset)
4179  """
4180  return _pcbnew.EDA_TEXT_Offset(self, aOffset)
4181 
4182 
4183  def Empty(self):
4184  """
4185  Empty(EDA_TEXT self)
4186 
4187  void EDA_TEXT::Empty()
4188  """
4189  return _pcbnew.EDA_TEXT_Empty(self)
4190 
4191 
4192  def Draw(self, *args):
4193  """
4194  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)
4195  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED)
4196  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode)
4197 
4198  void EDA_TEXT::Draw(EDA_RECT
4199  *aClipBox, wxDC *aDC, const wxPoint &aOffset, COLOR4D aColor,
4200  GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED, COLOR4D
4201  aAnchor_color=COLOR4D::UNSPECIFIED)
4202 
4203  Function Draw.
4204 
4205  Parameters:
4206  -----------
4207 
4208  aClipBox: = the clipping rect, or NULL if no clipping
4209 
4210  aDC: = the current Device Context
4211 
4212  aOffset: = draw offset (usually (0,0))
4213 
4214  aColor: = text color
4215 
4216  aDrawMode: = GR_OR, GR_XOR.., -1 to use the current mode.
4217 
4218  aDisplay_mode: = FILLED or SKETCH
4219 
4220  aAnchor_color: = anchor color ( COLOR4D::UNSPECIFIED = do not draw
4221  anchor ).
4222  """
4223  return _pcbnew.EDA_TEXT_Draw(self, *args)
4224 
4225 
4226  def TransformTextShapeToSegmentList(self, aCornerBuffer):
4227  """
4228  TransformTextShapeToSegmentList(EDA_TEXT self, wxPoint_Vector aCornerBuffer)
4229 
4230  void EDA_TEXT::TransformTextShapeToSegmentList(std::vector< wxPoint >
4231  &aCornerBuffer) const
4232 
4233  Convert the text shape to a list of segment each segment is stored as
4234  2 wxPoints: the starting point and the ending point there are
4235  therefore 2*n points.
4236 
4237  Parameters:
4238  -----------
4239 
4240  aCornerBuffer: = a buffer to store the polygon
4241  """
4242  return _pcbnew.EDA_TEXT_TransformTextShapeToSegmentList(self, aCornerBuffer)
4243 
4244 
4245  def TextHitTest(self, *args):
4246  """
4247  TextHitTest(EDA_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
4248  TextHitTest(EDA_TEXT self, wxPoint aPoint) -> bool
4249  TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False, int aAccuracy=0) -> bool
4250  TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False) -> bool
4251  TextHitTest(EDA_TEXT self, EDA_RECT aRect) -> bool
4252 
4253  bool
4254  EDA_TEXT::TextHitTest(const EDA_RECT &aRect, bool aContains=false, int
4255  aAccuracy=0) const
4256 
4257  Function TextHitTest (overloaded) Tests if object bounding box is
4258  contained within or intersects aRect.
4259 
4260  Parameters:
4261  -----------
4262 
4263  aRect: - Rect to test against.
4264 
4265  aContains: - Test for containment instead of intersection if true.
4266 
4267  aAccuracy: - Amount to inflate the bounding box.
4268 
4269  bool - true if a hit, else false
4270  """
4271  return _pcbnew.EDA_TEXT_TextHitTest(self, *args)
4272 
4273 
4274  def LenSize(self, aLine):
4275  """
4276  LenSize(EDA_TEXT self, wxString aLine) -> int
4277 
4278  int EDA_TEXT::LenSize(const
4279  wxString &aLine) const
4280 
4281  Function LenSize.
4282 
4283  the text length in internal units
4284 
4285  Parameters:
4286  -----------
4287 
4288  aLine: : the line of text to consider. For single line text, this
4289  parameter is always m_Text
4290  """
4291  return _pcbnew.EDA_TEXT_LenSize(self, aLine)
4292 
4293 
4294  def GetTextBox(self, aLine=-1, aThickness=-1, aInvertY=False):
4295  """
4296  GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1, bool aInvertY=False) -> EDA_RECT
4297  GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1) -> EDA_RECT
4298  GetTextBox(EDA_TEXT self, int aLine=-1) -> EDA_RECT
4299  GetTextBox(EDA_TEXT self) -> EDA_RECT
4300 
4301  EDA_RECT
4302  EDA_TEXT::GetTextBox(int aLine=-1, int aThickness=-1, bool
4303  aInvertY=false) const
4304 
4305  Function GetTextBox useful in multiline texts to calculate the full
4306  text or a line area (for zones filling, locate functions....)
4307 
4308  the rect containing the line of text (i.e. the position and the size
4309  of one line) this rectangle is calculated for 0 orient text. If
4310  orientation is not 0 the rect must be rotated to match the physical
4311  area
4312 
4313  Parameters:
4314  -----------
4315 
4316  aLine: The line of text to consider. for single line text, aLine is
4317  unused If aLine == -1, the full area (considering all lines) is
4318  returned
4319 
4320  aThickness: Overrides the current penwidth when greater than 0. This
4321  is needed when the current penwidth is 0 and a default penwidth is
4322  used.
4323 
4324  aInvertY: Invert the Y axis when calculating bounding box.
4325  """
4326  return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aThickness, aInvertY)
4327 
4328 
4329  def GetInterline(self, aTextThickness=-1):
4330  """
4331  GetInterline(EDA_TEXT self, int aTextThickness=-1) -> int
4332  GetInterline(EDA_TEXT self) -> int
4333 
4334  int
4335  EDA_TEXT::GetInterline(int aTextThickness=-1) const
4336 
4337  Return the distance between two lines of text.
4338 
4339  Calculates the distance (pitch) between two lines of text. This
4340  distance includes the interline distance plus room for characters like
4341  j, {, and [. It also used for single line text, to calculate the text
4342  bounding box.
4343 
4344  Parameters:
4345  -----------
4346 
4347  aTextThickness: Overrides the current thickness when greater than 0.
4348  this is needed when the current m_Thickness is 0 and a default line
4349  thickness is used
4350  """
4351  return _pcbnew.EDA_TEXT_GetInterline(self, aTextThickness)
4352 
4353 
4354  def GetTextStyleName(self):
4355  """
4356  GetTextStyleName(EDA_TEXT self) -> wxString
4357 
4358  wxString
4359  EDA_TEXT::GetTextStyleName()
4360 
4361  Function GetTextStyleName.
4362 
4363  a wxString with the style name( Normal, Italic, Bold, Bold+Italic)
4364  """
4365  return _pcbnew.EDA_TEXT_GetTextStyleName(self)
4366 
4367 
4368  def GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount):
4369  """
4370  GetPositionsOfLinesOfMultilineText(EDA_TEXT self, wxPoint_Vector aPositions, int aLineCount)
4371 
4372  void EDA_TEXT::GetPositionsOfLinesOfMultilineText(std::vector< wxPoint
4373  > &aPositions, int aLineCount) const
4374 
4375  Function GetPositionsOfLinesOfMultilineText Populates aPositions with
4376  the position of each line of a multiline text, according to the
4377  vertical justification and the rotation of the whole text.
4378 
4379  Parameters:
4380  -----------
4381 
4382  aPositions: is the list to populate by the wxPoint positions
4383 
4384  aLineCount: is the number of lines (not recalculated here for
4385  efficiency reasons
4386  """
4387  return _pcbnew.EDA_TEXT_GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount)
4388 
4389 
4390  def Format(self, aFormatter, aNestLevel, aControlBits):
4391  """
4392  Format(EDA_TEXT self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)
4393 
4394  void
4395  EDA_TEXT::Format(OUTPUTFORMATTER *aFormatter, int aNestLevel, int
4396  aControlBits) const
4397 
4398  Function Format outputs the object to aFormatter in s-expression form.
4399 
4400  Parameters:
4401  -----------
4402 
4403  aFormatter: The OUTPUTFORMATTER object to write to.
4404 
4405  aNestLevel: The indentation next level.
4406 
4407  aControlBits: The control bit definition for object specific
4408  formatting.
4409 
4410  Parameters:
4411  -----------
4412 
4413  ???: on write error.
4414  """
4415  return _pcbnew.EDA_TEXT_Format(self, aFormatter, aNestLevel, aControlBits)
4416 
4417 EDA_TEXT_swigregister = _pcbnew.EDA_TEXT_swigregister
4418 EDA_TEXT_swigregister(EDA_TEXT)
4419 
4421  """Proxy of C++ std::vector<(int)> class"""
4422  __swig_setmethods__ = {}
4423  __setattr__ = lambda self, name, value: _swig_setattr(self, intVector, name, value)
4424  __swig_getmethods__ = {}
4425  __getattr__ = lambda self, name: _swig_getattr(self, intVector, name)
4426  __repr__ = _swig_repr
4427 
4428  def iterator(self):
4429  """iterator(intVector self) -> SwigPyIterator"""
4430  return _pcbnew.intVector_iterator(self)
4431 
4432  def __iter__(self):
4433  return self.iterator()
4434 
4435  def __nonzero__(self):
4436  """__nonzero__(intVector self) -> bool"""
4437  return _pcbnew.intVector___nonzero__(self)
4438 
4439 
4440  def __bool__(self):
4441  """__bool__(intVector self) -> bool"""
4442  return _pcbnew.intVector___bool__(self)
4443 
4444 
4445  def __len__(self):
4446  """__len__(intVector self) -> std::vector< int >::size_type"""
4447  return _pcbnew.intVector___len__(self)
4448 
4449 
4450  def pop(self):
4451  """pop(intVector self) -> std::vector< int >::value_type"""
4452  return _pcbnew.intVector_pop(self)
4453 
4454 
4455  def __getslice__(self, i, j):
4456  """__getslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> intVector"""
4457  return _pcbnew.intVector___getslice__(self, i, j)
4458 
4459 
4460  def __setslice__(self, *args):
4461  """
4462  __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, intVector v)
4463  __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
4464  """
4465  return _pcbnew.intVector___setslice__(self, *args)
4466 
4467 
4468  def __delslice__(self, i, j):
4469  """__delslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
4470  return _pcbnew.intVector___delslice__(self, i, j)
4471 
4472 
4473  def __delitem__(self, *args):
4474  """
4475  __delitem__(intVector self, std::vector< int >::difference_type i)
4476  __delitem__(intVector self, PySliceObject * slice)
4477  """
4478  return _pcbnew.intVector___delitem__(self, *args)
4479 
4480 
4481  def __getitem__(self, *args):
4482  """
4483  __getitem__(intVector self, PySliceObject * slice) -> intVector
4484  __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
4485  """
4486  return _pcbnew.intVector___getitem__(self, *args)
4487 
4488 
4489  def __setitem__(self, *args):
4490  """
4491  __setitem__(intVector self, PySliceObject * slice, intVector v)
4492  __setitem__(intVector self, PySliceObject * slice)
4493  __setitem__(intVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
4494  """
4495  return _pcbnew.intVector___setitem__(self, *args)
4496 
4497 
4498  def append(self, x):
4499  """append(intVector self, std::vector< int >::value_type const & x)"""
4500  return _pcbnew.intVector_append(self, x)
4501 
4502 
4503  def empty(self):
4504  """empty(intVector self) -> bool"""
4505  return _pcbnew.intVector_empty(self)
4506 
4507 
4508  def size(self):
4509  """size(intVector self) -> std::vector< int >::size_type"""
4510  return _pcbnew.intVector_size(self)
4511 
4512 
4513  def clear(self):
4514  """clear(intVector self)"""
4515  return _pcbnew.intVector_clear(self)
4516 
4517 
4518  def swap(self, v):
4519  """swap(intVector self, intVector v)"""
4520  return _pcbnew.intVector_swap(self, v)
4521 
4522 
4523  def get_allocator(self):
4524  """get_allocator(intVector self) -> std::vector< int >::allocator_type"""
4525  return _pcbnew.intVector_get_allocator(self)
4526 
4527 
4528  def begin(self):
4529  """begin(intVector self) -> std::vector< int >::iterator"""
4530  return _pcbnew.intVector_begin(self)
4531 
4532 
4533  def end(self):
4534  """end(intVector self) -> std::vector< int >::iterator"""
4535  return _pcbnew.intVector_end(self)
4536 
4537 
4538  def rbegin(self):
4539  """rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
4540  return _pcbnew.intVector_rbegin(self)
4541 
4542 
4543  def rend(self):
4544  """rend(intVector self) -> std::vector< int >::reverse_iterator"""
4545  return _pcbnew.intVector_rend(self)
4546 
4547 
4548  def pop_back(self):
4549  """pop_back(intVector self)"""
4550  return _pcbnew.intVector_pop_back(self)
4551 
4552 
4553  def erase(self, *args):
4554  """
4555  erase(intVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
4556  erase(intVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
4557  """
4558  return _pcbnew.intVector_erase(self, *args)
4559 
4560 
4561  def __init__(self, *args):
4562  """
4563  __init__(std::vector<(int)> self) -> intVector
4564  __init__(std::vector<(int)> self, intVector arg2) -> intVector
4565  __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> intVector
4566  __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
4567  """
4568  this = _pcbnew.new_intVector(*args)
4569  try:
4570  self.this.append(this)
4571  except:
4572  self.this = this
4573 
4574  def push_back(self, x):
4575  """push_back(intVector self, std::vector< int >::value_type const & x)"""
4576  return _pcbnew.intVector_push_back(self, x)
4577 
4578 
4579  def front(self):
4580  """front(intVector self) -> std::vector< int >::value_type const &"""
4581  return _pcbnew.intVector_front(self)
4582 
4583 
4584  def back(self):
4585  """back(intVector self) -> std::vector< int >::value_type const &"""
4586  return _pcbnew.intVector_back(self)
4587 
4588 
4589  def assign(self, n, x):
4590  """assign(intVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
4591  return _pcbnew.intVector_assign(self, n, x)
4592 
4593 
4594  def resize(self, *args):
4595  """
4596  resize(intVector self, std::vector< int >::size_type new_size)
4597  resize(intVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
4598  """
4599  return _pcbnew.intVector_resize(self, *args)
4600 
4601 
4602  def insert(self, *args):
4603  """
4604  insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
4605  insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
4606  """
4607  return _pcbnew.intVector_insert(self, *args)
4608 
4609 
4610  def reserve(self, n):
4611  """reserve(intVector self, std::vector< int >::size_type n)"""
4612  return _pcbnew.intVector_reserve(self, n)
4613 
4614 
4615  def capacity(self):
4616  """capacity(intVector self) -> std::vector< int >::size_type"""
4617  return _pcbnew.intVector_capacity(self)
4618 
4619  __swig_destroy__ = _pcbnew.delete_intVector
4620  __del__ = lambda self: None
4621 intVector_swigregister = _pcbnew.intVector_swigregister
4622 intVector_swigregister(intVector)
4623 
4625  """Proxy of C++ std::map<(std::string,UTF8)> class"""
4626  __swig_setmethods__ = {}
4627  __setattr__ = lambda self, name, value: _swig_setattr(self, str_utf8_Map, name, value)
4628  __swig_getmethods__ = {}
4629  __getattr__ = lambda self, name: _swig_getattr(self, str_utf8_Map, name)
4630  __repr__ = _swig_repr
4631 
4632  def iterator(self):
4633  """iterator(str_utf8_Map self) -> SwigPyIterator"""
4634  return _pcbnew.str_utf8_Map_iterator(self)
4635 
4636  def __iter__(self):
4637  return self.iterator()
4638 
4639  def __nonzero__(self):
4640  """__nonzero__(str_utf8_Map self) -> bool"""
4641  return _pcbnew.str_utf8_Map___nonzero__(self)
4642 
4643 
4644  def __bool__(self):
4645  """__bool__(str_utf8_Map self) -> bool"""
4646  return _pcbnew.str_utf8_Map___bool__(self)
4647 
4648 
4649  def __len__(self):
4650  """__len__(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4651  return _pcbnew.str_utf8_Map___len__(self)
4652 
4653  def __iter__(self):
4654  return self.key_iterator()
4655  def iterkeys(self):
4656  return self.key_iterator()
4657  def itervalues(self):
4658  return self.value_iterator()
4659  def iteritems(self):
4660  return self.iterator()
4661 
4662  def __getitem__(self, key):
4663  """__getitem__(str_utf8_Map self, string key) -> UTF8"""
4664  return _pcbnew.str_utf8_Map___getitem__(self, key)
4665 
4666 
4667  def __delitem__(self, key):
4668  """__delitem__(str_utf8_Map self, string key)"""
4669  return _pcbnew.str_utf8_Map___delitem__(self, key)
4670 
4671 
4672  def has_key(self, key):
4673  """has_key(str_utf8_Map self, string key) -> bool"""
4674  return _pcbnew.str_utf8_Map_has_key(self, key)
4675 
4676 
4677  def keys(self):
4678  """keys(str_utf8_Map self) -> PyObject *"""
4679  return _pcbnew.str_utf8_Map_keys(self)
4680 
4681 
4682  def values(self):
4683  """values(str_utf8_Map self) -> PyObject *"""
4684  return _pcbnew.str_utf8_Map_values(self)
4685 
4686 
4687  def items(self):
4688  """items(str_utf8_Map self) -> PyObject *"""
4689  return _pcbnew.str_utf8_Map_items(self)
4690 
4691 
4692  def __contains__(self, key):
4693  """__contains__(str_utf8_Map self, string key) -> bool"""
4694  return _pcbnew.str_utf8_Map___contains__(self, key)
4695 
4696 
4697  def key_iterator(self):
4698  """key_iterator(str_utf8_Map self) -> SwigPyIterator"""
4699  return _pcbnew.str_utf8_Map_key_iterator(self)
4700 
4701 
4702  def value_iterator(self):
4703  """value_iterator(str_utf8_Map self) -> SwigPyIterator"""
4704  return _pcbnew.str_utf8_Map_value_iterator(self)
4705 
4706 
4707  def __setitem__(self, *args):
4708  """
4709  __setitem__(str_utf8_Map self, string key)
4710  __setitem__(str_utf8_Map self, string key, UTF8 x)
4711  """
4712  return _pcbnew.str_utf8_Map___setitem__(self, *args)
4713 
4714 
4715  def asdict(self):
4716  """asdict(str_utf8_Map self) -> PyObject *"""
4717  return _pcbnew.str_utf8_Map_asdict(self)
4718 
4719 
4720  def __init__(self, *args):
4721  """
4722  __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
4723  __init__(std::map<(std::string,UTF8)> self) -> str_utf8_Map
4724  __init__(std::map<(std::string,UTF8)> self, str_utf8_Map arg2) -> str_utf8_Map
4725  """
4726  this = _pcbnew.new_str_utf8_Map(*args)
4727  try:
4728  self.this.append(this)
4729  except:
4730  self.this = this
4731 
4732  def empty(self):
4733  """empty(str_utf8_Map self) -> bool"""
4734  return _pcbnew.str_utf8_Map_empty(self)
4735 
4736 
4737  def size(self):
4738  """size(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4739  return _pcbnew.str_utf8_Map_size(self)
4740 
4741 
4742  def clear(self):
4743  """clear(str_utf8_Map self)"""
4744  return _pcbnew.str_utf8_Map_clear(self)
4745 
4746 
4747  def swap(self, v):
4748  """swap(str_utf8_Map self, str_utf8_Map v)"""
4749  return _pcbnew.str_utf8_Map_swap(self, v)
4750 
4751 
4752  def get_allocator(self):
4753  """get_allocator(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type"""
4754  return _pcbnew.str_utf8_Map_get_allocator(self)
4755 
4756 
4757  def begin(self):
4758  """begin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4759  return _pcbnew.str_utf8_Map_begin(self)
4760 
4761 
4762  def end(self):
4763  """end(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4764  return _pcbnew.str_utf8_Map_end(self)
4765 
4766 
4767  def rbegin(self):
4768  """rbegin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
4769  return _pcbnew.str_utf8_Map_rbegin(self)
4770 
4771 
4772  def rend(self):
4773  """rend(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
4774  return _pcbnew.str_utf8_Map_rend(self)
4775 
4776 
4777  def count(self, x):
4778  """count(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4779  return _pcbnew.str_utf8_Map_count(self, x)
4780 
4781 
4782  def erase(self, *args):
4783  """
4784  erase(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type
4785  erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator position)
4786  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)
4787  """
4788  return _pcbnew.str_utf8_Map_erase(self, *args)
4789 
4790 
4791  def find(self, x):
4792  """find(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4793  return _pcbnew.str_utf8_Map_find(self, x)
4794 
4795 
4796  def lower_bound(self, x):
4797  """lower_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4798  return _pcbnew.str_utf8_Map_lower_bound(self, x)
4799 
4800 
4801  def upper_bound(self, x):
4802  """upper_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4803  return _pcbnew.str_utf8_Map_upper_bound(self, x)
4804 
4805  __swig_destroy__ = _pcbnew.delete_str_utf8_Map
4806  __del__ = lambda self: None
4807 str_utf8_Map_swigregister = _pcbnew.str_utf8_Map_swigregister
4808 str_utf8_Map_swigregister(str_utf8_Map)
4809 
4811  """Proxy of C++ std::vector<(enum PCB_LAYER_ID)> class"""
4812  __swig_setmethods__ = {}
4813  __setattr__ = lambda self, name, value: _swig_setattr(self, base_seqVect, name, value)
4814  __swig_getmethods__ = {}
4815  __getattr__ = lambda self, name: _swig_getattr(self, base_seqVect, name)
4816  __repr__ = _swig_repr
4817 
4818  def iterator(self):
4819  """iterator(base_seqVect self) -> SwigPyIterator"""
4820  return _pcbnew.base_seqVect_iterator(self)
4821 
4822  def __iter__(self):
4823  return self.iterator()
4824 
4825  def __nonzero__(self):
4826  """__nonzero__(base_seqVect self) -> bool"""
4827  return _pcbnew.base_seqVect___nonzero__(self)
4828 
4829 
4830  def __bool__(self):
4831  """__bool__(base_seqVect self) -> bool"""
4832  return _pcbnew.base_seqVect___bool__(self)
4833 
4834 
4835  def __len__(self):
4836  """__len__(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4837  return _pcbnew.base_seqVect___len__(self)
4838 
4839 
4840  def pop(self):
4841  """pop(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type"""
4842  return _pcbnew.base_seqVect_pop(self)
4843 
4844 
4845  def __getslice__(self, i, j):
4846  """__getslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j) -> base_seqVect"""
4847  return _pcbnew.base_seqVect___getslice__(self, i, j)
4848 
4849 
4850  def __setslice__(self, *args):
4851  """
4852  __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)
4853  __setslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)
4854  """
4855  return _pcbnew.base_seqVect___setslice__(self, *args)
4856 
4857 
4858  def __delslice__(self, i, j):
4859  """__delslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)"""
4860  return _pcbnew.base_seqVect___delslice__(self, i, j)
4861 
4862 
4863  def __delitem__(self, *args):
4864  """
4865  __delitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i)
4866  __delitem__(base_seqVect self, PySliceObject * slice)
4867  """
4868  return _pcbnew.base_seqVect___delitem__(self, *args)
4869 
4870 
4871  def __getitem__(self, *args):
4872  """
4873  __getitem__(base_seqVect self, PySliceObject * slice) -> base_seqVect
4874  __getitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i) -> std::vector< enum PCB_LAYER_ID >::value_type const &
4875  """
4876  return _pcbnew.base_seqVect___getitem__(self, *args)
4877 
4878 
4879  def __setitem__(self, *args):
4880  """
4881  __setitem__(base_seqVect self, PySliceObject * slice, base_seqVect v)
4882  __setitem__(base_seqVect self, PySliceObject * slice)
4883  __setitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::value_type const & x)
4884  """
4885  return _pcbnew.base_seqVect___setitem__(self, *args)
4886 
4887 
4888  def append(self, x):
4889  """append(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4890  return _pcbnew.base_seqVect_append(self, x)
4891 
4892 
4893  def empty(self):
4894  """empty(base_seqVect self) -> bool"""
4895  return _pcbnew.base_seqVect_empty(self)
4896 
4897 
4898  def size(self):
4899  """size(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4900  return _pcbnew.base_seqVect_size(self)
4901 
4902 
4903  def clear(self):
4904  """clear(base_seqVect self)"""
4905  return _pcbnew.base_seqVect_clear(self)
4906 
4907 
4908  def swap(self, v):
4909  """swap(base_seqVect self, base_seqVect v)"""
4910  return _pcbnew.base_seqVect_swap(self, v)
4911 
4912 
4913  def get_allocator(self):
4914  """get_allocator(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::allocator_type"""
4915  return _pcbnew.base_seqVect_get_allocator(self)
4916 
4917 
4918  def begin(self):
4919  """begin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
4920  return _pcbnew.base_seqVect_begin(self)
4921 
4922 
4923  def end(self):
4924  """end(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
4925  return _pcbnew.base_seqVect_end(self)
4926 
4927 
4928  def rbegin(self):
4929  """rbegin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
4930  return _pcbnew.base_seqVect_rbegin(self)
4931 
4932 
4933  def rend(self):
4934  """rend(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
4935  return _pcbnew.base_seqVect_rend(self)
4936 
4937 
4938  def pop_back(self):
4939  """pop_back(base_seqVect self)"""
4940  return _pcbnew.base_seqVect_pop_back(self)
4941 
4942 
4943  def erase(self, *args):
4944  """
4945  erase(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator pos) -> std::vector< enum PCB_LAYER_ID >::iterator
4946  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
4947  """
4948  return _pcbnew.base_seqVect_erase(self, *args)
4949 
4950 
4951  def __init__(self, *args):
4952  """
4953  __init__(std::vector<(enum PCB_LAYER_ID)> self) -> base_seqVect
4954  __init__(std::vector<(enum PCB_LAYER_ID)> self, base_seqVect arg2) -> base_seqVect
4955  __init__(std::vector<(enum PCB_LAYER_ID)> self, std::vector< enum PCB_LAYER_ID >::size_type size) -> base_seqVect
4956  __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
4957  """
4958  this = _pcbnew.new_base_seqVect(*args)
4959  try:
4960  self.this.append(this)
4961  except:
4962  self.this = this
4963 
4964  def push_back(self, x):
4965  """push_back(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4966  return _pcbnew.base_seqVect_push_back(self, x)
4967 
4968 
4969  def front(self):
4970  """front(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
4971  return _pcbnew.base_seqVect_front(self)
4972 
4973 
4974  def back(self):
4975  """back(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
4976  return _pcbnew.base_seqVect_back(self)
4977 
4978 
4979  def assign(self, n, x):
4980  """assign(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4981  return _pcbnew.base_seqVect_assign(self, n, x)
4982 
4983 
4984  def resize(self, *args):
4985  """
4986  resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size)
4987  resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size, std::vector< enum PCB_LAYER_ID >::value_type const & x)
4988  """
4989  return _pcbnew.base_seqVect_resize(self, *args)
4990 
4991 
4992  def insert(self, *args):
4993  """
4994  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
4995  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)
4996  """
4997  return _pcbnew.base_seqVect_insert(self, *args)
4998 
4999 
5000  def reserve(self, n):
5001  """reserve(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n)"""
5002  return _pcbnew.base_seqVect_reserve(self, n)
5003 
5004 
5005  def capacity(self):
5006  """capacity(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
5007  return _pcbnew.base_seqVect_capacity(self)
5008 
5009  __swig_destroy__ = _pcbnew.delete_base_seqVect
5010  __del__ = lambda self: None
5011 base_seqVect_swigregister = _pcbnew.base_seqVect_swigregister
5012 base_seqVect_swigregister(base_seqVect)
5013 
5014 
5015 
5016 KICAD_PLUGINS={} # the list of loaded footprint wizards
5017 
5018 """ the list of not loaded python scripts
5019  (usually because there is a syntax error in python script)
5020  this is the python script full filenames list.
5021  filenames are separated by '\n'
5022 """
5023 NOT_LOADED_WIZARDS=""
5024 
5025 """ the list of paths used to search python scripts.
5026  Stored here to be displayed on request in Pcbnew
5027  paths are separated by '\n'
5028 """
5029 PLUGIN_DIRECTORIES_SEARCH=""
5030 
5031 """ the trace of errors during execution of footprint wizards scripts
5032 """
5033 FULL_BACK_TRACE=""
5034 
5036  global NOT_LOADED_WIZARDS
5037  return NOT_LOADED_WIZARDS
5038 
5040  global PLUGIN_DIRECTORIES_SEARCH
5041  return PLUGIN_DIRECTORIES_SEARCH
5042 
5044  global FULL_BACK_TRACE
5045  return FULL_BACK_TRACE
5046 
5047 
5048 def LoadOnePlugin(Dirname, ModuleName):
5049  """
5050  Load the plugin file ModuleName found in folder Dirname.
5051  If this file cannot be loaded, its name is stored in failed_wizards_list
5052  and the error trace is stored in FULL_BACK_TRACE
5053  """
5054  import os
5055  import sys
5056  import traceback
5057 
5058  global NOT_LOADED_WIZARDS
5059  global FULL_BACK_TRACE
5060 
5061  module_filename = os.path.join(Dirname, ModuleName)
5062 
5063  try: # If there is an error loading the script, skip it
5064  mtime = os.path.getmtime(module_filename)
5065 
5066  if KICAD_PLUGINS.has_key(ModuleName):
5067  plugin = KICAD_PLUGINS[ModuleName]
5068 
5069  if not plugin["modification_time"] == mtime:
5070  mod = reload(plugin["ModuleName"])
5071  plugin["modification_time"] = mtime
5072  else:
5073  mod = plugin["ModuleName"]
5074  else:
5075  mod = __import__(ModuleName[:-3], locals(), globals() )
5076 
5077  KICAD_PLUGINS[ModuleName]={ "filename":module_filename,
5078  "modification_time":mtime,
5079  "ModuleName":mod }
5080 
5081  except:
5082  if NOT_LOADED_WIZARDS != "" :
5083  NOT_LOADED_WIZARDS += "\n"
5084  NOT_LOADED_WIZARDS += module_filename
5085  FULL_BACK_TRACE += traceback.format_exc(sys.exc_info())
5086  pass
5087 
5088 
5089 
5090 def LoadOneSubdirPlugin(Dirname, SubDirname):
5091  """
5092  Load the plugins found in folder Dirname/SubDirname, by loading __ini__.py file.
5093  If files cannot be loaded, its name is stored in failed_wizards_list
5094  and the error trace is stored in FULL_BACK_TRACE
5095  """
5096  import os
5097  import sys
5098  import traceback
5099 
5100  global NOT_LOADED_WIZARDS
5101  global FULL_BACK_TRACE
5102 
5103  fullPath = os.path.join(Dirname,SubDirname)
5104 
5105  if os.path.isdir(fullPath):
5106  """
5107  Skip subdir which does not contain __init__.py, becuase if can be
5108  a non python subdir (can be a subdir for .xsl plugins for instance)
5109  """
5110  if os.path.exists( os.path.join(fullPath, '__init__.py') ):
5111  try: # If there is an error loading the script, skip it
5112  __import__(SubDirname, locals(), globals())
5113 
5114  except:
5115  if NOT_LOADED_WIZARDS != "" :
5116  NOT_LOADED_WIZARDS += "\n"
5117  NOT_LOADED_WIZARDS += fullPath
5118  FULL_BACK_TRACE += traceback.format_exc(sys.exc_info())
5119  pass
5120 
5121  else:
5122  if NOT_LOADED_WIZARDS != "" :
5123  NOT_LOADED_WIZARDS += "\n"
5124  NOT_LOADED_WIZARDS += 'Skip subdir ' + fullPath
5125 
5126 
5127 def LoadPlugins(bundlepath=None):
5128  """
5129  Initialise Scripting/Plugin python environment and load plugins.
5130 
5131  Arguments:
5132  scriptpath -- The path to the bundled scripts.
5133  The bunbled Plugins are relative to this path, in the
5134  "plugins" subdirectory.
5135 
5136  NOTE: These are all of the possible "default" search paths for kicad
5137  python scripts. These paths will ONLY be added to the python
5138  search path ONLY IF they already exist.
5139 
5140  The Scripts bundled with the KiCad installation:
5141  <bundlepath>/
5142  <bundlepath>/plugins/
5143 
5144  The Scripts relative to the KiCad search path environment variable:
5145  [KICAD_PATH]/scripting/
5146  [KICAD_PATH]/scripting/plugins/
5147 
5148  The Scripts relative to the KiCad Users configuration:
5149  <kicad_config_path>/scripting/
5150  <kicad_config_path>/scripting/plugins/
5151 
5152  And on Linux ONLY, extra paths relative to the users home directory:
5153  ~/.kicad_plugins/
5154  ~/.kicad/scripting/
5155  ~/.kicad/scripting/plugins/
5156  """
5157  import os
5158  import sys
5159  import traceback
5160  import pcbnew
5161 
5162  kicad_path = os.environ.get('KICAD_PATH')
5163  config_path = pcbnew.GetKicadConfigPath()
5164  plugin_directories=[]
5165 
5166  if bundlepath:
5167  plugin_directories.append(bundlepath)
5168  plugin_directories.append(os.path.join(bundlepath, 'plugins'))
5169 
5170  if kicad_path:
5171  plugin_directories.append(os.path.join(kicad_path, 'scripting'))
5172  plugin_directories.append(os.path.join(kicad_path, 'scripting', 'plugins'))
5173 
5174  if config_path:
5175  plugin_directories.append(os.path.join(config_path, 'scripting'))
5176  plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))
5177 
5178  if sys.platform.startswith('linux'):
5179  plugin_directories.append(os.path.join(os.environ['HOME'],'.kicad_plugins'))
5180  plugin_directories.append(os.path.join(os.environ['HOME'],'.kicad','scripting'))
5181  plugin_directories.append(os.path.join(os.environ['HOME'],'.kicad','scripting','plugins'))
5182 
5183  global PLUGIN_DIRECTORIES_SEARCH
5184  PLUGIN_DIRECTORIES_SEARCH=""
5185  for plugins_dir in plugin_directories: # save search path list for later use
5186  if PLUGIN_DIRECTORIES_SEARCH != "" :
5187  PLUGIN_DIRECTORIES_SEARCH += "\n"
5188  PLUGIN_DIRECTORIES_SEARCH += plugins_dir
5189 
5190  global FULL_BACK_TRACE
5191  FULL_BACK_TRACE="" # clear any existing trace
5192 
5193  global NOT_LOADED_WIZARDS
5194  NOT_LOADED_WIZARDS = "" # save not loaded wizards names list for later use
5195 
5196  global KICAD_PLUGINS
5197 
5198  for plugins_dir in plugin_directories:
5199  if not os.path.isdir(plugins_dir):
5200  continue
5201 
5202  sys.path.append(plugins_dir)
5203 
5204  for module in os.listdir(plugins_dir):
5205  if os.path.isdir(os.path.join(plugins_dir,module)):
5206  LoadOneSubdirPlugin(plugins_dir, module)
5207  continue
5208 
5209  if module == '__init__.py' or module[-3:] != '.py':
5210  continue
5211 
5212  LoadOnePlugin(plugins_dir, module);
5213 
5214 
5216  def __init__(self):
5217  pass
5218 
5219  def register(self):
5220  if isinstance(self,FilePlugin):
5221  pass # register to file plugins in C++
5222 
5223  if isinstance(self,FootprintWizardPlugin):
5224  PYTHON_FOOTPRINT_WIZARDS.register_wizard(self)
5225  return
5226 
5227  if isinstance(self,ActionPlugin):
5228  PYTHON_ACTION_PLUGINS.register_action(self)
5229  return
5230 
5231  return
5232 
5233  def deregister(self):
5234  if isinstance(self,FilePlugin):
5235  pass # deregister to file plugins in C++
5236 
5237  if isinstance(self,FootprintWizardPlugin):
5238  PYTHON_FOOTPRINT_WIZARDS.deregister_wizard(self)
5239  return
5240 
5241  if isinstance(self,ActionPlugin):
5242  PYTHON_ACTION_PLUGINS.deregister_action(self)
5243  return
5244 
5245  return
5246 
5247 
5249  def __init__(self):
5250  KiCadPlugin.__init__(self)
5251 
5252 
5253 from math import ceil, floor, sqrt
5254 
5255 uMM = "mm" # Millimetres
5256 uMils = "mils" # Mils
5257 uFloat = "float" # Natural number units (dimensionless)
5258 uInteger = "integer" # Integer (no decimals, numeric, dimensionless)
5259 uBool = "bool" # Boolean value
5260 uRadians = "radians" # Angular units (radians)
5261 uDegrees = "degrees" # Angular units (degrees)
5262 uPercent = "%" # Percent (0% -> 100%)
5263 uString = "string" # Raw string
5264 
5265 uNumeric = [uMM, uMils, uFloat, uInteger, uDegrees, uRadians, uPercent] # List of numeric types
5266 uUnits = [uMM, uMils, uFloat, uInteger, uBool, uDegrees, uRadians, uPercent, uString] # List of allowable types
5267 
5269  _true = ['true','t','y','yes','on','1',1,]
5270  _false = ['false','f','n','no','off','0',0,'',None]
5271 
5272  _bools = _true + _false
5273 
5274  def __init__(self, page, name, units, default, **kwarg):
5275  self.page = page
5276  self.name = name
5277  self.hint = kwarg.get('hint','') # Parameter hint (shown as mouse-over text)
5278  self.designator = kwarg.get('designator',' ') # Parameter designator such as "e, D, p" (etc)
5279 
5280  if units.lower() in uUnits:
5281  self.units = units.lower()
5282  elif units.lower() == 'percent':
5283  self.units = uPercent
5284  elif type(units) in [list, tuple]: # Convert a list of options into a single string
5285  self.units = ",".join([str(el).strip() for el in units])
5286  else:
5287  self.units = units
5288 
5289  self.multiple = int(kwarg.get('multiple',1)) # Check integer values are multiples of this number
5290  self.min_value = kwarg.get('min_value',None) # Check numeric values are above or equal to this number
5291  self.max_value = kwarg.get('max_value',None) # Check numeric values are below or equal to this number
5292 
5293  self.SetValue(default)
5294  self.default = self.raw_value # Save value as default
5295 
5296  def ClearErrors(self):
5297  self.error_list = []
5298 
5299  def AddError(self, err, info=None):
5300 
5301  if err in self.error_list: # prevent duplicate error messages
5302  return
5303  if info is not None:
5304  err = err + " (" + str(info) + ")"
5305 
5306  self.error_list.append(err)
5307 
5308  def Check(self, min_value=None, max_value=None, multiple=None, info=None):
5309 
5310  if min_value is None:
5311  min_value = self.min_value
5312  if max_value is None:
5313  max_value = self.max_value
5314  if multiple is None:
5315  multiple = self.multiple
5316 
5317  if self.units not in uUnits and ',' not in self.units: # Allow either valid units or a list of strings
5318  self.AddError("type '{t}' unknown".format(t=self.units),info)
5319  self.AddError("Allowable types: " + str(self.units),info)
5320 
5321  if self.units in uNumeric:
5322  try:
5323  to_num = float(self.raw_value)
5324 
5325  if min_value is not None: # Check minimum value if it is present
5326  if to_num < min_value:
5327  self.AddError("value '{v}' is below minimum ({m})".format(v=self.raw_value,m=min_value),info)
5328 
5329  if max_value is not None: # Check maximum value if it is present
5330  if to_num > max_value:
5331  self.AddError("value '{v}' is above maximum ({m})".format(v=self.raw_value,m=max_value),info)
5332 
5333  except:
5334  self.AddError("value '{v}' is not of type '{t}'".format(v = self.raw_value, t=self.units),info)
5335 
5336  if self.units == uInteger: # Perform integer specific checks
5337  try:
5338  to_int = int(self.raw_value)
5339 
5340  if multiple is not None and multiple > 1:
5341  if (to_int % multiple) > 0:
5342  self.AddError("value '{v}' is not a multiple of {m}".format(v=self.raw_value,m=multiple),info)
5343  except:
5344  self.AddError("value {'v}' is not an integer".format(v=self.raw_value),info)
5345 
5346  if self.units == uBool: # Check that the value is of a correct boolean format
5347  if self.raw_value in [True,False] or str(self.raw_value).lower() in self._bools:
5348  pass
5349  else:
5350  self.AddError("value '{v}' is not a boolean value".format(v = self.raw_value),info)
5351 
5352  @property
5353  def value(self): # Return the current value, converted to appropriate units (from string representation) if required
5354  v = str(self.raw_value) # Enforce string type for known starting point
5355 
5356  if self.units == uInteger: # Integer values
5357  return int(v)
5358  elif self.units in uNumeric: # Any values that use floating points
5359  v = v.replace(",",".") # Replace "," separators with "."
5360  v = float(v)
5361 
5362  if self.units == uMM: # Convert from millimetres to nanometres
5363  return FromMM(v)
5364 
5365  elif self.units == uMils: # Convert from mils to nanometres
5366  return FromMils(v)
5367 
5368  else: # Any other floating-point values
5369  return v
5370 
5371  elif self.units == uBool:
5372  if v.lower() in self._true:
5373  return True
5374  else:
5375  return False
5376  else:
5377  return v
5378 
5379  def DefaultValue(self): # Reset the value of the parameter to its default
5380  self.raw_value = str(self.default)
5381 
5382  def SetValue(self, new_value): # Update the value
5383  new_value = str(new_value)
5384 
5385  if len(new_value.strip()) == 0:
5386  if not self.units in [uString, uBool]:
5387  return # Ignore empty values unless for strings or bools
5388 
5389  if self.units == uBool: # Enforce the same boolean representation as is used in KiCad
5390  new_value = "1" if new_value.lower() in self._true else "0"
5391  elif self.units in uNumeric:
5392  new_value = new_value.replace(",", ".") # Enforce decimal point separators
5393  elif ',' in self.units: # Select from a list of values
5394  if new_value not in self.units.split(','):
5395  new_value = self.units.split(',')[0]
5396 
5397  self.raw_value = new_value
5398 
5399  def __str__(self): # pretty-print the parameter
5400 
5401  s = self.name + ": " + str(self.raw_value)
5402 
5403  if self.units in [uMM, uMils, uPercent, uRadians, uDegrees]:
5404  s += self.units
5405  elif self.units == uBool: # Special case for Boolean values
5406  s = self.name + ": {b}".format(b = "True" if self.value else "False")
5407  elif self.units == uString:
5408  s = self.name + ": '" + self.raw_value + "'"
5409 
5410  return s
5411 
5412 
5414  def __init__(self):
5415  KiCadPlugin.__init__(self)
5416  self.defaults()
5417 
5418  def defaults(self):
5419  self.module = None
5420  self.params = [] # List of added parameters that observes addition order
5421 
5422  self.name = "KiCad FP Wizard"
5423  self.description = "Undefined Footprint Wizard plugin"
5424  self.image = ""
5425  self.buildmessages = ""
5426 
5427  def AddParam(self, page, name, unit, default, **kwarg):
5428 
5429  if self.GetParam(page,name) is not None: # Param already exists!
5430  return
5431 
5432  param = FootprintWizardParameter(page, name, unit, default, **kwarg) # Create a new parameter
5433  self.params.append(param)
5434 
5435  @property
5436  def parameters(self): # This is a helper function that returns a nested (unordered) dict of the VALUES of parameters
5437  pages = {} # Page dict
5438  for p in self.params:
5439  if p.page not in pages:
5440  pages[p.page] = {}
5441 
5442  pages[p.page][p.name] = p.value # Return the 'converted' value (convert from string to actual useful units)
5443 
5444  return pages
5445 
5446  @property
5447  def values(self): # Same as above
5448  return self.parameters
5449 
5450  def ResetWizard(self): # Reset all parameters to default values
5451  for p in self.params:
5452  p.DefaultValue()
5453 
5454  def GetName(self): # Return the name of this wizard
5455  return self.name
5456 
5457  def GetImage(self): # Return the filename of the preview image associated with this wizard
5458  return self.image
5459 
5460  def GetDescription(self): # Return the description text
5461  return self.description
5462 
5463  def GetValue(self):
5464  raise NotImplementedError
5465 
5467  return "REF" # Default reference prefix for any footprint
5468 
5469  def GetParam(self, page, name): # Grab a parameter
5470  for p in self.params:
5471  if p.page == page and p.name == name:
5472  return p
5473 
5474  return None
5475 
5476  def CheckParam(self, page, name, **kwarg):
5477  self.GetParam(page,name).Check(**kwarg)
5478 
5479  def AnyErrors(self):
5480  return any([len(p.error_list) > 0 for p in self.params])
5481 
5482  @property
5483  def pages(self): # Return an (ordered) list of the available page names
5484  page_list = []
5485  for p in self.params:
5486  if p.page not in page_list:
5487  page_list.append(p.page)
5488 
5489  return page_list
5490 
5491  def GetNumParameterPages(self): # Return the number of parameter pages
5492  return len(self.pages)
5493 
5494  def GetParameterPageName(self,page_n): # Return the name of a page at a given index
5495  return self.pages[page_n]
5496 
5497  def GetParametersByPageName(self, page_name): # Return a list of parameters on a given page
5498  params = []
5499 
5500  for p in self.params:
5501  if p.page == page_name:
5502  params.append(p)
5503 
5504  return params
5505 
5506  def GetParametersByPageIndex(self, page_index): # Return an ordered list of parameters on a given page
5507  return self.GetParametersByPageName(self.GetParameterPageName(page_index))
5508 
5509  def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
5510  params = self.GetParametersByPageIndex(page_index)
5511  return [p.designator for p in params]
5512 
5513  def GetParameterNames(self,page_index): # Return the list of names associated with a given page
5514  params = self.GetParametersByPageIndex(page_index)
5515  return [p.name for p in params]
5516 
5517  def GetParameterValues(self,page_index): # Return the list of values associated with a given page
5518  params = self.GetParametersByPageIndex(page_index)
5519  return [str(p.raw_value) for p in params]
5520 
5521  def GetParameterErrors(self,page_index): # Return list of errors associated with a given page
5522  params = self.GetParametersByPageIndex(page_index)
5523  return [str("\n".join(p.error_list)) for p in params]
5524 
5525  def GetParameterTypes(self, page_index): # Return list of units associated with a given page
5526  params = self.GetParametersByPageIndex(page_index)
5527  return [str(p.units) for p in params]
5528 
5529  def GetParameterHints(self, page_index): # Return a list of units associated with a given page
5530  params = self.GetParametersByPageIndex(page_index)
5531  return [str(p.hint) for p in params]
5532 
5533  def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
5534  params = self.GetParametersByPageIndex(page_index)
5535  return [str(p.designator) for p in params]
5536 
5537  def SetParameterValues(self, page_index, list_of_values): # Update values on a given page
5538 
5539  params = self.GetParametersByPageIndex(page_index)
5540 
5541  for i, param in enumerate(params):
5542  if i >= len(list_of_values):
5543  break
5544  param.SetValue(list_of_values[i])
5545 
5546  def GetFootprint( self ):
5547  self.BuildFootprint()
5548  return self.module
5549 
5550  def BuildFootprint(self):
5551  return
5552 
5553  def GetBuildMessages( self ):
5554  return self.buildmessages
5555 
5556  def Show(self):
5557  text = "Footprint Wizard Name: {name}\n".format(name=self.GetName())
5558  text += "Footprint Wizard Description: {desc}\n".format(desc=self.GetDescription())
5559 
5560  n_pages = self.GetNumParameterPages()
5561 
5562  text += "Pages: {n}\n".format(n=n_pages)
5563 
5564  for i in range(n_pages):
5565  name = self.GetParameterPageName(i)
5566 
5567  params = self.GetParametersByPageName(name)
5568 
5569  text += "{name}\n".format(name=name)
5570 
5571  for j in range(len(params)):
5572  text += ("\t{param}{err}\n".format(
5573  param = str(params[j]),
5574  err = ' *' if len(params[j].error_list) > 0 else ''
5575  ))
5576 
5577  if self.AnyErrors():
5578  text += " * Errors exist for these parameters"
5579 
5580  return text
5581 
5583  def __init__( self ):
5584  KiCadPlugin.__init__( self )
5585  self.defaults()
5586 
5587  def defaults( self ):
5588  self.name = "Undefined Action plugin"
5589  self.category = "Undefined"
5590  self.description = ""
5591 
5592  def GetName( self ):
5593  return self.name
5594 
5595  def GetCategoryName( self ):
5596  return self.category
5597 
5598  def GetDescription( self ):
5599  return self.description
5600 
5601  def Run(self):
5602  return
5603 
5604 
5605 class CSegment(_object):
5606  """C++ includes: PolyLine.h """
5607  __swig_setmethods__ = {}
5608  __setattr__ = lambda self, name, value: _swig_setattr(self, CSegment, name, value)
5609  __swig_getmethods__ = {}
5610  __getattr__ = lambda self, name: _swig_getattr(self, CSegment, name)
5611  __repr__ = _swig_repr
5612  __swig_setmethods__["m_Start"] = _pcbnew.CSegment_m_Start_set
5613  __swig_getmethods__["m_Start"] = _pcbnew.CSegment_m_Start_get
5614  if _newclass:
5615  m_Start = _swig_property(_pcbnew.CSegment_m_Start_get, _pcbnew.CSegment_m_Start_set)
5616  __swig_setmethods__["m_End"] = _pcbnew.CSegment_m_End_set
5617  __swig_getmethods__["m_End"] = _pcbnew.CSegment_m_End_get
5618  if _newclass:
5619  m_End = _swig_property(_pcbnew.CSegment_m_End_get, _pcbnew.CSegment_m_End_set)
5620 
5621  def __init__(self, *args):
5622  """
5623  __init__(CSegment self) -> CSegment
5624  __init__(CSegment self, wxPoint aStart, wxPoint aEnd) -> CSegment
5625  __init__(CSegment self, int x0, int y0, int x1, int y1) -> CSegment
5626 
5627  CSegment::CSegment(int x0,
5628  int y0, int x1, int y1)
5629  """
5630  this = _pcbnew.new_CSegment(*args)
5631  try:
5632  self.this.append(this)
5633  except:
5634  self.this = this
5635  __swig_destroy__ = _pcbnew.delete_CSegment
5636  __del__ = lambda self: None
5637 CSegment_swigregister = _pcbnew.CSegment_swigregister
5638 CSegment_swigregister(CSegment)
5639 
5641  """C++ includes: PolyLine.h """
5642  __swig_setmethods__ = {}
5643  for _s in [wxPoint]:
5644  __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
5645  __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyPt, name, value)
5646  __swig_getmethods__ = {}
5647  for _s in [wxPoint]:
5648  __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
5649  __getattr__ = lambda self, name: _swig_getattr(self, CPolyPt, name)
5650  __repr__ = _swig_repr
5651 
5652  def __init__(self, *args):
5653  """
5654  __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False, int aUtility=0) -> CPolyPt
5655  __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False) -> CPolyPt
5656  __init__(CPolyPt self, int aX=0, int aY=0) -> CPolyPt
5657  __init__(CPolyPt self, int aX=0) -> CPolyPt
5658  __init__(CPolyPt self) -> CPolyPt
5659  __init__(CPolyPt self, CPolyPt aPt) -> CPolyPt
5660  __init__(CPolyPt self, wxPoint aPoint) -> CPolyPt
5661 
5662  CPolyPt::CPolyPt(const
5663  wxPoint &aPoint)
5664  """
5665  this = _pcbnew.new_CPolyPt(*args)
5666  try:
5667  self.this.append(this)
5668  except:
5669  self.this = this
5670  __swig_setmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_set
5671  __swig_getmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_get
5672  if _newclass:
5673  end_contour = _swig_property(_pcbnew.CPolyPt_end_contour_get, _pcbnew.CPolyPt_end_contour_set)
5674  __swig_setmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_set
5675  __swig_getmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_get
5676  if _newclass:
5677  m_flags = _swig_property(_pcbnew.CPolyPt_m_flags_get, _pcbnew.CPolyPt_m_flags_set)
5678 
5679  def __eq__(self, cpt2):
5680  """__eq__(CPolyPt self, CPolyPt cpt2) -> bool"""
5681  return _pcbnew.CPolyPt___eq__(self, cpt2)
5682 
5683 
5684  def __ne__(self, cpt2):
5685  """__ne__(CPolyPt self, CPolyPt cpt2) -> bool"""
5686  return _pcbnew.CPolyPt___ne__(self, cpt2)
5687 
5688  __swig_destroy__ = _pcbnew.delete_CPolyPt
5689  __del__ = lambda self: None
5690 CPolyPt_swigregister = _pcbnew.CPolyPt_swigregister
5691 CPolyPt_swigregister(CPolyPt)
5692 
5694  """C++ includes: PolyLine.h """
5695  __swig_setmethods__ = {}
5696  __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyLine, name, value)
5697  __swig_getmethods__ = {}
5698  __getattr__ = lambda self, name: _swig_getattr(self, CPolyLine, name)
5699  __repr__ = _swig_repr
5700  NO_HATCH = _pcbnew.CPolyLine_NO_HATCH
5701  DIAGONAL_FULL = _pcbnew.CPolyLine_DIAGONAL_FULL
5702  DIAGONAL_EDGE = _pcbnew.CPolyLine_DIAGONAL_EDGE
5703 
5704  def __init__(self, *args):
5705  """
5706  __init__(CPolyLine self) -> CPolyLine
5707  __init__(CPolyLine self, CPolyLine aCPolyLine) -> CPolyLine
5708 
5709  CPolyLine::CPolyLine(const CPolyLine &aCPolyLine)
5710  """
5711  this = _pcbnew.new_CPolyLine(*args)
5712  try:
5713  self.this.append(this)
5714  except:
5715  self.this = this
5716  __swig_destroy__ = _pcbnew.delete_CPolyLine
5717  __del__ = lambda self: None
5718 
5719  def ImportSettings(self, aPoly):
5720  """
5721  ImportSettings(CPolyLine self, CPolyLine aPoly)
5722 
5723  void
5724  CPolyLine::ImportSettings(const CPolyLine *aPoly)
5725 
5726  Function ImportSettings Copy settings (layer, hatch styles) from
5727  aPoly.
5728 
5729  Parameters:
5730  -----------
5731 
5732  aPoly: is the CPolyLine to import settings
5733  """
5734  return _pcbnew.CPolyLine_ImportSettings(self, aPoly)
5735 
5736 
5737  def Start(self, layer, x, y, hatch):
5738  """
5739  Start(CPolyLine self, LAYER_NUM layer, int x, int y, int hatch)
5740 
5741  void
5742  CPolyLine::Start(LAYER_NUM layer, int x, int y, int hatch)
5743  """
5744  return _pcbnew.CPolyLine_Start(self, layer, x, y, hatch)
5745 
5746 
5747  def AppendCorner(self, x, y):
5748  """
5749  AppendCorner(CPolyLine self, int x, int y)
5750 
5751  void
5752  CPolyLine::AppendCorner(int x, int y)
5753  """
5754  return _pcbnew.CPolyLine_AppendCorner(self, x, y)
5755 
5756 
5757  def InsertCorner(self, ic, x, y):
5758  """
5759  InsertCorner(CPolyLine self, int ic, int x, int y)
5760 
5761  void
5762  CPolyLine::InsertCorner(int ic, int x, int y)
5763 
5764  Function InsertCorner insert a new corner between two existing
5765  corners.
5766 
5767  Parameters:
5768  -----------
5769 
5770  ic: = index for the insertion point: the corner is inserted AFTER ic
5771 
5772  x: y: = coordinates corner to insert
5773  """
5774  return _pcbnew.CPolyLine_InsertCorner(self, ic, x, y)
5775 
5776 
5777  def DeleteCorner(self, ic):
5778  """
5779  DeleteCorner(CPolyLine self, int ic)
5780 
5781  void
5782  CPolyLine::DeleteCorner(int ic)
5783 
5784  Function DeleteCorner remove the given corner.
5785 
5786  if it is the last point of a contour keep the controur closed by
5787  modifying the previous corner
5788 
5789  Parameters:
5790  -----------
5791 
5792  ic: = the index of the corner to delete
5793  """
5794  return _pcbnew.CPolyLine_DeleteCorner(self, ic)
5795 
5796 
5797  def MoveCorner(self, ic, x, y):
5798  """
5799  MoveCorner(CPolyLine self, int ic, int x, int y)
5800 
5801  void
5802  CPolyLine::MoveCorner(int ic, int x, int y)
5803  """
5804  return _pcbnew.CPolyLine_MoveCorner(self, ic, x, y)
5805 
5806 
5807  def CloseLastContour(self):
5808  """
5809  CloseLastContour(CPolyLine self)
5810 
5811  void
5812  CPolyLine::CloseLastContour()
5813 
5814  function CloseLastContour Set the .end_contour member of the last
5815  corner of the last contour to true
5816  """
5817  return _pcbnew.CPolyLine_CloseLastContour(self)
5818 
5819 
5820  def RemoveContour(self, icont):
5821  """
5822  RemoveContour(CPolyLine self, int icont)
5823 
5824  void
5825  CPolyLine::RemoveContour(int icont)
5826 
5827  Function RemoveContour.
5828 
5829  Parameters:
5830  -----------
5831 
5832  icont: = contour number to remove remove a contour only if there is
5833  more than 1 contour
5834  """
5835  return _pcbnew.CPolyLine_RemoveContour(self, icont)
5836 
5837 
5839  """
5840  IsPolygonSelfIntersecting(CPolyLine self) -> bool
5841 
5842  bool
5843  CPolyLine::IsPolygonSelfIntersecting()
5844 
5845  Function IsPolygonSelfIntersecting Test a CPolyLine for self-
5846  intersection of vertex (all contours).
5847 
5848  : false if no intersecting sides true if intersecting sides When a
5849  CPolyLine is self intersectic, it need to be normalized. (converted to
5850  non intersecting polygons)
5851  """
5852  return _pcbnew.CPolyLine_IsPolygonSelfIntersecting(self)
5853 
5854 
5855  def Chamfer(self, aDistance):
5856  """
5857  Chamfer(CPolyLine self, unsigned int aDistance) -> CPolyLine
5858 
5859  CPolyLine *
5860  CPolyLine::Chamfer(unsigned int aDistance)
5861 
5862  Function Chamfer returns a chamfered version of a polygon.
5863 
5864  Parameters:
5865  -----------
5866 
5867  aDistance: is the chamfering distance.
5868 
5869  CPolyLine* - Pointer to new polygon.
5870  """
5871  return _pcbnew.CPolyLine_Chamfer(self, aDistance)
5872 
5873 
5874  def Fillet(self, aRadius, aSegments):
5875  """
5876  Fillet(CPolyLine self, unsigned int aRadius, unsigned int aSegments) -> CPolyLine
5877 
5878  CPolyLine *
5879  CPolyLine::Fillet(unsigned int aRadius, unsigned int aSegments)
5880 
5881  Function Fillet returns a filleted version of a polygon.
5882 
5883  Parameters:
5884  -----------
5885 
5886  aRadius: is the fillet radius.
5887 
5888  aSegments: is the number of segments / fillet.
5889 
5890  CPolyLine* - Pointer to new polygon.
5891  """
5892  return _pcbnew.CPolyLine_Fillet(self, aRadius, aSegments)
5893 
5894 
5896  """
5897  RemoveNullSegments(CPolyLine self) -> int
5898 
5899  int
5900  CPolyLine::RemoveNullSegments()
5901 
5902  Function RemoveNullSegments Removes corners which create a null
5903  segment edge (i.e.
5904 
5905  when 2 successive corners are at the same location) the count of
5906  removed corners.
5907  """
5908  return _pcbnew.CPolyLine_RemoveNullSegments(self)
5909 
5910 
5912  """
5913  RemoveAllContours(CPolyLine self)
5914 
5915  void
5916  CPolyLine::RemoveAllContours(void)
5917 
5918  function RemoveAllContours removes all corners from the list.
5919 
5920  Others params are not changed
5921  """
5922  return _pcbnew.CPolyLine_RemoveAllContours(self)
5923 
5924 
5925  def UnHatch(self):
5926  """
5927  UnHatch(CPolyLine self)
5928 
5929  void CPolyLine::UnHatch()
5930 
5931  """
5932  return _pcbnew.CPolyLine_UnHatch(self)
5933 
5934 
5935  def Hatch(self):
5936  """
5937  Hatch(CPolyLine self)
5938 
5939  void CPolyLine::Hatch()
5940  """
5941  return _pcbnew.CPolyLine_Hatch(self)
5942 
5943 
5944  def MoveOrigin(self, x_off, y_off):
5945  """
5946  MoveOrigin(CPolyLine self, int x_off, int y_off)
5947 
5948  void
5949  CPolyLine::MoveOrigin(int x_off, int y_off)
5950  """
5951  return _pcbnew.CPolyLine_MoveOrigin(self, x_off, y_off)
5952 
5953 
5954  def GetBoundingBox(self, *args):
5955  """
5956  GetBoundingBox(CPolyLine self) -> EDA_RECT
5957  GetBoundingBox(CPolyLine self, int icont) -> EDA_RECT
5958 
5959  const EDA_RECT
5960  CPolyLine::GetBoundingBox(int icont)
5961 
5962  the bounding box of a given polygon
5963 
5964  Parameters:
5965  -----------
5966 
5967  icont: = the index of the polygon contour (0 = main contour, 1 ... n
5968  = other contours, usually holes)
5969  """
5970  return _pcbnew.CPolyLine_GetBoundingBox(self, *args)
5971 
5972 
5973  def Copy(self, src):
5974  """
5975  Copy(CPolyLine self, CPolyLine src)
5976 
5977  void CPolyLine::Copy(const
5978  CPolyLine *src)
5979  """
5980  return _pcbnew.CPolyLine_Copy(self, src)
5981 
5982 
5983  def TestPointInside(self, x, y):
5984  """
5985  TestPointInside(CPolyLine self, int x, int y) -> bool
5986 
5987  bool
5988  CPolyLine::TestPointInside(int x, int y)
5989  """
5990  return _pcbnew.CPolyLine_TestPointInside(self, x, y)
5991 
5992 
5993  def IsCutoutContour(self, aCornerIdx):
5994  """
5995  IsCutoutContour(CPolyLine self, int aCornerIdx) -> bool
5996 
5997  bool
5998  CPolyLine::IsCutoutContour(int aCornerIdx)
5999 
6000  true if the corner aCornerIdx is on a hole inside the main outline and
6001  false if it is on the main outline
6002  """
6003  return _pcbnew.CPolyLine_IsCutoutContour(self, aCornerIdx)
6004 
6005 
6006  def AppendArc(self, xi, yi, xf, yf, xc, yc, num):
6007  """
6008  AppendArc(CPolyLine self, int xi, int yi, int xf, int yf, int xc, int yc, int num)
6009 
6010  void
6011  CPolyLine::AppendArc(int xi, int yi, int xf, int yf, int xc, int yc,
6012  int num)
6013 
6014  Function AppendArc.
6015 
6016  Adds segments to current contour to approximate the given arc
6017  """
6018  return _pcbnew.CPolyLine_AppendArc(self, xi, yi, xf, yf, xc, yc, num)
6019 
6020 
6021  def SetLayer(self, aLayer):
6022  """
6023  SetLayer(CPolyLine self, LAYER_NUM aLayer)
6024 
6025  void
6026  CPolyLine::SetLayer(LAYER_NUM aLayer)
6027  """
6028  return _pcbnew.CPolyLine_SetLayer(self, aLayer)
6029 
6030 
6031  def GetLayer(self):
6032  """
6033  GetLayer(CPolyLine self) -> LAYER_NUM
6034 
6035  LAYER_NUM
6036  CPolyLine::GetLayer() const
6037  """
6038  return _pcbnew.CPolyLine_GetLayer(self)
6039 
6040 
6041  def GetCornersCount(self):
6042  """
6043  GetCornersCount(CPolyLine self) -> int
6044 
6045  int
6046  CPolyLine::GetCornersCount() const
6047  """
6048  return _pcbnew.CPolyLine_GetCornersCount(self)
6049 
6050 
6051  def GetClosed(self):
6052  """
6053  GetClosed(CPolyLine self) -> bool
6054 
6055  bool
6056  CPolyLine::GetClosed()
6057 
6058  true if the last corner in corners list is flagged end_contour
6059  """
6060  return _pcbnew.CPolyLine_GetClosed(self)
6061 
6062 
6063  def GetContoursCount(self):
6064  """
6065  GetContoursCount(CPolyLine self) -> int
6066 
6067  int
6068  CPolyLine::GetContoursCount() const
6069 
6070  Function GetContoursCount.
6071 
6072  the number of polygons stored in list (number of corners flagged
6073  "end_contour"
6074  """
6075  return _pcbnew.CPolyLine_GetContoursCount(self)
6076 
6077 
6078  def GetContour(self, ic):
6079  """
6080  GetContour(CPolyLine self, int ic) -> int
6081 
6082  int
6083  CPolyLine::GetContour(int ic)
6084 
6085  Function GetContour.
6086 
6087  the contour number containing the corner ic
6088 
6089  Parameters:
6090  -----------
6091 
6092  ic: = the index of the corner in the corner list
6093  """
6094  return _pcbnew.CPolyLine_GetContour(self, ic)
6095 
6096 
6097  def GetContourStart(self, icont):
6098  """
6099  GetContourStart(CPolyLine self, int icont) -> int
6100 
6101  int
6102  CPolyLine::GetContourStart(int icont)
6103 
6104  Function GetContourStart.
6105 
6106  the index of the first corner (in corners list) of a contour
6107 
6108  Parameters:
6109  -----------
6110 
6111  icont: = the index of the contour
6112  """
6113  return _pcbnew.CPolyLine_GetContourStart(self, icont)
6114 
6115 
6116  def GetContourEnd(self, icont):
6117  """
6118  GetContourEnd(CPolyLine self, int icont) -> int
6119 
6120  int
6121  CPolyLine::GetContourEnd(int icont)
6122 
6123  Function GetContourEnd.
6124 
6125  the index of the last corner (in corners list) of a contour
6126 
6127  Parameters:
6128  -----------
6129 
6130  icont: = the index of the contour
6131  """
6132  return _pcbnew.CPolyLine_GetContourEnd(self, icont)
6133 
6134 
6135  def GetContourSize(self, icont):
6136  """
6137  GetContourSize(CPolyLine self, int icont) -> int
6138 
6139  int
6140  CPolyLine::GetContourSize(int icont)
6141 
6142  Function GetContourSize.
6143 
6144  the corners count of a contour
6145 
6146  Parameters:
6147  -----------
6148 
6149  icont: = the index of the contour
6150  """
6151  return _pcbnew.CPolyLine_GetContourSize(self, icont)
6152 
6153 
6154  def GetX(self, ic):
6155  """
6156  GetX(CPolyLine self, int ic) -> int
6157 
6158  int CPolyLine::GetX(int ic)
6159  const
6160  """
6161  return _pcbnew.CPolyLine_GetX(self, ic)
6162 
6163 
6164  def GetY(self, ic):
6165  """
6166  GetY(CPolyLine self, int ic) -> int
6167 
6168  int CPolyLine::GetY(int ic)
6169  const
6170  """
6171  return _pcbnew.CPolyLine_GetY(self, ic)
6172 
6173