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, time_t aNewTimeStamp)
1515 
1516  void
1517  EDA_ITEM::SetTimeStamp(time_t aNewTimeStamp)
1518  """
1519  return _pcbnew.EDA_ITEM_SetTimeStamp(self, aNewTimeStamp)
1520 
1521 
1522  def GetTimeStamp(self):
1523  """
1524  GetTimeStamp(EDA_ITEM self) -> time_t
1525 
1526  time_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() -> time_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 ToU32(self):
3152  """ToU32(COLOR4D self) -> unsigned int"""
3153  return _pcbnew.COLOR4D_ToU32(self)
3154 
3155 
3156  def FromU32(self, aPackedColor):
3157  """FromU32(COLOR4D self, unsigned int aPackedColor)"""
3158  return _pcbnew.COLOR4D_FromU32(self, aPackedColor)
3159 
3160 
3162  """GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
3163  return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
3164 
3165  if _newclass:
3166  GetNearestLegacyColor = staticmethod(GetNearestLegacyColor)
3167  __swig_getmethods__["GetNearestLegacyColor"] = lambda x: GetNearestLegacyColor
3168 
3169  def Brighten(self, aFactor):
3170  """Brighten(COLOR4D self, double aFactor) -> COLOR4D"""
3171  return _pcbnew.COLOR4D_Brighten(self, aFactor)
3172 
3173 
3174  def Darken(self, aFactor):
3175  """Darken(COLOR4D self, double aFactor) -> COLOR4D"""
3176  return _pcbnew.COLOR4D_Darken(self, aFactor)
3177 
3178 
3179  def Invert(self):
3180  """Invert(COLOR4D self) -> COLOR4D"""
3181  return _pcbnew.COLOR4D_Invert(self)
3182 
3183 
3184  def Saturate(self, aFactor):
3185  """Saturate(COLOR4D self, double aFactor) -> COLOR4D"""
3186  return _pcbnew.COLOR4D_Saturate(self, aFactor)
3187 
3188 
3189  def Brightened(self, aFactor):
3190  """Brightened(COLOR4D self, double aFactor) -> COLOR4D"""
3191  return _pcbnew.COLOR4D_Brightened(self, aFactor)
3192 
3193 
3194  def Darkened(self, aFactor):
3195  """Darkened(COLOR4D self, double aFactor) -> COLOR4D"""
3196  return _pcbnew.COLOR4D_Darkened(self, aFactor)
3197 
3198 
3199  def WithAlpha(self, aAlpha):
3200  """WithAlpha(COLOR4D self, double aAlpha) -> COLOR4D"""
3201  return _pcbnew.COLOR4D_WithAlpha(self, aAlpha)
3202 
3203 
3204  def Inverted(self):
3205  """Inverted(COLOR4D self) -> COLOR4D"""
3206  return _pcbnew.COLOR4D_Inverted(self)
3207 
3208 
3209  def GetBrightness(self):
3210  """GetBrightness(COLOR4D self) -> double"""
3211  return _pcbnew.COLOR4D_GetBrightness(self)
3212 
3213 
3214  def ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue=False):
3215  """
3216  ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue, bool aAlwaysDefineHue=False)
3217  ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue)
3218  """
3219  return _pcbnew.COLOR4D_ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue)
3220 
3221 
3222  def FromHSV(self, aInH, aInS, aInV):
3223  """FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
3224  return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)
3225 
3226  __swig_setmethods__["r"] = _pcbnew.COLOR4D_r_set
3227  __swig_getmethods__["r"] = _pcbnew.COLOR4D_r_get
3228  if _newclass:
3229  r = _swig_property(_pcbnew.COLOR4D_r_get, _pcbnew.COLOR4D_r_set)
3230  __swig_setmethods__["g"] = _pcbnew.COLOR4D_g_set
3231  __swig_getmethods__["g"] = _pcbnew.COLOR4D_g_get
3232  if _newclass:
3233  g = _swig_property(_pcbnew.COLOR4D_g_get, _pcbnew.COLOR4D_g_set)
3234  __swig_setmethods__["b"] = _pcbnew.COLOR4D_b_set
3235  __swig_getmethods__["b"] = _pcbnew.COLOR4D_b_get
3236  if _newclass:
3237  b = _swig_property(_pcbnew.COLOR4D_b_get, _pcbnew.COLOR4D_b_set)
3238  __swig_setmethods__["a"] = _pcbnew.COLOR4D_a_set
3239  __swig_getmethods__["a"] = _pcbnew.COLOR4D_a_get
3240  if _newclass:
3241  a = _swig_property(_pcbnew.COLOR4D_a_get, _pcbnew.COLOR4D_a_set)
3242  __swig_destroy__ = _pcbnew.delete_COLOR4D
3243  __del__ = lambda self: None
3244 COLOR4D_swigregister = _pcbnew.COLOR4D_swigregister
3245 COLOR4D_swigregister(COLOR4D)
3246 
3248  """COLOR4D_GetNearestLegacyColor(COLOR4D aColor) -> EDA_COLOR_T"""
3249  return _pcbnew.COLOR4D_GetNearestLegacyColor(aColor)
3250 COLOR4D.UNSPECIFIED = _pcbnew.cvar.COLOR4D_UNSPECIFIED
3251 COLOR4D.WHITE = _pcbnew.cvar.COLOR4D_WHITE
3252 COLOR4D.BLACK = _pcbnew.cvar.COLOR4D_BLACK
3253 
3254 
3255 def __eq__(lhs, rhs):
3256  """__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
3257  return _pcbnew.__eq__(lhs, rhs)
3258 
3259 def __ne__(lhs, rhs):
3260  """__ne__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
3261  return _pcbnew.__ne__(lhs, rhs)
3262 
3263 def __lshift__(aStream, aColor):
3264  """__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
3265  return _pcbnew.__lshift__(aStream, aColor)
3267  """
3268 
3269 
3270  Class COLORS_DESIGN_SETTINGS is a list of color settings for designs
3271  in Pcbnew.
3272 
3273  C++ includes: class_colors_design_settings.h
3274  """
3275  __swig_setmethods__ = {}
3276  __setattr__ = lambda self, name, value: _swig_setattr(self, COLORS_DESIGN_SETTINGS, name, value)
3277  __swig_getmethods__ = {}
3278  __getattr__ = lambda self, name: _swig_getattr(self, COLORS_DESIGN_SETTINGS, name)
3279  __repr__ = _swig_repr
3280  __swig_setmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set
3281  __swig_getmethods__["m_LayersColors"] = _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get
3282  if _newclass:
3283  m_LayersColors = _swig_property(_pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_get, _pcbnew.COLORS_DESIGN_SETTINGS_m_LayersColors_set)
3284 
3285  def __init__(self, aFrameType):
3286  """
3287  __init__(COLORS_DESIGN_SETTINGS self, FRAME_T aFrameType) -> COLORS_DESIGN_SETTINGS
3288 
3289  COLORS_DESIGN_SETTINGS::COLORS_DESIGN_SETTINGS(FRAME_T aFrameType)
3290 
3291  """
3292  this = _pcbnew.new_COLORS_DESIGN_SETTINGS(aFrameType)
3293  try:
3294  self.this.append(this)
3295  except:
3296  self.this = this
3297  __swig_destroy__ = _pcbnew.delete_COLORS_DESIGN_SETTINGS
3298  __del__ = lambda self: None
3299 
3300  def Load(self, aConfig):
3301  """
3302  Load(COLORS_DESIGN_SETTINGS self, wxConfigBase * aConfig)
3303 
3304  void
3305  COLORS_DESIGN_SETTINGS::Load(wxConfigBase *aConfig) override
3306  """
3307  return _pcbnew.COLORS_DESIGN_SETTINGS_Load(self, aConfig)
3308 
3309 
3310  def Save(self, aConfig):
3311  """
3312  Save(COLORS_DESIGN_SETTINGS self, wxConfigBase * aConfig)
3313 
3314  void
3315  COLORS_DESIGN_SETTINGS::Save(wxConfigBase *aConfig) override
3316  """
3317  return _pcbnew.COLORS_DESIGN_SETTINGS_Save(self, aConfig)
3318 
3319 
3320  def GetLayerColor(self, aLayer):
3321  """
3322  GetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer) -> COLOR4D
3323 
3324  COLOR4D
3325  COLORS_DESIGN_SETTINGS::GetLayerColor(LAYER_NUM aLayer) const
3326 
3327  Function GetLayerColor.
3328 
3329  the color for aLayer which is one of the layer indices given in
3330  pcbstruct.h or in schematic
3331  """
3332  return _pcbnew.COLORS_DESIGN_SETTINGS_GetLayerColor(self, aLayer)
3333 
3334 
3335  def SetLayerColor(self, aLayer, aColor):
3336  """
3337  SetLayerColor(COLORS_DESIGN_SETTINGS self, LAYER_NUM aLayer, COLOR4D aColor)
3338 
3339  void
3340  COLORS_DESIGN_SETTINGS::SetLayerColor(LAYER_NUM aLayer, COLOR4D
3341  aColor)
3342 
3343  Function SetLayerColor sets the color for aLayer which is one of the
3344  layer indices given in pcbstruct.h or in schematic.
3345  """
3346  return _pcbnew.COLORS_DESIGN_SETTINGS_SetLayerColor(self, aLayer, aColor)
3347 
3348 
3349  def GetItemColor(self, aItemIdx):
3350  """
3351  GetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx) -> COLOR4D
3352 
3353  COLOR4D
3354  COLORS_DESIGN_SETTINGS::GetItemColor(int aItemIdx) const
3355 
3356  Function GetItemColor.
3357 
3358  the color for an item which is one of the item indices given in enum
3359  PCB_LAYER_ID
3360  """
3361  return _pcbnew.COLORS_DESIGN_SETTINGS_GetItemColor(self, aItemIdx)
3362 
3363 
3364  def SetItemColor(self, aItemIdx, aColor):
3365  """
3366  SetItemColor(COLORS_DESIGN_SETTINGS self, int aItemIdx, COLOR4D aColor)
3367 
3368  void
3369  COLORS_DESIGN_SETTINGS::SetItemColor(int aItemIdx, COLOR4D aColor)
3370 
3371  Function SetItemColor sets the color for an item which is one of the
3372  item indices given in enum PCB_LAYER_ID.
3373  """
3374  return _pcbnew.COLORS_DESIGN_SETTINGS_SetItemColor(self, aItemIdx, aColor)
3375 
3376 
3377  def SetAllColorsAs(self, aColor):
3378  """
3379  SetAllColorsAs(COLORS_DESIGN_SETTINGS self, COLOR4D aColor)
3380 
3381  void
3382  COLORS_DESIGN_SETTINGS::SetAllColorsAs(COLOR4D aColor)
3383 
3384  Function SetAllColorsAs sets alls colors to aColor Usefull to create a
3385  monochrome color selection for printing purpose.
3386  """
3387  return _pcbnew.COLORS_DESIGN_SETTINGS_SetAllColorsAs(self, aColor)
3388 
3389 COLORS_DESIGN_SETTINGS_swigregister = _pcbnew.COLORS_DESIGN_SETTINGS_swigregister
3390 COLORS_DESIGN_SETTINGS_swigregister(COLORS_DESIGN_SETTINGS)
3391 
3393  """
3394  C++ includes: class_marker_base.h
3395 
3396  """
3397  __swig_setmethods__ = {}
3398  __setattr__ = lambda self, name, value: _swig_setattr(self, MARKER_BASE, name, value)
3399  __swig_getmethods__ = {}
3400  __getattr__ = lambda self, name: _swig_getattr(self, MARKER_BASE, name)
3401  __repr__ = _swig_repr
3402  MARKER_UNSPEC = _pcbnew.MARKER_BASE_MARKER_UNSPEC
3403  MARKER_ERC = _pcbnew.MARKER_BASE_MARKER_ERC
3404  MARKER_PCB = _pcbnew.MARKER_BASE_MARKER_PCB
3405  MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
3406  MARKER_SEVERITY_UNSPEC = _pcbnew.MARKER_BASE_MARKER_SEVERITY_UNSPEC
3407  MARKER_SEVERITY_INFO = _pcbnew.MARKER_BASE_MARKER_SEVERITY_INFO
3408  MARKER_SEVERITY_WARNING = _pcbnew.MARKER_BASE_MARKER_SEVERITY_WARNING
3409  MARKER_SEVERITY_ERROR = _pcbnew.MARKER_BASE_MARKER_SEVERITY_ERROR
3410  __swig_setmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_set
3411  __swig_getmethods__["m_Pos"] = _pcbnew.MARKER_BASE_m_Pos_get
3412  if _newclass:
3413  m_Pos = _swig_property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set)
3414 
3415  def __init__(self, *args):
3416  """
3417  __init__(MARKER_BASE self) -> MARKER_BASE
3418  __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos) -> MARKER_BASE
3419  __init__(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos) -> MARKER_BASE
3420  __init__(MARKER_BASE self, MARKER_BASE aMarker) -> MARKER_BASE
3421 
3422  MARKER_BASE::MARKER_BASE(const MARKER_BASE &aMarker)
3423 
3424  Contructor makes a copy of aMarker but does not copy the DRC_ITEM.
3425 
3426  Parameters:
3427  -----------
3428 
3429  aMarker: The marker to copy.
3430  """
3431  this = _pcbnew.new_MARKER_BASE(*args)
3432  try:
3433  self.this.append(this)
3434  except:
3435  self.this = this
3436  __swig_destroy__ = _pcbnew.delete_MARKER_BASE
3437  __del__ = lambda self: None
3438 
3439  def DrawMarker(self, aPanel, aDC, aDrawMode, aOffset):
3440  """
3441  DrawMarker(MARKER_BASE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
3442 
3443  void
3444  MARKER_BASE::DrawMarker(EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE
3445  aDrawMode, const wxPoint &aOffset)
3446 
3447  Function DrawMarker draws the shape is the polygon defined in
3448  m_Corners (array of wxPoints).
3449  """
3450  return _pcbnew.MARKER_BASE_DrawMarker(self, aPanel, aDC, aDrawMode, aOffset)
3451 
3452 
3453  def GetPos(self):
3454  """
3455  GetPos(MARKER_BASE self) -> wxPoint
3456 
3457  const wxPoint&
3458  MARKER_BASE::GetPos() const
3459 
3460  Function GetPos returns the position of this MARKER, const.
3461  """
3462  return _pcbnew.MARKER_BASE_GetPos(self)
3463 
3464 
3465  def SetColor(self, aColor):
3466  """
3467  SetColor(MARKER_BASE self, COLOR4D aColor)
3468 
3469  void
3470  MARKER_BASE::SetColor(COLOR4D aColor)
3471 
3472  Function SetColor Set the color of this marker.
3473  """
3474  return _pcbnew.MARKER_BASE_SetColor(self, aColor)
3475 
3476 
3477  def SetErrorLevel(self, aErrorLevel):
3478  """
3479  SetErrorLevel(MARKER_BASE self, MARKER_BASE::MARKER_SEVERITY aErrorLevel)
3480 
3481  void
3482  MARKER_BASE::SetErrorLevel(MARKER_SEVERITY aErrorLevel)
3483 
3484  accessors to set/get error levels (warning, error, fatal error..)
3485  """
3486  return _pcbnew.MARKER_BASE_SetErrorLevel(self, aErrorLevel)
3487 
3488 
3489  def GetErrorLevel(self):
3490  """
3491  GetErrorLevel(MARKER_BASE self) -> MARKER_BASE::MARKER_SEVERITY
3492 
3493  MARKER_SEVERITY
3494  MARKER_BASE::GetErrorLevel() const
3495  """
3496  return _pcbnew.MARKER_BASE_GetErrorLevel(self)
3497 
3498 
3499  def SetMarkerType(self, aMarkerType):
3500  """
3501  SetMarkerType(MARKER_BASE self, enum MARKER_BASE::TYPEMARKER aMarkerType)
3502 
3503  void
3504  MARKER_BASE::SetMarkerType(enum TYPEMARKER aMarkerType)
3505 
3506  accessors to set/get marker type ( DRC, ERC, or other)
3507  """
3508  return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)
3509 
3510 
3511  def GetMarkerType(self):
3512  """
3513  GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::TYPEMARKER
3514 
3515  enum TYPEMARKER
3516  MARKER_BASE::GetMarkerType() const
3517  """
3518  return _pcbnew.MARKER_BASE_GetMarkerType(self)
3519 
3520 
3521  def SetData(self, *args):
3522  """
3523  SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos, wxString bText, wxPoint bPos)
3524  SetData(MARKER_BASE self, int aErrorCode, wxPoint aMarkerPos, wxString aText, wxPoint aPos)
3525 
3526  void
3527  MARKER_BASE::SetData(int aErrorCode, const wxPoint &aMarkerPos, const
3528  wxString &aText, const wxPoint &aPos)
3529 
3530  Function SetData fills in all the reportable data associated with a
3531  MARKER.
3532 
3533  Parameters:
3534  -----------
3535 
3536  aErrorCode: The categorizing identifier for an error
3537 
3538  aMarkerPos: The position of the MARKER on the BOARD
3539 
3540  aText: Text describing the object
3541 
3542  aPos: The position of the object
3543  """
3544  return _pcbnew.MARKER_BASE_SetData(self, *args)
3545 
3546 
3547  def SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos):
3548  """
3549  SetAuxiliaryData(MARKER_BASE self, wxString aAuxiliaryText, wxPoint aAuxiliaryPos)
3550 
3551  void
3552  MARKER_BASE::SetAuxiliaryData(const wxString &aAuxiliaryText, const
3553  wxPoint &aAuxiliaryPos)
3554 
3555  Function SetAuxiliaryData initialize data for the second (auxiliary)
3556  item.
3557 
3558  Parameters:
3559  -----------
3560 
3561  aAuxiliaryText: = the second text (main text) concerning the second
3562  schematic or board item
3563 
3564  aAuxiliaryPos: = position the second item
3565  """
3566  return _pcbnew.MARKER_BASE_SetAuxiliaryData(self, aAuxiliaryText, aAuxiliaryPos)
3567 
3568 
3570  """
3571  SetShowNoCoordinate(MARKER_BASE self)
3572 
3573  void
3574  MARKER_BASE::SetShowNoCoordinate()
3575  """
3576  return _pcbnew.MARKER_BASE_SetShowNoCoordinate(self)
3577 
3578 
3579  def GetReporter(self):
3580  """
3581  GetReporter(MARKER_BASE self) -> DRC_ITEM const &
3582 
3583  const DRC_ITEM&
3584  MARKER_BASE::GetReporter() const
3585 
3586  Function GetReporter returns the DRC_ITEM held within this MARKER so
3587  that its interface may be used.
3588 
3589  const& DRC_ITEM
3590  """
3591  return _pcbnew.MARKER_BASE_GetReporter(self)
3592 
3593 
3594  def DisplayMarkerInfo(self, aFrame):
3595  """
3596  DisplayMarkerInfo(MARKER_BASE self, EDA_DRAW_FRAME * aFrame)
3597 
3598  void
3599  MARKER_BASE::DisplayMarkerInfo(EDA_DRAW_FRAME *aFrame)
3600 
3601  Function DisplayMarkerInfo displays the full info of this marker, in a
3602  HTML window.
3603  """
3604  return _pcbnew.MARKER_BASE_DisplayMarkerInfo(self, aFrame)
3605 
3606 
3607  def HitTestMarker(self, ref_pos):
3608  """
3609  HitTestMarker(MARKER_BASE self, wxPoint ref_pos) -> bool
3610 
3611  bool
3612  MARKER_BASE::HitTestMarker(const wxPoint &ref_pos) const
3613 
3614  Function HitTestMarker tests if the given wxPoint is within the bounds
3615  of this object.
3616 
3617  Parameters:
3618  -----------
3619 
3620  ref_pos: A wxPoint to test
3621 
3622  bool - true if a hit, else false
3623  """
3624  return _pcbnew.MARKER_BASE_HitTestMarker(self, ref_pos)
3625 
3626 
3628  """
3629  GetBoundingBoxMarker(MARKER_BASE self) -> EDA_RECT
3630 
3631  EDA_RECT
3632  MARKER_BASE::GetBoundingBoxMarker() const
3633 
3634  Function GetBoundingBoxMarker returns the orthogonal, bounding box of
3635  this object for display purposes.
3636 
3637  This box should be an enclosing perimeter for visible components of
3638  this object, and the units should be in the pcb or schematic
3639  coordinate system. It is OK to overestimate the size by a few counts.
3640 
3641  """
3642  return _pcbnew.MARKER_BASE_GetBoundingBoxMarker(self)
3643 
3644 MARKER_BASE_swigregister = _pcbnew.MARKER_BASE_swigregister
3645 MARKER_BASE_swigregister(MARKER_BASE)
3646 
3647 
3648 _pcbnew.CTL_OMIT_HIDE_swigconstant(_pcbnew)
3649 CTL_OMIT_HIDE = _pcbnew.CTL_OMIT_HIDE
3650 
3651 _pcbnew.GR_TEXT_HJUSTIFY_LEFT_swigconstant(_pcbnew)
3652 GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT
3653 
3654 _pcbnew.GR_TEXT_HJUSTIFY_CENTER_swigconstant(_pcbnew)
3655 GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER
3656 
3657 _pcbnew.GR_TEXT_HJUSTIFY_RIGHT_swigconstant(_pcbnew)
3658 GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT
3659 
3660 _pcbnew.GR_TEXT_VJUSTIFY_TOP_swigconstant(_pcbnew)
3661 GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP
3662 
3663 _pcbnew.GR_TEXT_VJUSTIFY_CENTER_swigconstant(_pcbnew)
3664 GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER
3665 
3666 _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM_swigconstant(_pcbnew)
3667 GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM
3668 
3669 _pcbnew.FILLED_swigconstant(_pcbnew)
3670 FILLED = _pcbnew.FILLED
3671 
3672 _pcbnew.SKETCH_swigconstant(_pcbnew)
3673 SKETCH = _pcbnew.SKETCH
3674 
3675 _pcbnew.DEFAULT_SIZE_TEXT_swigconstant(_pcbnew)
3676 DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT
3677 
3678 _pcbnew.DIM_ANCRE_TEXTE_swigconstant(_pcbnew)
3679 DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE
3681  """Proxy of C++ TEXT_EFFECTS class"""
3682  __swig_setmethods__ = {}
3683  __setattr__ = lambda self, name, value: _swig_setattr(self, TEXT_EFFECTS, name, value)
3684  __swig_getmethods__ = {}
3685  __getattr__ = lambda self, name: _swig_getattr(self, TEXT_EFFECTS, name)
3686  __repr__ = _swig_repr
3687 
3688  def __init__(self, aSetOfBits=0):
3689  """
3690  __init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS
3691  __init__(TEXT_EFFECTS self) -> TEXT_EFFECTS
3692  """
3693  this = _pcbnew.new_TEXT_EFFECTS(aSetOfBits)
3694  try:
3695  self.this.append(this)
3696  except:
3697  self.this = this
3698  __swig_setmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_set
3699  __swig_getmethods__["bits"] = _pcbnew.TEXT_EFFECTS_bits_get
3700  if _newclass:
3701  bits = _swig_property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set)
3702  __swig_setmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_set
3703  __swig_getmethods__["hjustify"] = _pcbnew.TEXT_EFFECTS_hjustify_get
3704  if _newclass:
3705  hjustify = _swig_property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set)
3706  __swig_setmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_set
3707  __swig_getmethods__["vjustify"] = _pcbnew.TEXT_EFFECTS_vjustify_get
3708  if _newclass:
3709  vjustify = _swig_property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set)
3710  __swig_setmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_set
3711  __swig_getmethods__["size"] = _pcbnew.TEXT_EFFECTS_size_get
3712  if _newclass:
3713  size = _swig_property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set)
3714  __swig_setmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_set
3715  __swig_getmethods__["penwidth"] = _pcbnew.TEXT_EFFECTS_penwidth_get
3716  if _newclass:
3717  penwidth = _swig_property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set)
3718  __swig_setmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_set
3719  __swig_getmethods__["angle"] = _pcbnew.TEXT_EFFECTS_angle_get
3720  if _newclass:
3721  angle = _swig_property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set)
3722  __swig_setmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_set
3723  __swig_getmethods__["pos"] = _pcbnew.TEXT_EFFECTS_pos_get
3724  if _newclass:
3725  pos = _swig_property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set)
3726 
3727  def Bit(self, *args):
3728  """
3729  Bit(TEXT_EFFECTS self, int aBit, bool aValue)
3730  Bit(TEXT_EFFECTS self, int aBit) -> bool
3731  """
3732  return _pcbnew.TEXT_EFFECTS_Bit(self, *args)
3733 
3734  __swig_destroy__ = _pcbnew.delete_TEXT_EFFECTS
3735  __del__ = lambda self: None
3736 TEXT_EFFECTS_swigregister = _pcbnew.TEXT_EFFECTS_swigregister
3737 TEXT_EFFECTS_swigregister(TEXT_EFFECTS)
3738 
3740  """
3741 
3742 
3743  Class EDA_TEXT is a mix-in class (via multiple inheritance) that
3744  handles texts such as labels, parts, components, or footprints.
3745 
3746  Because it's a mix-in class, care is used to provide function names
3747  (accessors) that to not collide with function names likely to be seen
3748  in the combined derived classes.
3749 
3750  C++ includes: eda_text.h
3751  """
3752  __swig_setmethods__ = {}
3753  __setattr__ = lambda self, name, value: _swig_setattr(self, EDA_TEXT, name, value)
3754  __swig_getmethods__ = {}
3755  __getattr__ = lambda self, name: _swig_getattr(self, EDA_TEXT, name)
3756  __repr__ = _swig_repr
3757 
3758  def __init__(self, *args):
3759  """
3760  __init__(EDA_TEXT self, wxString text) -> EDA_TEXT
3761  __init__(EDA_TEXT self) -> EDA_TEXT
3762 
3763  EDA_TEXT::EDA_TEXT(const
3764  wxString &text=wxEmptyString)
3765  """
3766  this = _pcbnew.new_EDA_TEXT(*args)
3767  try:
3768  self.this.append(this)
3769  except:
3770  self.this = this
3771  __swig_destroy__ = _pcbnew.delete_EDA_TEXT
3772  __del__ = lambda self: None
3773 
3774  def GetText(self):
3775  """
3776  GetText(EDA_TEXT self) -> wxString
3777 
3778  const wxString&
3779  EDA_TEXT::GetText() const
3780 
3781  Function GetText returns the string associated with the text object.
3782 
3783  a const wxString reference containing the string of the item.
3784  """
3785  return _pcbnew.EDA_TEXT_GetText(self)
3786 
3787 
3788  def GetShownText(self):
3789  """
3790  GetShownText(EDA_TEXT self) -> wxString
3791 
3792  virtual wxString
3793  EDA_TEXT::GetShownText() const
3794 
3795  Returns the string actually shown after processing of the base text.
3796 
3797  Default is no processing
3798  """
3799  return _pcbnew.EDA_TEXT_GetShownText(self)
3800 
3801 
3803  """
3804  ShortenedShownText(EDA_TEXT self) -> wxString
3805 
3806  wxString
3807  EDA_TEXT::ShortenedShownText() const
3808 
3809  Returns a shortened version (max 15 characters) of the shown text.
3810  """
3811  return _pcbnew.EDA_TEXT_ShortenedShownText(self)
3812 
3813 
3814  def SetText(self, aText):
3815  """
3816  SetText(EDA_TEXT self, wxString aText)
3817 
3818  virtual void
3819  EDA_TEXT::SetText(const wxString &aText)
3820  """
3821  return _pcbnew.EDA_TEXT_SetText(self, aText)
3822 
3823 
3824  def SetThickness(self, aNewThickness):
3825  """
3826  SetThickness(EDA_TEXT self, int aNewThickness)
3827 
3828  void
3829  EDA_TEXT::SetThickness(int aNewThickness)
3830 
3831  Function SetThickness sets pen width.
3832 
3833  Parameters:
3834  -----------
3835 
3836  aNewThickness: is the new pen width
3837  """
3838  return _pcbnew.EDA_TEXT_SetThickness(self, aNewThickness)
3839 
3840 
3841  def GetThickness(self):
3842  """
3843  GetThickness(EDA_TEXT self) -> int
3844 
3845  int
3846  EDA_TEXT::GetThickness() const
3847 
3848  Function GetThickness returns pen width.
3849  """
3850  return _pcbnew.EDA_TEXT_GetThickness(self)
3851 
3852 
3853  def SetTextAngle(self, aAngle):
3854  """
3855  SetTextAngle(EDA_TEXT self, double aAngle)
3856 
3857  void
3858  EDA_TEXT::SetTextAngle(double aAngle)
3859  """
3860  return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)
3861 
3862 
3863  def GetTextAngle(self):
3864  """
3865  GetTextAngle(EDA_TEXT self) -> double
3866 
3867  double
3868  EDA_TEXT::GetTextAngle() const
3869  """
3870  return _pcbnew.EDA_TEXT_GetTextAngle(self)
3871 
3872 
3874  """
3875  GetTextAngleDegrees(EDA_TEXT self) -> double
3876 
3877  double
3878  EDA_TEXT::GetTextAngleDegrees() const
3879  """
3880  return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)
3881 
3882 
3884  """
3885  GetTextAngleRadians(EDA_TEXT self) -> double
3886 
3887  double
3888  EDA_TEXT::GetTextAngleRadians() const
3889  """
3890  return _pcbnew.EDA_TEXT_GetTextAngleRadians(self)
3891 
3892 
3893  def SetItalic(self, isItalic):
3894  """
3895  SetItalic(EDA_TEXT self, bool isItalic)
3896 
3897  void
3898  EDA_TEXT::SetItalic(bool isItalic)
3899  """
3900  return _pcbnew.EDA_TEXT_SetItalic(self, isItalic)
3901 
3902 
3903  def IsItalic(self):
3904  """
3905  IsItalic(EDA_TEXT self) -> bool
3906 
3907  bool EDA_TEXT::IsItalic()
3908  const
3909  """
3910  return _pcbnew.EDA_TEXT_IsItalic(self)
3911 
3912 
3913  def SetBold(self, aBold):
3914  """
3915  SetBold(EDA_TEXT self, bool aBold)
3916 
3917  void EDA_TEXT::SetBold(bool
3918  aBold)
3919  """
3920  return _pcbnew.EDA_TEXT_SetBold(self, aBold)
3921 
3922 
3923  def IsBold(self):
3924  """
3925  IsBold(EDA_TEXT self) -> bool
3926 
3927  bool EDA_TEXT::IsBold()
3928  const
3929  """
3930  return _pcbnew.EDA_TEXT_IsBold(self)
3931 
3932 
3933  def SetVisible(self, aVisible):
3934  """
3935  SetVisible(EDA_TEXT self, bool aVisible)
3936 
3937  void
3938  EDA_TEXT::SetVisible(bool aVisible)
3939  """
3940  return _pcbnew.EDA_TEXT_SetVisible(self, aVisible)
3941 
3942 
3943  def IsVisible(self):
3944  """
3945  IsVisible(EDA_TEXT self) -> bool
3946 
3947  bool
3948  EDA_TEXT::IsVisible() const
3949  """
3950  return _pcbnew.EDA_TEXT_IsVisible(self)
3951 
3952 
3953  def SetMirrored(self, isMirrored):
3954  """
3955  SetMirrored(EDA_TEXT self, bool isMirrored)
3956 
3957  void
3958  EDA_TEXT::SetMirrored(bool isMirrored)
3959  """
3960  return _pcbnew.EDA_TEXT_SetMirrored(self, isMirrored)
3961 
3962 
3963  def IsMirrored(self):
3964  """
3965  IsMirrored(EDA_TEXT self) -> bool
3966 
3967  bool
3968  EDA_TEXT::IsMirrored() const
3969  """
3970  return _pcbnew.EDA_TEXT_IsMirrored(self)
3971 
3972 
3973  def SetMultilineAllowed(self, aAllow):
3974  """
3975  SetMultilineAllowed(EDA_TEXT self, bool aAllow)
3976 
3977  void
3978  EDA_TEXT::SetMultilineAllowed(bool aAllow)
3979 
3980  Function SetMultiLineAllowed.
3981 
3982  Parameters:
3983  -----------
3984 
3985  aAllow: true if ok to use multiline option, false if ok to use only
3986  single line text. (Single line is faster in calculations than
3987  multiline.)
3988  """
3989  return _pcbnew.EDA_TEXT_SetMultilineAllowed(self, aAllow)
3990 
3991 
3993  """
3994  IsMultilineAllowed(EDA_TEXT self) -> bool
3995 
3996  bool
3997  EDA_TEXT::IsMultilineAllowed() const
3998  """
3999  return _pcbnew.EDA_TEXT_IsMultilineAllowed(self)
4000 
4001 
4002  def GetHorizJustify(self):
4003  """
4004  GetHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T
4005 
4006  EDA_TEXT_HJUSTIFY_T
4007  EDA_TEXT::GetHorizJustify() const
4008  """
4009  return _pcbnew.EDA_TEXT_GetHorizJustify(self)
4010 
4011 
4012  def GetVertJustify(self):
4013  """
4014  GetVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T
4015 
4016  EDA_TEXT_VJUSTIFY_T
4017  EDA_TEXT::GetVertJustify() const
4018  """
4019  return _pcbnew.EDA_TEXT_GetVertJustify(self)
4020 
4021 
4022  def SetHorizJustify(self, aType):
4023  """
4024  SetHorizJustify(EDA_TEXT self, EDA_TEXT_HJUSTIFY_T aType)
4025 
4026  void
4027  EDA_TEXT::SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
4028  """
4029  return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)
4030 
4031 
4032  def SetVertJustify(self, aType):
4033  """
4034  SetVertJustify(EDA_TEXT self, EDA_TEXT_VJUSTIFY_T aType)
4035 
4036  void
4037  EDA_TEXT::SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
4038  """
4039  return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)
4040 
4041 
4042  def SetEffects(self, aSrc):
4043  """
4044  SetEffects(EDA_TEXT self, EDA_TEXT aSrc)
4045 
4046  void
4047  EDA_TEXT::SetEffects(const EDA_TEXT &aSrc)
4048 
4049  Function SetEffects sets the text effects from another instance.
4050 
4051  ( TEXT_EFFECTS is not exposed in the public API, but includes
4052  everything except the actual text string itself.)
4053  """
4054  return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)
4055 
4056 
4057  def SwapEffects(self, aTradingPartner):
4058  """
4059  SwapEffects(EDA_TEXT self, EDA_TEXT aTradingPartner)
4060 
4061  void
4062  EDA_TEXT::SwapEffects(EDA_TEXT &aTradingPartner)
4063 
4064  Function SwapEffects swaps the text effects of the two involved
4065  instances.
4066 
4067  (TEXT_EFECTS is not exposed in the public API, but includes everything
4068  except the actual text string itself.)
4069  """
4070  return _pcbnew.EDA_TEXT_SwapEffects(self, aTradingPartner)
4071 
4072 
4074  """
4075  IsDefaultFormatting(EDA_TEXT self) -> bool
4076 
4077  bool
4078  EDA_TEXT::IsDefaultFormatting() const
4079  """
4080  return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)
4081 
4082 
4083  def SetTextSize(self, aNewSize):
4084  """
4085  SetTextSize(EDA_TEXT self, wxSize aNewSize)
4086 
4087  void
4088  EDA_TEXT::SetTextSize(const wxSize &aNewSize)
4089  """
4090  return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize)
4091 
4092 
4093  def GetTextSize(self):
4094  """
4095  GetTextSize(EDA_TEXT self) -> wxSize
4096 
4097  const wxSize&
4098  EDA_TEXT::GetTextSize() const
4099  """
4100  return _pcbnew.EDA_TEXT_GetTextSize(self)
4101 
4102 
4103  def SetTextWidth(self, aWidth):
4104  """
4105  SetTextWidth(EDA_TEXT self, int aWidth)
4106 
4107  void
4108  EDA_TEXT::SetTextWidth(int aWidth)
4109  """
4110  return _pcbnew.EDA_TEXT_SetTextWidth(self, aWidth)
4111 
4112 
4113  def GetTextWidth(self):
4114  """
4115  GetTextWidth(EDA_TEXT self) -> int
4116 
4117  int
4118  EDA_TEXT::GetTextWidth() const
4119  """
4120  return _pcbnew.EDA_TEXT_GetTextWidth(self)
4121 
4122 
4123  def SetTextHeight(self, aHeight):
4124  """
4125  SetTextHeight(EDA_TEXT self, int aHeight)
4126 
4127  void
4128  EDA_TEXT::SetTextHeight(int aHeight)
4129  """
4130  return _pcbnew.EDA_TEXT_SetTextHeight(self, aHeight)
4131 
4132 
4133  def GetTextHeight(self):
4134  """
4135  GetTextHeight(EDA_TEXT self) -> int
4136 
4137  int
4138  EDA_TEXT::GetTextHeight() const
4139  """
4140  return _pcbnew.EDA_TEXT_GetTextHeight(self)
4141 
4142 
4143  def SetTextPos(self, aPoint):
4144  """
4145  SetTextPos(EDA_TEXT self, wxPoint aPoint)
4146 
4147  void
4148  EDA_TEXT::SetTextPos(const wxPoint &aPoint)
4149  """
4150  return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)
4151 
4152 
4153  def GetTextPos(self):
4154  """
4155  GetTextPos(EDA_TEXT self) -> wxPoint
4156 
4157  const wxPoint&
4158  EDA_TEXT::GetTextPos() const
4159  """
4160  return _pcbnew.EDA_TEXT_GetTextPos(self)
4161 
4162 
4163  def SetTextX(self, aX):
4164  """
4165  SetTextX(EDA_TEXT self, int aX)
4166 
4167  void
4168  EDA_TEXT::SetTextX(int aX)
4169  """
4170  return _pcbnew.EDA_TEXT_SetTextX(self, aX)
4171 
4172 
4173  def SetTextY(self, aY):
4174  """
4175  SetTextY(EDA_TEXT self, int aY)
4176 
4177  void
4178  EDA_TEXT::SetTextY(int aY)
4179  """
4180  return _pcbnew.EDA_TEXT_SetTextY(self, aY)
4181 
4182 
4183  def Offset(self, aOffset):
4184  """
4185  Offset(EDA_TEXT self, wxPoint aOffset)
4186 
4187  void EDA_TEXT::Offset(const
4188  wxPoint &aOffset)
4189  """
4190  return _pcbnew.EDA_TEXT_Offset(self, aOffset)
4191 
4192 
4193  def Empty(self):
4194  """
4195  Empty(EDA_TEXT self)
4196 
4197  void EDA_TEXT::Empty()
4198  """
4199  return _pcbnew.EDA_TEXT_Empty(self)
4200 
4201 
4202  def Draw(self, *args):
4203  """
4204  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)
4205  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED)
4206  Draw(EDA_TEXT self, EDA_RECT aClipBox, wxDC * aDC, wxPoint aOffset, COLOR4D aColor, GR_DRAWMODE aDrawMode)
4207 
4208  void EDA_TEXT::Draw(EDA_RECT
4209  *aClipBox, wxDC *aDC, const wxPoint &aOffset, COLOR4D aColor,
4210  GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aDisplay_mode=FILLED, COLOR4D
4211  aAnchor_color=COLOR4D::UNSPECIFIED)
4212 
4213  Function Draw.
4214 
4215  Parameters:
4216  -----------
4217 
4218  aClipBox: = the clipping rect, or NULL if no clipping
4219 
4220  aDC: = the current Device Context
4221 
4222  aOffset: = draw offset (usually (0,0))
4223 
4224  aColor: = text color
4225 
4226  aDrawMode: = GR_OR, GR_XOR.., -1 to use the current mode.
4227 
4228  aDisplay_mode: = FILLED or SKETCH
4229 
4230  aAnchor_color: = anchor color ( COLOR4D::UNSPECIFIED = do not draw
4231  anchor ).
4232  """
4233  return _pcbnew.EDA_TEXT_Draw(self, *args)
4234 
4235 
4236  def TransformTextShapeToSegmentList(self, aCornerBuffer):
4237  """
4238  TransformTextShapeToSegmentList(EDA_TEXT self, wxPoint_Vector aCornerBuffer)
4239 
4240  void EDA_TEXT::TransformTextShapeToSegmentList(std::vector< wxPoint >
4241  &aCornerBuffer) const
4242 
4243  Convert the text shape to a list of segment each segment is stored as
4244  2 wxPoints: the starting point and the ending point there are
4245  therefore 2*n points.
4246 
4247  Parameters:
4248  -----------
4249 
4250  aCornerBuffer: = a buffer to store the polygon
4251  """
4252  return _pcbnew.EDA_TEXT_TransformTextShapeToSegmentList(self, aCornerBuffer)
4253 
4254 
4255  def TextHitTest(self, *args):
4256  """
4257  TextHitTest(EDA_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
4258  TextHitTest(EDA_TEXT self, wxPoint aPoint) -> bool
4259  TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False, int aAccuracy=0) -> bool
4260  TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains=False) -> bool
4261  TextHitTest(EDA_TEXT self, EDA_RECT aRect) -> bool
4262 
4263  bool
4264  EDA_TEXT::TextHitTest(const EDA_RECT &aRect, bool aContains=false, int
4265  aAccuracy=0) const
4266 
4267  Function TextHitTest (overloaded) Tests if object bounding box is
4268  contained within or intersects aRect.
4269 
4270  Parameters:
4271  -----------
4272 
4273  aRect: - Rect to test against.
4274 
4275  aContains: - Test for containment instead of intersection if true.
4276 
4277  aAccuracy: - Amount to inflate the bounding box.
4278 
4279  bool - true if a hit, else false
4280  """
4281  return _pcbnew.EDA_TEXT_TextHitTest(self, *args)
4282 
4283 
4284  def LenSize(self, aLine):
4285  """
4286  LenSize(EDA_TEXT self, wxString aLine) -> int
4287 
4288  int EDA_TEXT::LenSize(const
4289  wxString &aLine) const
4290 
4291  Function LenSize.
4292 
4293  the text length in internal units
4294 
4295  Parameters:
4296  -----------
4297 
4298  aLine: : the line of text to consider. For single line text, this
4299  parameter is always m_Text
4300  """
4301  return _pcbnew.EDA_TEXT_LenSize(self, aLine)
4302 
4303 
4304  def GetTextBox(self, aLine=-1, aThickness=-1, aInvertY=False):
4305  """
4306  GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1, bool aInvertY=False) -> EDA_RECT
4307  GetTextBox(EDA_TEXT self, int aLine=-1, int aThickness=-1) -> EDA_RECT
4308  GetTextBox(EDA_TEXT self, int aLine=-1) -> EDA_RECT
4309  GetTextBox(EDA_TEXT self) -> EDA_RECT
4310 
4311  EDA_RECT
4312  EDA_TEXT::GetTextBox(int aLine=-1, int aThickness=-1, bool
4313  aInvertY=false) const
4314 
4315  Function GetTextBox useful in multiline texts to calculate the full
4316  text or a line area (for zones filling, locate functions....)
4317 
4318  the rect containing the line of text (i.e. the position and the size
4319  of one line) this rectangle is calculated for 0 orient text. If
4320  orientation is not 0 the rect must be rotated to match the physical
4321  area
4322 
4323  Parameters:
4324  -----------
4325 
4326  aLine: The line of text to consider. for single line text, aLine is
4327  unused If aLine == -1, the full area (considering all lines) is
4328  returned
4329 
4330  aThickness: Overrides the current penwidth when greater than 0. This
4331  is needed when the current penwidth is 0 and a default penwidth is
4332  used.
4333 
4334  aInvertY: Invert the Y axis when calculating bounding box.
4335  """
4336  return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aThickness, aInvertY)
4337 
4338 
4339  def GetInterline(self, aTextThickness=-1):
4340  """
4341  GetInterline(EDA_TEXT self, int aTextThickness=-1) -> int
4342  GetInterline(EDA_TEXT self) -> int
4343 
4344  int
4345  EDA_TEXT::GetInterline(int aTextThickness=-1) const
4346 
4347  Return the distance between two lines of text.
4348 
4349  Calculates the distance (pitch) between two lines of text. This
4350  distance includes the interline distance plus room for characters like
4351  j, {, and [. It also used for single line text, to calculate the text
4352  bounding box.
4353 
4354  Parameters:
4355  -----------
4356 
4357  aTextThickness: Overrides the current thickness when greater than 0.
4358  this is needed when the current m_Thickness is 0 and a default line
4359  thickness is used
4360  """
4361  return _pcbnew.EDA_TEXT_GetInterline(self, aTextThickness)
4362 
4363 
4364  def GetTextStyleName(self):
4365  """
4366  GetTextStyleName(EDA_TEXT self) -> wxString
4367 
4368  wxString
4369  EDA_TEXT::GetTextStyleName()
4370 
4371  Function GetTextStyleName.
4372 
4373  a wxString with the style name( Normal, Italic, Bold, Bold+Italic)
4374  """
4375  return _pcbnew.EDA_TEXT_GetTextStyleName(self)
4376 
4377 
4378  def GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount):
4379  """
4380  GetPositionsOfLinesOfMultilineText(EDA_TEXT self, wxPoint_Vector aPositions, int aLineCount)
4381 
4382  void EDA_TEXT::GetPositionsOfLinesOfMultilineText(std::vector< wxPoint
4383  > &aPositions, int aLineCount) const
4384 
4385  Function GetPositionsOfLinesOfMultilineText Populates aPositions with
4386  the position of each line of a multiline text, according to the
4387  vertical justification and the rotation of the whole text.
4388 
4389  Parameters:
4390  -----------
4391 
4392  aPositions: is the list to populate by the wxPoint positions
4393 
4394  aLineCount: is the number of lines (not recalculated here for
4395  efficiency reasons
4396  """
4397  return _pcbnew.EDA_TEXT_GetPositionsOfLinesOfMultilineText(self, aPositions, aLineCount)
4398 
4399 
4400  def Format(self, aFormatter, aNestLevel, aControlBits):
4401  """
4402  Format(EDA_TEXT self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)
4403 
4404  void
4405  EDA_TEXT::Format(OUTPUTFORMATTER *aFormatter, int aNestLevel, int
4406  aControlBits) const
4407 
4408  Function Format outputs the object to aFormatter in s-expression form.
4409 
4410  Parameters:
4411  -----------
4412 
4413  aFormatter: The OUTPUTFORMATTER object to write to.
4414 
4415  aNestLevel: The indentation next level.
4416 
4417  aControlBits: The control bit definition for object specific
4418  formatting.
4419 
4420  Parameters:
4421  -----------
4422 
4423  ???: on write error.
4424  """
4425  return _pcbnew.EDA_TEXT_Format(self, aFormatter, aNestLevel, aControlBits)
4426 
4427 EDA_TEXT_swigregister = _pcbnew.EDA_TEXT_swigregister
4428 EDA_TEXT_swigregister(EDA_TEXT)
4429 
4431  """Proxy of C++ std::vector<(int)> class"""
4432  __swig_setmethods__ = {}
4433  __setattr__ = lambda self, name, value: _swig_setattr(self, intVector, name, value)
4434  __swig_getmethods__ = {}
4435  __getattr__ = lambda self, name: _swig_getattr(self, intVector, name)
4436  __repr__ = _swig_repr
4437 
4438  def iterator(self):
4439  """iterator(intVector self) -> SwigPyIterator"""
4440  return _pcbnew.intVector_iterator(self)
4441 
4442  def __iter__(self):
4443  return self.iterator()
4444 
4445  def __nonzero__(self):
4446  """__nonzero__(intVector self) -> bool"""
4447  return _pcbnew.intVector___nonzero__(self)
4448 
4449 
4450  def __bool__(self):
4451  """__bool__(intVector self) -> bool"""
4452  return _pcbnew.intVector___bool__(self)
4453 
4454 
4455  def __len__(self):
4456  """__len__(intVector self) -> std::vector< int >::size_type"""
4457  return _pcbnew.intVector___len__(self)
4458 
4459 
4460  def pop(self):
4461  """pop(intVector self) -> std::vector< int >::value_type"""
4462  return _pcbnew.intVector_pop(self)
4463 
4464 
4465  def __getslice__(self, i, j):
4466  """__getslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> intVector"""
4467  return _pcbnew.intVector___getslice__(self, i, j)
4468 
4469 
4470  def __setslice__(self, *args):
4471  """
4472  __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, intVector v)
4473  __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
4474  """
4475  return _pcbnew.intVector___setslice__(self, *args)
4476 
4477 
4478  def __delslice__(self, i, j):
4479  """__delslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
4480  return _pcbnew.intVector___delslice__(self, i, j)
4481 
4482 
4483  def __delitem__(self, *args):
4484  """
4485  __delitem__(intVector self, std::vector< int >::difference_type i)
4486  __delitem__(intVector self, PySliceObject * slice)
4487  """
4488  return _pcbnew.intVector___delitem__(self, *args)
4489 
4490 
4491  def __getitem__(self, *args):
4492  """
4493  __getitem__(intVector self, PySliceObject * slice) -> intVector
4494  __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
4495  """
4496  return _pcbnew.intVector___getitem__(self, *args)
4497 
4498 
4499  def __setitem__(self, *args):
4500  """
4501  __setitem__(intVector self, PySliceObject * slice, intVector v)
4502  __setitem__(intVector self, PySliceObject * slice)
4503  __setitem__(intVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
4504  """
4505  return _pcbnew.intVector___setitem__(self, *args)
4506 
4507 
4508  def append(self, x):
4509  """append(intVector self, std::vector< int >::value_type const & x)"""
4510  return _pcbnew.intVector_append(self, x)
4511 
4512 
4513  def empty(self):
4514  """empty(intVector self) -> bool"""
4515  return _pcbnew.intVector_empty(self)
4516 
4517 
4518  def size(self):
4519  """size(intVector self) -> std::vector< int >::size_type"""
4520  return _pcbnew.intVector_size(self)
4521 
4522 
4523  def clear(self):
4524  """clear(intVector self)"""
4525  return _pcbnew.intVector_clear(self)
4526 
4527 
4528  def swap(self, v):
4529  """swap(intVector self, intVector v)"""
4530  return _pcbnew.intVector_swap(self, v)
4531 
4532 
4533  def get_allocator(self):
4534  """get_allocator(intVector self) -> std::vector< int >::allocator_type"""
4535  return _pcbnew.intVector_get_allocator(self)
4536 
4537 
4538  def begin(self):
4539  """begin(intVector self) -> std::vector< int >::iterator"""
4540  return _pcbnew.intVector_begin(self)
4541 
4542 
4543  def end(self):
4544  """end(intVector self) -> std::vector< int >::iterator"""
4545  return _pcbnew.intVector_end(self)
4546 
4547 
4548  def rbegin(self):
4549  """rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
4550  return _pcbnew.intVector_rbegin(self)
4551 
4552 
4553  def rend(self):
4554  """rend(intVector self) -> std::vector< int >::reverse_iterator"""
4555  return _pcbnew.intVector_rend(self)
4556 
4557 
4558  def pop_back(self):
4559  """pop_back(intVector self)"""
4560  return _pcbnew.intVector_pop_back(self)
4561 
4562 
4563  def erase(self, *args):
4564  """
4565  erase(intVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
4566  erase(intVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
4567  """
4568  return _pcbnew.intVector_erase(self, *args)
4569 
4570 
4571  def __init__(self, *args):
4572  """
4573  __init__(std::vector<(int)> self) -> intVector
4574  __init__(std::vector<(int)> self, intVector arg2) -> intVector
4575  __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> intVector
4576  __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
4577  """
4578  this = _pcbnew.new_intVector(*args)
4579  try:
4580  self.this.append(this)
4581  except:
4582  self.this = this
4583 
4584  def push_back(self, x):
4585  """push_back(intVector self, std::vector< int >::value_type const & x)"""
4586  return _pcbnew.intVector_push_back(self, x)
4587 
4588 
4589  def front(self):
4590  """front(intVector self) -> std::vector< int >::value_type const &"""
4591  return _pcbnew.intVector_front(self)
4592 
4593 
4594  def back(self):
4595  """back(intVector self) -> std::vector< int >::value_type const &"""
4596  return _pcbnew.intVector_back(self)
4597 
4598 
4599  def assign(self, n, x):
4600  """assign(intVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
4601  return _pcbnew.intVector_assign(self, n, x)
4602 
4603 
4604  def resize(self, *args):
4605  """
4606  resize(intVector self, std::vector< int >::size_type new_size)
4607  resize(intVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
4608  """
4609  return _pcbnew.intVector_resize(self, *args)
4610 
4611 
4612  def insert(self, *args):
4613  """
4614  insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
4615  insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
4616  """
4617  return _pcbnew.intVector_insert(self, *args)
4618 
4619 
4620  def reserve(self, n):
4621  """reserve(intVector self, std::vector< int >::size_type n)"""
4622  return _pcbnew.intVector_reserve(self, n)
4623 
4624 
4625  def capacity(self):
4626  """capacity(intVector self) -> std::vector< int >::size_type"""
4627  return _pcbnew.intVector_capacity(self)
4628 
4629  __swig_destroy__ = _pcbnew.delete_intVector
4630  __del__ = lambda self: None
4631 intVector_swigregister = _pcbnew.intVector_swigregister
4632 intVector_swigregister(intVector)
4633 
4635  """Proxy of C++ std::map<(std::string,UTF8)> class"""
4636  __swig_setmethods__ = {}
4637  __setattr__ = lambda self, name, value: _swig_setattr(self, str_utf8_Map, name, value)
4638  __swig_getmethods__ = {}
4639  __getattr__ = lambda self, name: _swig_getattr(self, str_utf8_Map, name)
4640  __repr__ = _swig_repr
4641 
4642  def iterator(self):
4643  """iterator(str_utf8_Map self) -> SwigPyIterator"""
4644  return _pcbnew.str_utf8_Map_iterator(self)
4645 
4646  def __iter__(self):
4647  return self.iterator()
4648 
4649  def __nonzero__(self):
4650  """__nonzero__(str_utf8_Map self) -> bool"""
4651  return _pcbnew.str_utf8_Map___nonzero__(self)
4652 
4653 
4654  def __bool__(self):
4655  """__bool__(str_utf8_Map self) -> bool"""
4656  return _pcbnew.str_utf8_Map___bool__(self)
4657 
4658 
4659  def __len__(self):
4660  """__len__(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4661  return _pcbnew.str_utf8_Map___len__(self)
4662 
4663  def __iter__(self):
4664  return self.key_iterator()
4665  def iterkeys(self):
4666  return self.key_iterator()
4667  def itervalues(self):
4668  return self.value_iterator()
4669  def iteritems(self):
4670  return self.iterator()
4671 
4672  def __getitem__(self, key):
4673  """__getitem__(str_utf8_Map self, string key) -> UTF8"""
4674  return _pcbnew.str_utf8_Map___getitem__(self, key)
4675 
4676 
4677  def __delitem__(self, key):
4678  """__delitem__(str_utf8_Map self, string key)"""
4679  return _pcbnew.str_utf8_Map___delitem__(self, key)
4680 
4681 
4682  def has_key(self, key):
4683  """has_key(str_utf8_Map self, string key) -> bool"""
4684  return _pcbnew.str_utf8_Map_has_key(self, key)
4685 
4686 
4687  def keys(self):
4688  """keys(str_utf8_Map self) -> PyObject *"""
4689  return _pcbnew.str_utf8_Map_keys(self)
4690 
4691 
4692  def values(self):
4693  """values(str_utf8_Map self) -> PyObject *"""
4694  return _pcbnew.str_utf8_Map_values(self)
4695 
4696 
4697  def items(self):
4698  """items(str_utf8_Map self) -> PyObject *"""
4699  return _pcbnew.str_utf8_Map_items(self)
4700 
4701 
4702  def __contains__(self, key):
4703  """__contains__(str_utf8_Map self, string key) -> bool"""
4704  return _pcbnew.str_utf8_Map___contains__(self, key)
4705 
4706 
4707  def key_iterator(self):
4708  """key_iterator(str_utf8_Map self) -> SwigPyIterator"""
4709  return _pcbnew.str_utf8_Map_key_iterator(self)
4710 
4711 
4712  def value_iterator(self):
4713  """value_iterator(str_utf8_Map self) -> SwigPyIterator"""
4714  return _pcbnew.str_utf8_Map_value_iterator(self)
4715 
4716 
4717  def __setitem__(self, *args):
4718  """
4719  __setitem__(str_utf8_Map self, string key)
4720  __setitem__(str_utf8_Map self, string key, UTF8 x)
4721  """
4722  return _pcbnew.str_utf8_Map___setitem__(self, *args)
4723 
4724 
4725  def asdict(self):
4726  """asdict(str_utf8_Map self) -> PyObject *"""
4727  return _pcbnew.str_utf8_Map_asdict(self)
4728 
4729 
4730  def __init__(self, *args):
4731  """
4732  __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
4733  __init__(std::map<(std::string,UTF8)> self) -> str_utf8_Map
4734  __init__(std::map<(std::string,UTF8)> self, str_utf8_Map arg2) -> str_utf8_Map
4735  """
4736  this = _pcbnew.new_str_utf8_Map(*args)
4737  try:
4738  self.this.append(this)
4739  except:
4740  self.this = this
4741 
4742  def empty(self):
4743  """empty(str_utf8_Map self) -> bool"""
4744  return _pcbnew.str_utf8_Map_empty(self)
4745 
4746 
4747  def size(self):
4748  """size(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4749  return _pcbnew.str_utf8_Map_size(self)
4750 
4751 
4752  def clear(self):
4753  """clear(str_utf8_Map self)"""
4754  return _pcbnew.str_utf8_Map_clear(self)
4755 
4756 
4757  def swap(self, v):
4758  """swap(str_utf8_Map self, str_utf8_Map v)"""
4759  return _pcbnew.str_utf8_Map_swap(self, v)
4760 
4761 
4762  def get_allocator(self):
4763  """get_allocator(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type"""
4764  return _pcbnew.str_utf8_Map_get_allocator(self)
4765 
4766 
4767  def begin(self):
4768  """begin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4769  return _pcbnew.str_utf8_Map_begin(self)
4770 
4771 
4772  def end(self):
4773  """end(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4774  return _pcbnew.str_utf8_Map_end(self)
4775 
4776 
4777  def rbegin(self):
4778  """rbegin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
4779  return _pcbnew.str_utf8_Map_rbegin(self)
4780 
4781 
4782  def rend(self):
4783  """rend(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
4784  return _pcbnew.str_utf8_Map_rend(self)
4785 
4786 
4787  def count(self, x):
4788  """count(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
4789  return _pcbnew.str_utf8_Map_count(self, x)
4790 
4791 
4792  def erase(self, *args):
4793  """
4794  erase(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type
4795  erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator position)
4796  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)
4797  """
4798  return _pcbnew.str_utf8_Map_erase(self, *args)
4799 
4800 
4801  def find(self, x):
4802  """find(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4803  return _pcbnew.str_utf8_Map_find(self, x)
4804 
4805 
4806  def lower_bound(self, x):
4807  """lower_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4808  return _pcbnew.str_utf8_Map_lower_bound(self, x)
4809 
4810 
4811  def upper_bound(self, x):
4812  """upper_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
4813  return _pcbnew.str_utf8_Map_upper_bound(self, x)
4814 
4815  __swig_destroy__ = _pcbnew.delete_str_utf8_Map
4816  __del__ = lambda self: None
4817 str_utf8_Map_swigregister = _pcbnew.str_utf8_Map_swigregister
4818 str_utf8_Map_swigregister(str_utf8_Map)
4819 
4821  """Proxy of C++ std::vector<(enum PCB_LAYER_ID)> class"""
4822  __swig_setmethods__ = {}
4823  __setattr__ = lambda self, name, value: _swig_setattr(self, base_seqVect, name, value)
4824  __swig_getmethods__ = {}
4825  __getattr__ = lambda self, name: _swig_getattr(self, base_seqVect, name)
4826  __repr__ = _swig_repr
4827 
4828  def iterator(self):
4829  """iterator(base_seqVect self) -> SwigPyIterator"""
4830  return _pcbnew.base_seqVect_iterator(self)
4831 
4832  def __iter__(self):
4833  return self.iterator()
4834 
4835  def __nonzero__(self):
4836  """__nonzero__(base_seqVect self) -> bool"""
4837  return _pcbnew.base_seqVect___nonzero__(self)
4838 
4839 
4840  def __bool__(self):
4841  """__bool__(base_seqVect self) -> bool"""
4842  return _pcbnew.base_seqVect___bool__(self)
4843 
4844 
4845  def __len__(self):
4846  """__len__(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4847  return _pcbnew.base_seqVect___len__(self)
4848 
4849 
4850  def pop(self):
4851  """pop(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type"""
4852  return _pcbnew.base_seqVect_pop(self)
4853 
4854 
4855  def __getslice__(self, i, j):
4856  """__getslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j) -> base_seqVect"""
4857  return _pcbnew.base_seqVect___getslice__(self, i, j)
4858 
4859 
4860  def __setslice__(self, *args):
4861  """
4862  __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)
4863  __setslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)
4864  """
4865  return _pcbnew.base_seqVect___setslice__(self, *args)
4866 
4867 
4868  def __delslice__(self, i, j):
4869  """__delslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)"""
4870  return _pcbnew.base_seqVect___delslice__(self, i, j)
4871 
4872 
4873  def __delitem__(self, *args):
4874  """
4875  __delitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i)
4876  __delitem__(base_seqVect self, PySliceObject * slice)
4877  """
4878  return _pcbnew.base_seqVect___delitem__(self, *args)
4879 
4880 
4881  def __getitem__(self, *args):
4882  """
4883  __getitem__(base_seqVect self, PySliceObject * slice) -> base_seqVect
4884  __getitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i) -> std::vector< enum PCB_LAYER_ID >::value_type const &
4885  """
4886  return _pcbnew.base_seqVect___getitem__(self, *args)
4887 
4888 
4889  def __setitem__(self, *args):
4890  """
4891  __setitem__(base_seqVect self, PySliceObject * slice, base_seqVect v)
4892  __setitem__(base_seqVect self, PySliceObject * slice)
4893  __setitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::value_type const & x)
4894  """
4895  return _pcbnew.base_seqVect___setitem__(self, *args)
4896 
4897 
4898  def append(self, x):
4899  """append(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4900  return _pcbnew.base_seqVect_append(self, x)
4901 
4902 
4903  def empty(self):
4904  """empty(base_seqVect self) -> bool"""
4905  return _pcbnew.base_seqVect_empty(self)
4906 
4907 
4908  def size(self):
4909  """size(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
4910  return _pcbnew.base_seqVect_size(self)
4911 
4912 
4913  def clear(self):
4914  """clear(base_seqVect self)"""
4915  return _pcbnew.base_seqVect_clear(self)
4916 
4917 
4918  def swap(self, v):
4919  """swap(base_seqVect self, base_seqVect v)"""
4920  return _pcbnew.base_seqVect_swap(self, v)
4921 
4922 
4923  def get_allocator(self):
4924  """get_allocator(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::allocator_type"""
4925  return _pcbnew.base_seqVect_get_allocator(self)
4926 
4927 
4928  def begin(self):
4929  """begin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
4930  return _pcbnew.base_seqVect_begin(self)
4931 
4932 
4933  def end(self):
4934  """end(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
4935  return _pcbnew.base_seqVect_end(self)
4936 
4937 
4938  def rbegin(self):
4939  """rbegin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
4940  return _pcbnew.base_seqVect_rbegin(self)
4941 
4942 
4943  def rend(self):
4944  """rend(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
4945  return _pcbnew.base_seqVect_rend(self)
4946 
4947 
4948  def pop_back(self):
4949  """pop_back(base_seqVect self)"""
4950  return _pcbnew.base_seqVect_pop_back(self)
4951 
4952 
4953  def erase(self, *args):
4954  """
4955  erase(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator pos) -> std::vector< enum PCB_LAYER_ID >::iterator
4956  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
4957  """
4958  return _pcbnew.base_seqVect_erase(self, *args)
4959 
4960 
4961  def __init__(self, *args):
4962  """
4963  __init__(std::vector<(enum PCB_LAYER_ID)> self) -> base_seqVect
4964  __init__(std::vector<(enum PCB_LAYER_ID)> self, base_seqVect arg2) -> base_seqVect
4965  __init__(std::vector<(enum PCB_LAYER_ID)> self, std::vector< enum PCB_LAYER_ID >::size_type size) -> base_seqVect
4966  __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
4967  """
4968  this = _pcbnew.new_base_seqVect(*args)
4969  try:
4970  self.this.append(this)
4971  except:
4972  self.this = this
4973 
4974  def push_back(self, x):
4975  """push_back(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4976  return _pcbnew.base_seqVect_push_back(self, x)
4977 
4978 
4979  def front(self):
4980  """front(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
4981  return _pcbnew.base_seqVect_front(self)
4982 
4983 
4984  def back(self):
4985  """back(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
4986  return _pcbnew.base_seqVect_back(self)
4987 
4988 
4989  def assign(self, n, x):
4990  """assign(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
4991  return _pcbnew.base_seqVect_assign(self, n, x)
4992 
4993 
4994  def resize(self, *args):
4995  """
4996  resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size)
4997  resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size, std::vector< enum PCB_LAYER_ID >::value_type const & x)
4998  """
4999  return _pcbnew.base_seqVect_resize(self, *args)
5000 
5001 
5002  def insert(self, *args):
5003  """
5004  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
5005  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)
5006  """
5007  return _pcbnew.base_seqVect_insert(self, *args)
5008 
5009 
5010  def reserve(self, n):
5011  """reserve(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n)"""
5012  return _pcbnew.base_seqVect_reserve(self, n)
5013 
5014 
5015  def capacity(self):
5016  """capacity(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
5017  return _pcbnew.base_seqVect_capacity(self)
5018 
5019  __swig_destroy__ = _pcbnew.delete_base_seqVect
5020  __del__ = lambda self: None
5021 base_seqVect_swigregister = _pcbnew.base_seqVect_swigregister
5022 base_seqVect_swigregister(base_seqVect)
5023 
5024 
5025 
5026 KICAD_PLUGINS={} # the list of loaded footprint wizards
5027 
5028 """ the list of not loaded python scripts
5029  (usually because there is a syntax error in python script)
5030  this is the python script full filenames list.
5031  filenames are separated by '\n'
5032 """
5033 NOT_LOADED_WIZARDS=""
5034 
5035 """ the list of paths used to search python scripts.
5036  Stored here to be displayed on request in Pcbnew
5037  paths are separated by '\n'
5038 """
5039 PLUGIN_DIRECTORIES_SEARCH=""
5040 
5041 """ the trace of errors during execution of footprint wizards scripts
5042 """
5043 FULL_BACK_TRACE=""
5044 
5046  global NOT_LOADED_WIZARDS
5047  return NOT_LOADED_WIZARDS
5048 
5050  global PLUGIN_DIRECTORIES_SEARCH
5051  return PLUGIN_DIRECTORIES_SEARCH
5052 
5054  global FULL_BACK_TRACE
5055  return FULL_BACK_TRACE
5056 
5057 
5058 def LoadOnePlugin(Dirname, ModuleName):
5059  """
5060  Load the plugin file ModuleName found in folder Dirname.
5061  If this file cannot be loaded, its name is stored in failed_wizards_list
5062  and the error trace is stored in FULL_BACK_TRACE
5063  """
5064  import os
5065  import sys
5066  import traceback
5067 
5068  global NOT_LOADED_WIZARDS
5069  global FULL_BACK_TRACE
5070 
5071  module_filename = os.path.join(Dirname, ModuleName)
5072 
5073  try: # If there is an error loading the script, skip it
5074  mtime = os.path.getmtime(module_filename)
5075 
5076  if KICAD_PLUGINS.has_key(ModuleName):
5077  plugin = KICAD_PLUGINS[ModuleName]
5078 
5079  if not plugin["modification_time"] == mtime:
5080  mod = reload(plugin["ModuleName"])
5081  plugin["modification_time"] = mtime
5082  else:
5083  mod = plugin["ModuleName"]
5084  else:
5085  mod = __import__(ModuleName[:-3], locals(), globals() )
5086 
5087  KICAD_PLUGINS[ModuleName]={ "filename":module_filename,
5088  "modification_time":mtime,
5089  "ModuleName":mod }
5090 
5091  except:
5092  if NOT_LOADED_WIZARDS != "" :
5093  NOT_LOADED_WIZARDS += "\n"
5094  NOT_LOADED_WIZARDS += module_filename
5095  FULL_BACK_TRACE += traceback.format_exc(sys.exc_info())
5096  pass
5097 
5098 
5099 
5100 def LoadOneSubdirPlugin(Dirname, SubDirname):
5101  """
5102  Load the plugins found in folder Dirname/SubDirname, by loading __ini__.py file.
5103  If files cannot be loaded, its name is stored in failed_wizards_list
5104  and the error trace is stored in FULL_BACK_TRACE
5105  """
5106  import os
5107  import sys
5108  import traceback
5109 
5110  global NOT_LOADED_WIZARDS
5111  global FULL_BACK_TRACE
5112 
5113  fullPath = os.path.join(Dirname,SubDirname)
5114 
5115  if os.path.isdir(fullPath):
5116  """
5117  Skip subdir which does not contain __init__.py, becuase if can be
5118  a non python subdir (can be a subdir for .xsl plugins for instance)
5119  """
5120  if os.path.exists( os.path.join(fullPath, '__init__.py') ):
5121  try: # If there is an error loading the script, skip it
5122  __import__(SubDirname, locals(), globals())
5123 
5124  except:
5125  if NOT_LOADED_WIZARDS != "" :
5126  NOT_LOADED_WIZARDS += "\n"
5127  NOT_LOADED_WIZARDS += fullPath
5128  FULL_BACK_TRACE += traceback.format_exc(sys.exc_info())
5129  pass
5130 
5131  else:
5132  if NOT_LOADED_WIZARDS != "" :
5133  NOT_LOADED_WIZARDS += "\n"
5134  NOT_LOADED_WIZARDS += 'Skip subdir ' + fullPath
5135 
5136 
5137 def LoadPlugins(bundlepath=None):
5138  """
5139  Initialise Scripting/Plugin python environment and load plugins.
5140 
5141  Arguments:
5142  scriptpath -- The path to the bundled scripts.
5143  The bunbled Plugins are relative to this path, in the
5144  "plugins" subdirectory.
5145 
5146  NOTE: These are all of the possible "default" search paths for kicad
5147  python scripts. These paths will ONLY be added to the python
5148  search path ONLY IF they already exist.
5149 
5150  The Scripts bundled with the KiCad installation:
5151  <bundlepath>/
5152  <bundlepath>/plugins/
5153 
5154  The Scripts relative to the KiCad search path environment variable:
5155  [KICAD_PATH]/scripting/
5156  [KICAD_PATH]/scripting/plugins/
5157 
5158  The Scripts relative to the KiCad Users configuration:
5159  <kicad_config_path>/scripting/
5160  <kicad_config_path>/scripting/plugins/
5161 
5162  And on Linux ONLY, extra paths relative to the users home directory:
5163  ~/.kicad_plugins/
5164  ~/.kicad/scripting/
5165  ~/.kicad/scripting/plugins/
5166  """
5167  import os
5168  import sys
5169  import traceback
5170  import pcbnew
5171 
5172  kicad_path = os.environ.get('KICAD_PATH')
5173  config_path = pcbnew.GetKicadConfigPath()
5174  plugin_directories=[]
5175 
5176  if bundlepath:
5177  plugin_directories.append(bundlepath)
5178  plugin_directories.append(os.path.join(bundlepath, 'plugins'))
5179 
5180  if kicad_path:
5181  plugin_directories.append(os.path.join(kicad_path, 'scripting'))
5182  plugin_directories.append(os.path.join(kicad_path, 'scripting', 'plugins'))
5183 
5184  if config_path:
5185  plugin_directories.append(os.path.join(config_path, 'scripting'))
5186  plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))
5187 
5188  if sys.platform.startswith('linux'):
5189  plugin_directories.append(os.path.join(os.environ['HOME'],'.kicad_plugins'))
5190  plugin_directories.append(os.path.join(os.environ['HOME'],'.kicad','scripting'))
5191  plugin_directories.append(os.path.join(os.environ['HOME'],'.kicad','scripting','plugins'))
5192 
5193  global PLUGIN_DIRECTORIES_SEARCH
5194  PLUGIN_DIRECTORIES_SEARCH=""
5195  for plugins_dir in plugin_directories: # save search path list for later use
5196  if PLUGIN_DIRECTORIES_SEARCH != "" :
5197  PLUGIN_DIRECTORIES_SEARCH += "\n"
5198  PLUGIN_DIRECTORIES_SEARCH += plugins_dir
5199 
5200  global FULL_BACK_TRACE
5201  FULL_BACK_TRACE="" # clear any existing trace
5202 
5203  global NOT_LOADED_WIZARDS
5204  NOT_LOADED_WIZARDS = "" # save not loaded wizards names list for later use
5205 
5206  global KICAD_PLUGINS
5207 
5208  for plugins_dir in plugin_directories:
5209  if not os.path.isdir(plugins_dir):
5210  continue
5211 
5212  sys.path.append(plugins_dir)
5213 
5214  for module in os.listdir(plugins_dir):
5215  if os.path.isdir(os.path.join(plugins_dir,module)):
5216  LoadOneSubdirPlugin(plugins_dir, module)
5217  continue
5218 
5219  if module == '__init__.py' or module[-3:] != '.py':
5220  continue
5221 
5222  LoadOnePlugin(plugins_dir, module);
5223 
5224 
5226  def __init__(self):
5227  pass
5228 
5229  def register(self):
5230  if isinstance(self,FilePlugin):
5231  pass # register to file plugins in C++
5232 
5233  if isinstance(self,FootprintWizardPlugin):
5234  PYTHON_FOOTPRINT_WIZARDS.register_wizard(self)
5235  return
5236 
5237  if isinstance(self,ActionPlugin):
5238  PYTHON_ACTION_PLUGINS.register_action(self)
5239  return
5240 
5241  return
5242 
5243  def deregister(self):
5244  if isinstance(self,FilePlugin):
5245  pass # deregister to file plugins in C++
5246 
5247  if isinstance(self,FootprintWizardPlugin):
5248  PYTHON_FOOTPRINT_WIZARDS.deregister_wizard(self)
5249  return
5250 
5251  if isinstance(self,ActionPlugin):
5252  PYTHON_ACTION_PLUGINS.deregister_action(self)
5253  return
5254 
5255  return
5256 
5257 
5259  def __init__(self):
5260  KiCadPlugin.__init__(self)
5261 
5262 
5263 from math import ceil, floor, sqrt
5264 
5265 uMM = "mm" # Millimetres
5266 uMils = "mils" # Mils
5267 uFloat = "float" # Natural number units (dimensionless)
5268 uInteger = "integer" # Integer (no decimals, numeric, dimensionless)
5269 uBool = "bool" # Boolean value
5270 uRadians = "radians" # Angular units (radians)
5271 uDegrees = "degrees" # Angular units (degrees)
5272 uPercent = "%" # Percent (0% -> 100%)
5273 uString = "string" # Raw string
5274 
5275 uNumeric = [uMM, uMils, uFloat, uInteger, uDegrees, uRadians, uPercent] # List of numeric types
5276 uUnits = [uMM, uMils, uFloat, uInteger, uBool, uDegrees, uRadians, uPercent, uString] # List of allowable types
5277 
5279  _true = ['true','t','y','yes','on','1',1,]
5280  _false = ['false','f','n','no','off','0',0,'',None]
5281 
5282  _bools = _true + _false
5283 
5284  def __init__(self, page, name, units, default, **kwarg):
5285  self.page = page
5286  self.name = name
5287  self.hint = kwarg.get('hint','') # Parameter hint (shown as mouse-over text)
5288  self.designator = kwarg.get('designator',' ') # Parameter designator such as "e, D, p" (etc)
5289 
5290  if units.lower() in uUnits:
5291  self.units = units.lower()
5292  elif units.lower() == 'percent':
5293  self.units = uPercent
5294  elif type(units) in [list, tuple]: # Convert a list of options into a single string
5295  self.units = ",".join([str(el).strip() for el in units])
5296  else:
5297  self.units = units
5298 
5299  self.multiple = int(kwarg.get('multiple',1)) # Check integer values are multiples of this number
5300  self.min_value = kwarg.get('min_value',None) # Check numeric values are above or equal to this number
5301  self.max_value = kwarg.get('max_value',None) # Check numeric values are below or equal to this number
5302 
5303  self.SetValue(default)
5304  self.default = self.raw_value # Save value as default
5305 
5306  def ClearErrors(self):
5307  self.error_list = []
5308 
5309  def AddError(self, err, info=None):
5310 
5311  if err in self.error_list: # prevent duplicate error messages
5312  return
5313  if info is not None:
5314  err = err + " (" + str(info) + ")"
5315 
5316  self.error_list.append(err)
5317 
5318  def Check(self, min_value=None, max_value=None, multiple=None, info=None):
5319 
5320  if min_value is None:
5321  min_value = self.min_value
5322  if max_value is None:
5323  max_value = self.max_value
5324  if multiple is None:
5325  multiple = self.multiple
5326 
5327  if self.units not in uUnits and ',' not in self.units: # Allow either valid units or a list of strings
5328  self.AddError("type '{t}' unknown".format(t=self.units),info)
5329  self.AddError("Allowable types: " + str(self.units),info)
5330 
5331  if self.units in uNumeric:
5332  try:
5333  to_num = float(self.raw_value)
5334 
5335  if min_value is not None: # Check minimum value if it is present
5336  if to_num < min_value:
5337  self.AddError("value '{v}' is below minimum ({m})".format(v=self.raw_value,m=min_value),info)
5338 
5339  if max_value is not None: # Check maximum value if it is present
5340  if to_num > max_value:
5341  self.AddError("value '{v}' is above maximum ({m})".format(v=self.raw_value,m=max_value),info)
5342 
5343  except:
5344  self.AddError("value '{v}' is not of type '{t}'".format(v = self.raw_value, t=self.units),info)
5345 
5346  if self.units == uInteger: # Perform integer specific checks
5347  try:
5348  to_int = int(self.raw_value)
5349 
5350  if multiple is not None and multiple > 1:
5351  if (to_int % multiple) > 0:
5352  self.AddError("value '{v}' is not a multiple of {m}".format(v=self.raw_value,m=multiple),info)
5353  except:
5354  self.AddError("value {'v}' is not an integer".format(v=self.raw_value),info)
5355 
5356  if self.units == uBool: # Check that the value is of a correct boolean format
5357  if self.raw_value in [True,False] or str(self.raw_value).lower() in self._bools:
5358  pass
5359  else:
5360  self.AddError("value '{v}' is not a boolean value".format(v = self.raw_value),info)
5361 
5362  @property
5363  def value(self): # Return the current value, converted to appropriate units (from string representation) if required
5364  v = str(self.raw_value) # Enforce string type for known starting point
5365 
5366  if self.units == uInteger: # Integer values
5367  return int(v)
5368  elif self.units in uNumeric: # Any values that use floating points
5369  v = v.replace(",",".") # Replace "," separators with "."
5370  v = float(v)
5371 
5372  if self.units == uMM: # Convert from millimetres to nanometres
5373  return FromMM(v)
5374 
5375  elif self.units == uMils: # Convert from mils to nanometres
5376  return FromMils(v)
5377 
5378  else: # Any other floating-point values
5379  return v
5380 
5381  elif self.units == uBool:
5382  if v.lower() in self._true:
5383  return True
5384  else:
5385  return False
5386  else:
5387  return v
5388 
5389  def DefaultValue(self): # Reset the value of the parameter to its default
5390  self.raw_value = str(self.default)
5391 
5392  def SetValue(self, new_value): # Update the value
5393  new_value = str(new_value)
5394 
5395  if len(new_value.strip()) == 0:
5396  if not self.units in [uString, uBool]:
5397  return # Ignore empty values unless for strings or bools
5398 
5399  if self.units == uBool: # Enforce the same boolean representation as is used in KiCad
5400  new_value = "1" if new_value.lower() in self._true else "0"
5401  elif self.units in uNumeric:
5402  new_value = new_value.replace(",", ".") # Enforce decimal point separators
5403  elif ',' in self.units: # Select from a list of values
5404  if new_value not in self.units.split(','):
5405  new_value = self.units.split(',')[0]
5406 
5407  self.raw_value = new_value
5408 
5409  def __str__(self): # pretty-print the parameter
5410 
5411  s = self.name + ": " + str(self.raw_value)
5412 
5413  if self.units in [uMM, uMils, uPercent, uRadians, uDegrees]:
5414  s += self.units
5415  elif self.units == uBool: # Special case for Boolean values
5416  s = self.name + ": {b}".format(b = "True" if self.value else "False")
5417  elif self.units == uString:
5418  s = self.name + ": '" + self.raw_value + "'"
5419 
5420  return s
5421 
5422 
5424  def __init__(self):
5425  KiCadPlugin.__init__(self)
5426  self.defaults()
5427 
5428  def defaults(self):
5429  self.module = None
5430  self.params = [] # List of added parameters that observes addition order
5431 
5432  self.name = "KiCad FP Wizard"
5433  self.description = "Undefined Footprint Wizard plugin"
5434  self.image = ""
5435  self.buildmessages = ""
5436 
5437  def AddParam(self, page, name, unit, default, **kwarg):
5438 
5439  if self.GetParam(page,name) is not None: # Param already exists!
5440  return
5441 
5442  param = FootprintWizardParameter(page, name, unit, default, **kwarg) # Create a new parameter
5443  self.params.append(param)
5444 
5445  @property
5446  def parameters(self): # This is a helper function that returns a nested (unordered) dict of the VALUES of parameters
5447  pages = {} # Page dict
5448  for p in self.params:
5449  if p.page not in pages:
5450  pages[p.page] = {}
5451 
5452  pages[p.page][p.name] = p.value # Return the 'converted' value (convert from string to actual useful units)
5453 
5454  return pages
5455 
5456  @property
5457  def values(self): # Same as above
5458  return self.parameters
5459 
5460  def ResetWizard(self): # Reset all parameters to default values
5461  for p in self.params:
5462  p.DefaultValue()
5463 
5464  def GetName(self): # Return the name of this wizard
5465  return self.name
5466 
5467  def GetImage(self): # Return the filename of the preview image associated with this wizard
5468  return self.image
5469 
5470  def GetDescription(self): # Return the description text
5471  return self.description
5472 
5473  def GetValue(self):
5474  raise NotImplementedError
5475 
5477  return "REF" # Default reference prefix for any footprint
5478 
5479  def GetParam(self, page, name): # Grab a parameter
5480  for p in self.params:
5481  if p.page == page and p.name == name:
5482  return p
5483 
5484  return None
5485 
5486  def CheckParam(self, page, name, **kwarg):
5487  self.GetParam(page,name).Check(**kwarg)
5488 
5489  def AnyErrors(self):
5490  return any([len(p.error_list) > 0 for p in self.params])
5491 
5492  @property
5493  def pages(self): # Return an (ordered) list of the available page names
5494  page_list = []
5495  for p in self.params:
5496  if p.page not in page_list:
5497  page_list.append(p.page)
5498 
5499  return page_list
5500 
5501  def GetNumParameterPages(self): # Return the number of parameter pages
5502  return len(self.pages)
5503 
5504  def GetParameterPageName(self,page_n): # Return the name of a page at a given index
5505  return self.pages[page_n]
5506 
5507  def GetParametersByPageName(self, page_name): # Return a list of parameters on a given page
5508  params = []
5509 
5510  for p in self.params:
5511  if p.page == page_name:
5512  params.append(p)
5513 
5514  return params
5515 
5516  def GetParametersByPageIndex(self, page_index): # Return an ordered list of parameters on a given page
5517  return self.GetParametersByPageName(self.GetParameterPageName(page_index))
5518 
5519  def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
5520  params = self.GetParametersByPageIndex(page_index)
5521  return [p.designator for p in params]
5522 
5523  def GetParameterNames(self,page_index): # Return the list of names associated with a given page
5524  params = self.GetParametersByPageIndex(page_index)
5525  return [p.name for p in params]
5526 
5527  def GetParameterValues(self,page_index): # Return the list of values associated with a given page
5528  params = self.GetParametersByPageIndex(page_index)
5529  return [str(p.raw_value) for p in params]
5530 
5531  def GetParameterErrors(self,page_index): # Return list of errors associated with a given page
5532  params = self.GetParametersByPageIndex(page_index)
5533  return [str("\n".join(p.error_list)) for p in params]
5534 
5535  def GetParameterTypes(self, page_index): # Return list of units associated with a given page
5536  params = self.GetParametersByPageIndex(page_index)
5537  return [str(p.units) for p in params]
5538 
5539  def GetParameterHints(self, page_index): # Return a list of units associated with a given page
5540  params = self.GetParametersByPageIndex(page_index)
5541  return [str(p.hint) for p in params]
5542 
5543  def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
5544  params = self.GetParametersByPageIndex(page_index)
5545  return [str(p.designator) for p in params]
5546 
5547  def SetParameterValues(self, page_index, list_of_values): # Update values on a given page
5548 
5549  params = self.GetParametersByPageIndex(page_index)
5550 
5551  for i, param in enumerate(params):
5552  if i >= len(list_of_values):
5553  break
5554  param.SetValue(list_of_values[i])
5555 
5556  def GetFootprint( self ):
5557  self.BuildFootprint()
5558  return self.module
5559 
5560  def BuildFootprint(self):
5561  return
5562 
5563  def GetBuildMessages( self ):
5564  return self.buildmessages
5565 
5566  def Show(self):
5567  text = "Footprint Wizard Name: {name}\n".format(name=self.GetName())
5568  text += "Footprint Wizard Description: {desc}\n".format(desc=self.GetDescription())
5569 
5570  n_pages = self.GetNumParameterPages()
5571 
5572  text += "Pages: {n}\n".format(n=n_pages)
5573 
5574  for i in range(n_pages):
5575  name = self.GetParameterPageName(i)
5576 
5577  params = self.GetParametersByPageName(name)
5578 
5579  text += "{name}\n".format(name=name)
5580 
5581  for j in range(len(params)):
5582  text += ("\t{param}{err}\n".format(
5583  param = str(params[j]),
5584  err = ' *' if len(params[j].error_list) > 0 else ''
5585  ))
5586 
5587  if self.AnyErrors():
5588  text += " * Errors exist for these parameters"
5589 
5590  return text
5591 
5593  def __init__( self ):
5594  KiCadPlugin.__init__( self )
5595  self.defaults()
5596 
5597  def defaults( self ):
5598  self.name = "Undefined Action plugin"
5599  self.category = "Undefined"
5600  self.description = ""
5601 
5602  def GetName( self ):
5603  return self.name
5604 
5605  def GetCategoryName( self ):
5606  return self.category
5607 
5608  def GetDescription( self ):
5609  return self.description
5610 
5611  def Run(self):
5612  return
5613 
5614 
5615 class CSegment(_object):
5616  """C++ includes: PolyLine.h """
5617  __swig_setmethods__ = {}
5618  __setattr__ = lambda self, name, value: _swig_setattr(self, CSegment, name, value)
5619  __swig_getmethods__ = {}
5620  __getattr__ = lambda self, name: _swig_getattr(self, CSegment, name)
5621  __repr__ = _swig_repr
5622  __swig_setmethods__["m_Start"] = _pcbnew.CSegment_m_Start_set
5623  __swig_getmethods__["m_Start"] = _pcbnew.CSegment_m_Start_get
5624  if _newclass:
5625  m_Start = _swig_property(_pcbnew.CSegment_m_Start_get, _pcbnew.CSegment_m_Start_set)
5626  __swig_setmethods__["m_End"] = _pcbnew.CSegment_m_End_set
5627  __swig_getmethods__["m_End"] = _pcbnew.CSegment_m_End_get
5628  if _newclass:
5629  m_End = _swig_property(_pcbnew.CSegment_m_End_get, _pcbnew.CSegment_m_End_set)
5630 
5631  def __init__(self, *args):
5632  """
5633  __init__(CSegment self) -> CSegment
5634  __init__(CSegment self, wxPoint aStart, wxPoint aEnd) -> CSegment
5635  __init__(CSegment self, int x0, int y0, int x1, int y1) -> CSegment
5636 
5637  CSegment::CSegment(int x0,
5638  int y0, int x1, int y1)
5639  """
5640  this = _pcbnew.new_CSegment(*args)
5641  try:
5642  self.this.append(this)
5643  except:
5644  self.this = this
5645  __swig_destroy__ = _pcbnew.delete_CSegment
5646  __del__ = lambda self: None
5647 CSegment_swigregister = _pcbnew.CSegment_swigregister
5648 CSegment_swigregister(CSegment)
5649 
5651  """C++ includes: PolyLine.h """
5652  __swig_setmethods__ = {}
5653  for _s in [wxPoint]:
5654  __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
5655  __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyPt, name, value)
5656  __swig_getmethods__ = {}
5657  for _s in [wxPoint]:
5658  __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
5659  __getattr__ = lambda self, name: _swig_getattr(self, CPolyPt, name)
5660  __repr__ = _swig_repr
5661 
5662  def __init__(self, *args):
5663  """
5664  __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False, int aUtility=0) -> CPolyPt
5665  __init__(CPolyPt self, int aX=0, int aY=0, bool aEnd=False) -> CPolyPt
5666  __init__(CPolyPt self, int aX=0, int aY=0) -> CPolyPt
5667  __init__(CPolyPt self, int aX=0) -> CPolyPt
5668  __init__(CPolyPt self) -> CPolyPt
5669  __init__(CPolyPt self, CPolyPt aPt) -> CPolyPt
5670  __init__(CPolyPt self, wxPoint aPoint) -> CPolyPt
5671 
5672  CPolyPt::CPolyPt(const
5673  wxPoint &aPoint)
5674  """
5675  this = _pcbnew.new_CPolyPt(*args)
5676  try:
5677  self.this.append(this)
5678  except:
5679  self.this = this
5680  __swig_setmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_set
5681  __swig_getmethods__["end_contour"] = _pcbnew.CPolyPt_end_contour_get
5682  if _newclass:
5683  end_contour = _swig_property(_pcbnew.CPolyPt_end_contour_get, _pcbnew.CPolyPt_end_contour_set)
5684  __swig_setmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_set
5685  __swig_getmethods__["m_flags"] = _pcbnew.CPolyPt_m_flags_get
5686  if _newclass:
5687  m_flags = _swig_property(_pcbnew.CPolyPt_m_flags_get, _pcbnew.CPolyPt_m_flags_set)
5688 
5689  def __eq__(self, cpt2):
5690  """__eq__(CPolyPt self, CPolyPt cpt2) -> bool"""
5691  return _pcbnew.CPolyPt___eq__(self, cpt2)
5692 
5693 
5694  def __ne__(self, cpt2):
5695  """__ne__(CPolyPt self, CPolyPt cpt2) -> bool"""
5696  return _pcbnew.CPolyPt___ne__(self, cpt2)
5697 
5698  __swig_destroy__ = _pcbnew.delete_CPolyPt
5699  __del__ = lambda self: None
5700 CPolyPt_swigregister = _pcbnew.CPolyPt_swigregister
5701 CPolyPt_swigregister(CPolyPt)
5702 
5704  """C++ includes: PolyLine.h """
5705  __swig_setmethods__ = {}
5706  __setattr__ = lambda self, name, value: _swig_setattr(self, CPolyLine, name, value)
5707  __swig_getmethods__ = {}
5708  __getattr__ = lambda self, name: _swig_getattr(self, CPolyLine, name)
5709  __repr__ = _swig_repr
5710  NO_HATCH = _pcbnew.CPolyLine_NO_HATCH
5711  DIAGONAL_FULL = _pcbnew.CPolyLine_DIAGONAL_FULL
5712  DIAGONAL_EDGE = _pcbnew.CPolyLine_DIAGONAL_EDGE
5713 
5714  def __init__(self, *args):
5715  """
5716  __init__(CPolyLine self) -> CPolyLine
5717  __init__(CPolyLine self, CPolyLine aCPolyLine) -> CPolyLine
5718 
5719  CPolyLine::CPolyLine(const CPolyLine &aCPolyLine)
5720  """
5721  this = _pcbnew.new_CPolyLine(*args)
5722  try:
5723  self.this.append(this)
5724  except:
5725  self.this = this
5726  __swig_destroy__ = _pcbnew.delete_CPolyLine
5727  __del__ = lambda self: None
5728 
5729  def ImportSettings(self, aPoly):
5730  """
5731  ImportSettings(CPolyLine self, CPolyLine aPoly)
5732 
5733  void
5734  CPolyLine::ImportSettings(const CPolyLine *aPoly)
5735 
5736  Function ImportSettings Copy settings (layer, hatch styles) from
5737  aPoly.
5738 
5739  Parameters:
5740  -----------
5741 
5742  aPoly: is the CPolyLine to import settings
5743  """
5744  return _pcbnew.CPolyLine_ImportSettings(self, aPoly)
5745 
5746 
5747  def Start(self, layer, x, y, hatch):
5748  """
5749  Start(CPolyLine self, LAYER_NUM layer, int x, int y, int hatch)
5750 
5751  void
5752  CPolyLine::Start(LAYER_NUM layer, int x, int y, int hatch)
5753  """
5754  return _pcbnew.CPolyLine_Start(self, layer, x, y, hatch)
5755 
5756 
5757  def AppendCorner(self, x, y):
5758  """
5759  AppendCorner(CPolyLine self, int x, int y)
5760 
5761  void
5762  CPolyLine::AppendCorner(int x, int y)
5763  """
5764  return _pcbnew.CPolyLine_AppendCorner(self, x, y)
5765 
5766 
5767  def InsertCorner(self, ic, x, y):
5768  """
5769  InsertCorner(CPolyLine self, int ic, int x, int y)
5770 
5771  void
5772  CPolyLine::InsertCorner(int ic, int x, int y)
5773 
5774  Function InsertCorner insert a new corner between two existing
5775  corners.
5776 
5777  Parameters:
5778  -----------
5779 
5780  ic: = index for the insertion point: the corner is inserted AFTER ic
5781 
5782  x: y: = coordinates corner to insert
5783  """
5784  return _pcbnew.CPolyLine_InsertCorner(self, ic, x, y)
5785 
5786 
5787  def DeleteCorner(self, ic):
5788  """
5789  DeleteCorner(CPolyLine self, int ic)
5790 
5791  void
5792  CPolyLine::DeleteCorner(int ic)
5793 
5794  Function DeleteCorner remove the given corner.
5795 
5796  if it is the last point of a contour keep the controur closed by
5797  modifying the previous corner
5798 
5799  Parameters:
5800  -----------
5801 
5802  ic: = the index of the corner to delete
5803  """
5804  return _pcbnew.CPolyLine_DeleteCorner(self, ic)
5805 
5806 
5807  def MoveCorner(self, ic, x, y):
5808  """
5809  MoveCorner(CPolyLine self, int ic, int x, int y)
5810 
5811  void
5812  CPolyLine::MoveCorner(int ic, int x, int y)
5813  """
5814  return _pcbnew.CPolyLine_MoveCorner(self, ic, x, y)
5815 
5816 
5817  def CloseLastContour(self):
5818  """
5819  CloseLastContour(CPolyLine self)
5820 
5821  void
5822  CPolyLine::CloseLastContour()
5823 
5824  function CloseLastContour Set the .end_contour member of the last
5825  corner of the last contour to true
5826  """
5827  return _pcbnew.CPolyLine_CloseLastContour(self)
5828 
5829 
5830  def RemoveContour(self, icont):
5831  """
5832  RemoveContour(CPolyLine self, int icont)
5833 
5834  void
5835  CPolyLine::RemoveContour(int icont)
5836 
5837  Function RemoveContour.
5838 
5839  Parameters:
5840  -----------
5841 
5842  icont: = contour number to remove remove a contour only if there is
5843  more than 1 contour
5844  """
5845  return _pcbnew.CPolyLine_RemoveContour(self, icont)
5846 
5847 
5849  """
5850  IsPolygonSelfIntersecting(CPolyLine self) -> bool
5851 
5852  bool
5853  CPolyLine::IsPolygonSelfIntersecting()
5854 
5855  Function IsPolygonSelfIntersecting Test a CPolyLine for self-
5856  intersection of vertex (all contours).
5857 
5858  : false if no intersecting sides true if intersecting sides When a
5859  CPolyLine is self intersectic, it need to be normalized. (converted to
5860  non intersecting polygons)
5861  """
5862  return _pcbnew.CPolyLine_IsPolygonSelfIntersecting(self)
5863 
5864 
5865  def Chamfer(self, aDistance):
5866  """
5867  Chamfer(CPolyLine self, unsigned int aDistance) -> CPolyLine
5868 
5869  CPolyLine *
5870  CPolyLine::Chamfer(unsigned int aDistance)
5871 
5872  Function Chamfer returns a chamfered version of a polygon.
5873 
5874  Parameters:
5875  -----------
5876 
5877  aDistance: is the chamfering distance.
5878 
5879  CPolyLine* - Pointer to new polygon.
5880  """
5881  return _pcbnew.CPolyLine_Chamfer(self, aDistance)
5882 
5883 
5884  def Fillet(self, aRadius, aSegments):
5885  """
5886  Fillet(CPolyLine self, unsigned int aRadius, unsigned int aSegments) -> CPolyLine
5887 
5888  CPolyLine *
5889  CPolyLine::Fillet(unsigned int aRadius, unsigned int aSegments)
5890 
5891  Function Fillet returns a filleted version of a polygon.
5892 
5893  Parameters:
5894  -----------
5895 
5896  aRadius: is the fillet radius.
5897 
5898  aSegments: is the number of segments / fillet.
5899 
5900  CPolyLine* - Pointer to new polygon.
5901  """
5902  return _pcbnew.CPolyLine_Fillet(self, aRadius, aSegments)
5903 
5904 
5906  """
5907  RemoveNullSegments(CPolyLine self) -> int
5908 
5909  int
5910  CPolyLine::RemoveNullSegments()
5911 
5912  Function RemoveNullSegments Removes corners which create a null
5913  segment edge (i.e.
5914 
5915  when 2 successive corners are at the same location) the count of
5916  removed corners.
5917  """
5918  return _pcbnew.CPolyLine_RemoveNullSegments(self)
5919 
5920 
5922  """
5923  RemoveAllContours(CPolyLine self)
5924 
5925  void
5926  CPolyLine::RemoveAllContours(void)
5927 
5928  function RemoveAllContours removes all corners from the list.
5929 
5930  Others params are not changed
5931  """
5932  return _pcbnew.CPolyLine_RemoveAllContours(self)
5933 
5934 
5935  def UnHatch(self):
5936  """
5937  UnHatch(CPolyLine self)
5938 
5939  void CPolyLine::UnHatch()
5940 
5941  """
5942  return _pcbnew.CPolyLine_UnHatch(self)
5943 
5944 
5945  def Hatch(self):
5946  """
5947  Hatch(CPolyLine self)
5948 
5949  void CPolyLine::Hatch()
5950  """
5951  return _pcbnew.CPolyLine_Hatch(self)
5952 
5953 
5954  def MoveOrigin(self, x_off, y_off):
5955  """
5956  MoveOrigin(CPolyLine self, int x_off, int y_off)
5957 
5958  void
5959  CPolyLine::MoveOrigin(int x_off, int y_off)
5960  """
5961  return _pcbnew.CPolyLine_MoveOrigin(self, x_off, y_off)
5962 
5963 
5964  def GetBoundingBox(self, *args):
5965  """
5966  GetBoundingBox(CPolyLine self) -> EDA_RECT
5967  GetBoundingBox(CPolyLine self, int icont) -> EDA_RECT
5968 
5969  const EDA_RECT
5970  CPolyLine::GetBoundingBox(int icont)
5971 
5972  the bounding box of a given polygon
5973 
5974  Parameters:
5975  -----------
5976 
5977  icont: = the index of the polygon contour (0 = main contour, 1 ... n
5978  = other contours, usually holes)
5979  """
5980  return _pcbnew.CPolyLine_GetBoundingBox(self, *args)
5981 
5982 
5983  def Copy(self, src):
5984  """
5985  Copy(CPolyLine self, CPolyLine src)
5986 
5987  void CPolyLine::Copy(const
5988  CPolyLine *src)
5989  """
5990  return _pcbnew.CPolyLine_Copy(self, src)
5991 
5992 
5993  def TestPointInside(self, x, y):
5994  """
5995  TestPointInside(CPolyLine self, int x, int y) -> bool
5996 
5997  bool
5998  CPolyLine::TestPointInside(int x, int y)
5999  """
6000  return _pcbnew.CPolyLine_TestPointInside(self, x, y)
6001 
6002 
6003  def IsCutoutContour(self, aCornerIdx):
6004  """
6005  IsCutoutContour(CPolyLine self, int aCornerIdx) -> bool
6006 
6007  bool
6008  CPolyLine::IsCutoutContour(int aCornerIdx)
6009 
6010  true if the corner aCornerIdx is on a hole inside the main outline and
6011  false if it is on the main outline
6012  """
6013  return _pcbnew.CPolyLine_IsCutoutContour(self, aCornerIdx)
6014 
6015 
6016  def AppendArc(self, xi, yi, xf, yf, xc, yc, num):
6017  """
6018  AppendArc(CPolyLine self, int xi, int yi, int xf, int yf, int xc, int yc, int num)
6019 
6020  void
6021  CPolyLine::AppendArc(int xi, int yi, int xf, int yf, int xc, int yc,
6022  int num)
6023 
6024  Function AppendArc.
6025 
6026  Adds segments to current contour to approximate the given arc
6027  """
6028  return _pcbnew.CPolyLine_AppendArc(self, xi, yi, xf, yf, xc, yc, num)
6029 
6030 
6031  def SetLayer(self, aLayer):
6032  """
6033  SetLayer(CPolyLine self, LAYER_NUM aLayer)
6034 
6035  void
6036  CPolyLine::SetLayer(LAYER_NUM aLayer)
6037  """
6038  return _pcbnew.CPolyLine_SetLayer(self, aLayer)
6039 
6040 
6041  def GetLayer(self):
6042  """
6043  GetLayer(CPolyLine self) -> LAYER_NUM
6044 
6045  LAYER_NUM
6046  CPolyLine::GetLayer() const
6047  """
6048  return _pcbnew.CPolyLine_GetLayer(self)
6049 
6050 
6051  def GetCornersCount(self):
6052  """
6053  GetCornersCount(CPolyLine self) -> int
6054 
6055  int
6056  CPolyLine::GetCornersCount() const
6057  """
6058  return _pcbnew.CPolyLine_GetCornersCount(self)
6059 
6060 
6061  def GetClosed(self):
6062  """
6063  GetClosed(CPolyLine self) -> bool
6064 
6065  bool
6066  CPolyLine::GetClosed()
6067 
6068  true if the last corner in corners list is flagged end_contour
6069  """
6070  return _pcbnew.CPolyLine_GetClosed(self)
6071 
6072 
6073  def GetContoursCount(self):
6074  """
6075  GetContoursCount(CPolyLine self) -> int
6076 
6077  int
6078  CPolyLine::GetContoursCount() const
6079 
6080  Function GetContoursCount.
6081 
6082  the number of polygons stored in list (number of corners flagged
6083  "end_contour"
6084  """
6085  return _pcbnew.CPolyLine_GetContoursCount(self)
6086 
6087 
6088  def GetContour(self, ic):
6089  """
6090  GetContour(CPolyLine self, int ic) -> int
6091 
6092  int
6093  CPolyLine::GetContour(int ic)
6094 
6095  Function GetContour.
6096 
6097  the contour number containing the corner ic
6098 
6099  Parameters:
6100  -----------
6101 
6102  ic: = the index of the corner in the corner list
6103  """
6104  return _pcbnew.CPolyLine_GetContour(self, ic)
6105 
6106 
6107  def GetContourStart(self, icont):
6108  """
6109  GetContourStart(CPolyLine self, int icont) -> int
6110 
6111  int
6112  CPolyLine::GetContourStart(int icont)
6113 
6114  Function GetContourStart.
6115 
6116  the index of the first corner (in corners list) of a contour
6117 
6118  Parameters:
6119  -----------
6120 
6121  icont: = the index of the contour
6122  """
6123  return _pcbnew.CPolyLine_GetContourStart(self, icont)
6124 
6125 
6126  def GetContourEnd(self, icont):
6127  """
6128  GetContourEnd(CPolyLine self, int icont) -> int
6129 
6130  int
6131  CPolyLine::GetContourEnd(int icont)
6132 
6133  Function GetContourEnd.
6134 
6135  the index of the last corner (in corners list) of a contour
6136 
6137  Parameters:
6138  -----------
6139 
6140  icont: = the index of the contour
6141  """
6142  return _pcbnew.CPolyLine_GetContourEnd(self, icont)
6143 
6144 
6145  def GetContourSize(self, icont):
6146  """
6147  GetContourSize(CPolyLine self, int icont) -> int
6148 
6149  int
6150  CPolyLine::GetContourSize(int icont)
6151 
6152  Function GetContourSize.
6153 
6154  the corners count of a contour
6155 
6156  Parameters:
6157  -----------
6158 
6159  icont: = the index of the contour
6160  """
6161  return _pcbnew.CPolyLine_GetContourSize(self, icont)
6162 
6163 
6164  def GetX(self, ic):
6165  """
6166  GetX(CPolyLine self, int ic) -> int
6167 
6168  int CPolyLine::GetX(int ic)
6169  const
6170  """
6171  return _pcbnew.CPolyLine_GetX(self, ic)
6172 
6173 
6174  def GetY(self, ic):
6175  """
6176  GetY(CPolyLine self, int ic) -> int
6177 
6178  int CPolyLine::GetY(int ic)
6179  const
6180  """
6181  return _pcbnew.CPolyLine_GetY(self, ic)
6182 
6183