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