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