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