]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


23629f0e4cc717c1068345541f27ab252f1b59cd
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= __core.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init__core
1478
1479 #define SWIG_name "__core"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString wxFileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2633
2634 void wxApp_CleanUp() {
2635 __wxPyCleanup();
2636 }
2637
2638
2639 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2640
2641
2642 SWIGINTERNSHORT int
2643 SWIG_AsCharPtr(PyObject *obj, char **val)
2644 {
2645 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2646 return 1;
2647 }
2648 if (val) {
2649 PyErr_Clear();
2650 SWIG_type_error("char *", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERN PyObject *
2657 SWIG_FromCharPtr(const char* cptr)
2658 {
2659 if (cptr) {
2660 size_t size = strlen(cptr);
2661 if (size > INT_MAX) {
2662 return SWIG_NewPointerObj((char*)(cptr),
2663 SWIG_TypeQuery("char *"), 0);
2664 } else {
2665 if (size != 0) {
2666 return PyString_FromStringAndSize(cptr, size);
2667 } else {
2668 return PyString_FromString(cptr);
2669 }
2670 }
2671 }
2672 Py_INCREF(Py_None);
2673 return Py_None;
2674 }
2675
2676
2677 #ifdef __WXMAC__
2678
2679 // A dummy class that raises an exception if used...
2680 class wxEventLoop
2681 {
2682 public:
2683 wxEventLoop() { wxPyRaiseNotImplemented(); }
2684 int Run() { return 0; }
2685 void Exit(int rc = 0) {}
2686 bool Pending() const { return false; }
2687 bool Dispatch() { return false; }
2688 bool IsRunning() const { return false; }
2689 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2690 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2691 };
2692
2693 #else
2694
2695 #include <wx/evtloop.h>
2696
2697 #endif
2698
2699
2700
2701 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2702 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2703 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2704 static PyObject *wxWindow_GetChildren(wxWindow *self){
2705 wxWindowList& list = self->GetChildren();
2706 return wxPy_ConvertList(&list);
2707 }
2708 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2709 #if wxUSE_HOTKEY
2710 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2711 #else
2712 return false;
2713 #endif
2714 }
2715 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2716
2717
2718
2719 return false;
2720
2721 }
2722 static long wxWindow_GetHandle(wxWindow *self){
2723 return wxPyGetWinHandle(self);
2724 }
2725 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2726 self->AssociateHandle((WXWidget)handle);
2727 }
2728
2729 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2730 return wxWindow::FindWindowById(id, parent);
2731 }
2732
2733 wxWindow* wxFindWindowByName( const wxString& name,
2734 const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowByName(name, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByLabel( const wxString& label,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByLabel(label, parent);
2741 }
2742
2743
2744 #ifdef __WXMSW__
2745 #include <wx/msw/private.h> // to get wxGetWindowId
2746 #endif
2747
2748
2749 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2750 #ifdef __WXMSW__
2751 WXHWND hWnd = (WXHWND)_hWnd;
2752 long id = wxGetWindowId(hWnd);
2753 wxWindow* win = new wxWindow;
2754 parent->AddChild(win);
2755 win->SetEventHandler(win);
2756 win->SetHWND(hWnd);
2757 win->SetId(id);
2758 win->SubclassWin(hWnd);
2759 win->AdoptAttributesFromHWND();
2760 win->SetupColours();
2761 return win;
2762 #else
2763 wxPyRaiseNotImplemented();
2764 return NULL;
2765 #endif
2766 }
2767
2768
2769 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2772
2773 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2774
2775 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2776 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2777 wxMenuItemList& list = self->GetMenuItems();
2778 return wxPy_ConvertList(&list);
2779 }
2780 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2781 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2782 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2783 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2784 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2785 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2786 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2787 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2788 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2789 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2790 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2791 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2792 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2793 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2794 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2795 static const wxString wxPyControlNameStr(wxControlNameStr);
2796 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2797 if (clientData) {
2798 wxPyClientData* data = new wxPyClientData(clientData);
2799 return self->Append(item, data);
2800 } else
2801 return self->Append(item);
2802 }
2803 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2804 if (clientData) {
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 return self->Insert(item, pos, data);
2807 } else
2808 return self->Insert(item, pos);
2809 }
2810 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2811 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2812 if (data) {
2813 Py_INCREF(data->m_obj);
2814 return data->m_obj;
2815 } else {
2816 Py_INCREF(Py_None);
2817 return Py_None;
2818 }
2819 }
2820 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2821 wxPyClientData* data = new wxPyClientData(clientData);
2822 self->SetClientObject(n, data);
2823 }
2824
2825
2826 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2827 wxPyUserData* data = NULL;
2828 if ( userData ) {
2829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2830 data = new wxPyUserData(userData);
2831 wxPyEndBlockThreads(blocked);
2832 }
2833 return new wxSizerItem(window, proportion, flag, border, data);
2834 }
2835 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2836 wxPyUserData* data = NULL;
2837 if ( userData ) {
2838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2839 data = new wxPyUserData(userData);
2840 wxPyEndBlockThreads(blocked);
2841 }
2842 return new wxSizerItem(width, height, proportion, flag, border, data);
2843 }
2844 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2845 wxPyUserData* data = NULL;
2846 if ( userData ) {
2847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2848 data = new wxPyUserData(userData);
2849 wxPyEndBlockThreads(blocked);
2850 }
2851 return new wxSizerItem(sizer, proportion, flag, border, data);
2852 }
2853
2854 #include <float.h>
2855 SWIGINTERN int
2856 SWIG_CheckDoubleInRange(double value, double min_value,
2857 double max_value, const char* errmsg)
2858 {
2859 if (value < min_value) {
2860 if (errmsg) {
2861 PyErr_Format(PyExc_OverflowError,
2862 "value %g is less than %s minimum %g",
2863 value, errmsg, min_value);
2864 }
2865 return 0;
2866 } else if (value > max_value) {
2867 if (errmsg) {
2868 PyErr_Format(PyExc_OverflowError,
2869 "value %g is greater than %s maximum %g",
2870 value, errmsg, max_value);
2871 }
2872 return 0;
2873 }
2874 return 1;
2875 }
2876
2877
2878 SWIGINTERN int
2879 SWIG_AsVal_float(PyObject *obj, float *val)
2880 {
2881 const char* errmsg = val ? "float" : (char*)0;
2882 double v;
2883 if (SWIG_AsVal_double(obj, &v)) {
2884 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2885 if (val) *val = (float)(v);
2886 return 1;
2887 } else {
2888 return 0;
2889 }
2890 } else {
2891 PyErr_Clear();
2892 }
2893 if (val) {
2894 SWIG_type_error(errmsg, obj);
2895 }
2896 return 0;
2897 }
2898
2899
2900 SWIGINTERNSHORT float
2901 SWIG_As_float(PyObject* obj)
2902 {
2903 float v;
2904 if (!SWIG_AsVal_float(obj, &v)) {
2905 /*
2906 this is needed to make valgrind/purify happier.
2907 */
2908 memset((void*)&v, 0, sizeof(float));
2909 }
2910 return v;
2911 }
2912
2913
2914 SWIGINTERNSHORT int
2915 SWIG_Check_float(PyObject* obj)
2916 {
2917 return SWIG_AsVal_float(obj, (float*)0);
2918 }
2919
2920
2921 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2922 #define SWIG_From_float PyFloat_FromDouble
2923 /*@@*/
2924
2925 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2926 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2927 if (data) {
2928 Py_INCREF(data->m_obj);
2929 return data->m_obj;
2930 } else {
2931 Py_INCREF(Py_None);
2932 return Py_None;
2933 }
2934 }
2935
2936 // Figure out the type of the sizer item
2937
2938 struct wxPySizerItemInfo {
2939 wxPySizerItemInfo()
2940 : window(NULL), sizer(NULL), gotSize(false),
2941 size(wxDefaultSize), gotPos(false), pos(-1)
2942 {}
2943
2944 wxWindow* window;
2945 wxSizer* sizer;
2946 bool gotSize;
2947 wxSize size;
2948 bool gotPos;
2949 int pos;
2950 };
2951
2952 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2953
2954 wxPySizerItemInfo info;
2955 wxSize size;
2956 wxSize* sizePtr = &size;
2957
2958 // Find out what the type of the item is
2959 // try wxWindow
2960 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2961 PyErr_Clear();
2962 info.window = NULL;
2963
2964 // try wxSizer
2965 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2966 PyErr_Clear();
2967 info.sizer = NULL;
2968
2969 // try wxSize or (w,h)
2970 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2971 info.size = *sizePtr;
2972 info.gotSize = true;
2973 }
2974
2975 // or a single int
2976 if (checkIdx && PyInt_Check(item)) {
2977 info.pos = PyInt_AsLong(item);
2978 info.gotPos = true;
2979 }
2980 }
2981 }
2982
2983 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2984 // no expected type, figure out what kind of error message to generate
2985 if ( !checkSize && !checkIdx )
2986 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2987 else if ( checkSize && !checkIdx )
2988 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2989 else if ( !checkSize && checkIdx)
2990 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2991 else
2992 // can this one happen?
2993 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2994 }
2995
2996 return info;
2997 }
2998
2999 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3000 if (!self->GetClientObject())
3001 self->SetClientObject(new wxPyOORClientData(_self));
3002 }
3003 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3004
3005 wxPyUserData* data = NULL;
3006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3007 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3008 if ( userData && (info.window || info.sizer || info.gotSize) )
3009 data = new wxPyUserData(userData);
3010 wxPyEndBlockThreads(blocked);
3011
3012 // Now call the real Add method if a valid item type was found
3013 if ( info.window )
3014 return self->Add(info.window, proportion, flag, border, data);
3015 else if ( info.sizer )
3016 return self->Add(info.sizer, proportion, flag, border, data);
3017 else if (info.gotSize)
3018 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3019 proportion, flag, border, data);
3020 else
3021 return NULL;
3022 }
3023 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3024
3025 wxPyUserData* data = NULL;
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3028 if ( userData && (info.window || info.sizer || info.gotSize) )
3029 data = new wxPyUserData(userData);
3030 wxPyEndBlockThreads(blocked);
3031
3032 // Now call the real Insert method if a valid item type was found
3033 if ( info.window )
3034 return self->Insert(before, info.window, proportion, flag, border, data);
3035 else if ( info.sizer )
3036 return self->Insert(before, info.sizer, proportion, flag, border, data);
3037 else if (info.gotSize)
3038 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3039 proportion, flag, border, data);
3040 else
3041 return NULL;
3042 }
3043 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3044
3045 wxPyUserData* data = NULL;
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3048 if ( userData && (info.window || info.sizer || info.gotSize) )
3049 data = new wxPyUserData(userData);
3050 wxPyEndBlockThreads(blocked);
3051
3052 // Now call the real Prepend method if a valid item type was found
3053 if ( info.window )
3054 return self->Prepend(info.window, proportion, flag, border, data);
3055 else if ( info.sizer )
3056 return self->Prepend(info.sizer, proportion, flag, border, data);
3057 else if (info.gotSize)
3058 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3059 proportion, flag, border, data);
3060 else
3061 return NULL;
3062 }
3063 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3066 wxPyEndBlockThreads(blocked);
3067 if ( info.window )
3068 return self->Remove(info.window);
3069 else if ( info.sizer )
3070 return self->Remove(info.sizer);
3071 else if ( info.gotPos )
3072 return self->Remove(info.pos);
3073 else
3074 return false;
3075 }
3076 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3079 wxPyEndBlockThreads(blocked);
3080 if ( info.window )
3081 return self->Detach(info.window);
3082 else if ( info.sizer )
3083 return self->Detach(info.sizer);
3084 else if ( info.gotPos )
3085 return self->Detach(info.pos);
3086 else
3087 return false;
3088 }
3089 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3092 wxPyEndBlockThreads(blocked);
3093 if ( info.window )
3094 return self->GetItem(info.window);
3095 else if ( info.sizer )
3096 return self->GetItem(info.sizer);
3097 else if ( info.gotPos )
3098 return self->GetItem(info.pos);
3099 else
3100 return NULL;
3101 }
3102 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3105 wxPyEndBlockThreads(blocked);
3106 if ( info.window )
3107 self->SetItemMinSize(info.window, size);
3108 else if ( info.sizer )
3109 self->SetItemMinSize(info.sizer, size);
3110 else if ( info.gotPos )
3111 self->SetItemMinSize(info.pos, size);
3112 }
3113 static PyObject *wxSizer_GetChildren(wxSizer *self){
3114 wxSizerItemList& list = self->GetChildren();
3115 return wxPy_ConvertList(&list);
3116 }
3117 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3119 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3120 wxPyEndBlockThreads(blocked);
3121 if ( info.window )
3122 return self->Show(info.window, show, recursive);
3123 else if ( info.sizer )
3124 return self->Show(info.sizer, show, recursive);
3125 else if ( info.gotPos )
3126 return self->Show(info.pos, show);
3127 else
3128 return false;
3129 }
3130 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3131 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3132 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3133 wxPyEndBlockThreads(blocked);
3134 if ( info.window )
3135 return self->IsShown(info.window);
3136 else if ( info.sizer )
3137 return self->IsShown(info.sizer);
3138 else if ( info.gotPos )
3139 return self->IsShown(info.pos);
3140 else
3141 return false;
3142 }
3143
3144 // See pyclasses.h
3145 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3146 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3147 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3148
3149
3150
3151
3152 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3153 {
3154 if (source == Py_None) {
3155 **obj = wxGBPosition(-1,-1);
3156 return true;
3157 }
3158 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3159 }
3160
3161 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3162 {
3163 if (source == Py_None) {
3164 **obj = wxGBSpan(-1,-1);
3165 return true;
3166 }
3167 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3168 }
3169
3170
3171 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3172 self->SetRow(row);
3173 self->SetCol(col);
3174 }
3175 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3177 PyObject* tup = PyTuple_New(2);
3178 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3179 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3180 wxPyEndBlockThreads(blocked);
3181 return tup;
3182 }
3183 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3184 self->SetRowspan(rowspan);
3185 self->SetColspan(colspan);
3186 }
3187 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3189 PyObject* tup = PyTuple_New(2);
3190 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3191 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3192 wxPyEndBlockThreads(blocked);
3193 return tup;
3194 }
3195 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3196 wxPyUserData* data = NULL;
3197 if ( userData ) {
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 data = new wxPyUserData(userData);
3200 wxPyEndBlockThreads(blocked);
3201 }
3202 return new wxGBSizerItem(window, pos, span, flag, border, data);
3203 }
3204 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3205 wxPyUserData* data = NULL;
3206 if ( userData ) {
3207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3208 data = new wxPyUserData(userData);
3209 wxPyEndBlockThreads(blocked);
3210 }
3211 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3212 }
3213 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3214 wxPyUserData* data = NULL;
3215 if ( userData ) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3221 }
3222 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3223 int row, col;
3224 self->GetEndPos(row, col);
3225 return wxGBPosition(row, col);
3226 }
3227 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3228
3229 wxPyUserData* data = NULL;
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3232 if ( userData && (info.window || info.sizer || info.gotSize) )
3233 data = new wxPyUserData(userData);
3234 wxPyEndBlockThreads(blocked);
3235
3236 // Now call the real Add method if a valid item type was found
3237 if ( info.window )
3238 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3239 else if ( info.sizer )
3240 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3241 else if (info.gotSize)
3242 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3243 pos, span, flag, border, data);
3244 return NULL;
3245 }
3246
3247
3248 #ifdef __cplusplus
3249 extern "C" {
3250 #endif
3251 static int _wrap_EmptyString_set(PyObject *) {
3252 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3253 return 1;
3254 }
3255
3256
3257 static PyObject *_wrap_EmptyString_get(void) {
3258 PyObject *pyobj;
3259
3260 {
3261 #if wxUSE_UNICODE
3262 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3263 #else
3264 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3265 #endif
3266 }
3267 return pyobj;
3268 }
3269
3270
3271 static PyObject *_wrap_wxObject_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 wxString result;
3275 PyObject * obj0 = 0 ;
3276 char *kwnames[] = {
3277 (char *) "self", NULL
3278 };
3279
3280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxObject_GetClassName",kwnames,&obj0)) goto fail;
3281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3282 if (SWIG_arg_fail(1)) SWIG_fail;
3283 {
3284 PyThreadState* __tstate = wxPyBeginAllowThreads();
3285 result = wxObject_GetClassName(arg1);
3286
3287 wxPyEndAllowThreads(__tstate);
3288 if (PyErr_Occurred()) SWIG_fail;
3289 }
3290 {
3291 #if wxUSE_UNICODE
3292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3293 #else
3294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3295 #endif
3296 }
3297 return resultobj;
3298 fail:
3299 return NULL;
3300 }
3301
3302
3303 static PyObject *_wrap_wxObject_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxObject *arg1 = (wxObject *) 0 ;
3306 PyObject * obj0 = 0 ;
3307 char *kwnames[] = {
3308 (char *) "self", NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxObject_Destroy",kwnames,&obj0)) goto fail;
3312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3313 if (SWIG_arg_fail(1)) SWIG_fail;
3314 {
3315 PyThreadState* __tstate = wxPyBeginAllowThreads();
3316 wxObject_Destroy(arg1);
3317
3318 wxPyEndAllowThreads(__tstate);
3319 if (PyErr_Occurred()) SWIG_fail;
3320 }
3321 Py_INCREF(Py_None); resultobj = Py_None;
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject * wxObject_swigregister(PyObject *, PyObject *args) {
3329 PyObject *obj;
3330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3331 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3332 Py_INCREF(obj);
3333 return Py_BuildValue((char *)"");
3334 }
3335 static PyObject *_wrap_wxSize_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3336 PyObject *resultobj;
3337 wxSize *arg1 = (wxSize *) 0 ;
3338 int arg2 ;
3339 PyObject * obj0 = 0 ;
3340 PyObject * obj1 = 0 ;
3341 char *kwnames[] = {
3342 (char *) "self",(char *) "x", NULL
3343 };
3344
3345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_width_set",kwnames,&obj0,&obj1)) goto fail;
3346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3347 if (SWIG_arg_fail(1)) SWIG_fail;
3348 {
3349 arg2 = (int)(SWIG_As_int(obj1));
3350 if (SWIG_arg_fail(2)) SWIG_fail;
3351 }
3352 if (arg1) (arg1)->x = arg2;
3353
3354 Py_INCREF(Py_None); resultobj = Py_None;
3355 return resultobj;
3356 fail:
3357 return NULL;
3358 }
3359
3360
3361 static PyObject *_wrap_wxSize_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3362 PyObject *resultobj;
3363 wxSize *arg1 = (wxSize *) 0 ;
3364 int result;
3365 PyObject * obj0 = 0 ;
3366 char *kwnames[] = {
3367 (char *) "self", NULL
3368 };
3369
3370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSize_width_get",kwnames,&obj0)) goto fail;
3371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3372 if (SWIG_arg_fail(1)) SWIG_fail;
3373 result = (int) ((arg1)->x);
3374
3375 {
3376 resultobj = SWIG_From_int((int)(result));
3377 }
3378 return resultobj;
3379 fail:
3380 return NULL;
3381 }
3382
3383
3384 static PyObject *_wrap_wxSize_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3385 PyObject *resultobj;
3386 wxSize *arg1 = (wxSize *) 0 ;
3387 int arg2 ;
3388 PyObject * obj0 = 0 ;
3389 PyObject * obj1 = 0 ;
3390 char *kwnames[] = {
3391 (char *) "self",(char *) "y", NULL
3392 };
3393
3394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_height_set",kwnames,&obj0,&obj1)) goto fail;
3395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3396 if (SWIG_arg_fail(1)) SWIG_fail;
3397 {
3398 arg2 = (int)(SWIG_As_int(obj1));
3399 if (SWIG_arg_fail(2)) SWIG_fail;
3400 }
3401 if (arg1) (arg1)->y = arg2;
3402
3403 Py_INCREF(Py_None); resultobj = Py_None;
3404 return resultobj;
3405 fail:
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_wxSize_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 wxSize *arg1 = (wxSize *) 0 ;
3413 int result;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "self", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSize_height_get",kwnames,&obj0)) goto fail;
3420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3421 if (SWIG_arg_fail(1)) SWIG_fail;
3422 result = (int) ((arg1)->y);
3423
3424 {
3425 resultobj = SWIG_From_int((int)(result));
3426 }
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_new_wxSize(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 int arg1 = (int) 0 ;
3436 int arg2 = (int) 0 ;
3437 wxSize *result;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "w",(char *) "h", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxSize",kwnames,&obj0,&obj1)) goto fail;
3445 if (obj0) {
3446 {
3447 arg1 = (int)(SWIG_As_int(obj0));
3448 if (SWIG_arg_fail(1)) SWIG_fail;
3449 }
3450 }
3451 if (obj1) {
3452 {
3453 arg2 = (int)(SWIG_As_int(obj1));
3454 if (SWIG_arg_fail(2)) SWIG_fail;
3455 }
3456 }
3457 {
3458 PyThreadState* __tstate = wxPyBeginAllowThreads();
3459 result = (wxSize *)new wxSize(arg1,arg2);
3460
3461 wxPyEndAllowThreads(__tstate);
3462 if (PyErr_Occurred()) SWIG_fail;
3463 }
3464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_delete_wxSize(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxSize *arg1 = (wxSize *) 0 ;
3474 PyObject * obj0 = 0 ;
3475 char *kwnames[] = {
3476 (char *) "self", NULL
3477 };
3478
3479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxSize",kwnames,&obj0)) goto fail;
3480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3481 if (SWIG_arg_fail(1)) SWIG_fail;
3482 {
3483 PyThreadState* __tstate = wxPyBeginAllowThreads();
3484 delete arg1;
3485
3486 wxPyEndAllowThreads(__tstate);
3487 if (PyErr_Occurred()) SWIG_fail;
3488 }
3489 Py_INCREF(Py_None); resultobj = Py_None;
3490 return resultobj;
3491 fail:
3492 return NULL;
3493 }
3494
3495
3496 static PyObject *_wrap_wxSize___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3497 PyObject *resultobj;
3498 wxSize *arg1 = (wxSize *) 0 ;
3499 wxSize *arg2 = 0 ;
3500 bool result;
3501 wxSize temp2 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 char *kwnames[] = {
3505 (char *) "self",(char *) "sz", NULL
3506 };
3507
3508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize___eq__",kwnames,&obj0,&obj1)) goto fail;
3509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 {
3512 arg2 = &temp2;
3513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3514 }
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 {
3523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3524 }
3525 return resultobj;
3526 fail:
3527 return NULL;
3528 }
3529
3530
3531 static PyObject *_wrap_wxSize___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3532 PyObject *resultobj;
3533 wxSize *arg1 = (wxSize *) 0 ;
3534 wxSize *arg2 = 0 ;
3535 bool result;
3536 wxSize temp2 ;
3537 PyObject * obj0 = 0 ;
3538 PyObject * obj1 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "self",(char *) "sz", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize___ne__",kwnames,&obj0,&obj1)) goto fail;
3544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3545 if (SWIG_arg_fail(1)) SWIG_fail;
3546 {
3547 arg2 = &temp2;
3548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3549 }
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 {
3558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3559 }
3560 return resultobj;
3561 fail:
3562 return NULL;
3563 }
3564
3565
3566 static PyObject *_wrap_wxSize___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3567 PyObject *resultobj;
3568 wxSize *arg1 = (wxSize *) 0 ;
3569 wxSize *arg2 = 0 ;
3570 wxSize result;
3571 wxSize temp2 ;
3572 PyObject * obj0 = 0 ;
3573 PyObject * obj1 = 0 ;
3574 char *kwnames[] = {
3575 (char *) "self",(char *) "sz", NULL
3576 };
3577
3578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize___add__",kwnames,&obj0,&obj1)) goto fail;
3579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 {
3582 arg2 = &temp2;
3583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 result = (arg1)->operator +((wxSize const &)*arg2);
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 {
3593 wxSize * resultptr;
3594 resultptr = new wxSize((wxSize &)(result));
3595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3596 }
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_wxSize___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 wxSize *arg1 = (wxSize *) 0 ;
3606 wxSize *arg2 = 0 ;
3607 wxSize result;
3608 wxSize temp2 ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "self",(char *) "sz", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize___sub__",kwnames,&obj0,&obj1)) goto fail;
3616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 {
3619 arg2 = &temp2;
3620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3621 }
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 result = (arg1)->operator -((wxSize const &)*arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 {
3630 wxSize * resultptr;
3631 resultptr = new wxSize((wxSize &)(result));
3632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3633 }
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_wxSize_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 wxSize *arg1 = (wxSize *) 0 ;
3643 wxSize *arg2 = 0 ;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_IncTo",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 (arg1)->IncTo((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 Py_INCREF(Py_None); resultobj = Py_None;
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_wxSize_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 wxSize *arg2 = 0 ;
3676 wxSize temp2 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "self",(char *) "sz", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_DecTo",kwnames,&obj0,&obj1)) goto fail;
3684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 {
3687 arg2 = &temp2;
3688 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3689 }
3690 {
3691 PyThreadState* __tstate = wxPyBeginAllowThreads();
3692 (arg1)->DecTo((wxSize const &)*arg2);
3693
3694 wxPyEndAllowThreads(__tstate);
3695 if (PyErr_Occurred()) SWIG_fail;
3696 }
3697 Py_INCREF(Py_None); resultobj = Py_None;
3698 return resultobj;
3699 fail:
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_wxSize_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 wxSize *arg1 = (wxSize *) 0 ;
3707 int arg2 ;
3708 int arg3 ;
3709 PyObject * obj0 = 0 ;
3710 PyObject * obj1 = 0 ;
3711 PyObject * obj2 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "self",(char *) "w",(char *) "h", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxSize_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3718 if (SWIG_arg_fail(1)) SWIG_fail;
3719 {
3720 arg2 = (int)(SWIG_As_int(obj1));
3721 if (SWIG_arg_fail(2)) SWIG_fail;
3722 }
3723 {
3724 arg3 = (int)(SWIG_As_int(obj2));
3725 if (SWIG_arg_fail(3)) SWIG_fail;
3726 }
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 (arg1)->Set(arg2,arg3);
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 Py_INCREF(Py_None); resultobj = Py_None;
3735 return resultobj;
3736 fail:
3737 return NULL;
3738 }
3739
3740
3741 static PyObject *_wrap_wxSize_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3742 PyObject *resultobj;
3743 wxSize *arg1 = (wxSize *) 0 ;
3744 int arg2 ;
3745 PyObject * obj0 = 0 ;
3746 PyObject * obj1 = 0 ;
3747 char *kwnames[] = {
3748 (char *) "self",(char *) "w", NULL
3749 };
3750
3751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3753 if (SWIG_arg_fail(1)) SWIG_fail;
3754 {
3755 arg2 = (int)(SWIG_As_int(obj1));
3756 if (SWIG_arg_fail(2)) SWIG_fail;
3757 }
3758 {
3759 PyThreadState* __tstate = wxPyBeginAllowThreads();
3760 (arg1)->SetWidth(arg2);
3761
3762 wxPyEndAllowThreads(__tstate);
3763 if (PyErr_Occurred()) SWIG_fail;
3764 }
3765 Py_INCREF(Py_None); resultobj = Py_None;
3766 return resultobj;
3767 fail:
3768 return NULL;
3769 }
3770
3771
3772 static PyObject *_wrap_wxSize_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3773 PyObject *resultobj;
3774 wxSize *arg1 = (wxSize *) 0 ;
3775 int arg2 ;
3776 PyObject * obj0 = 0 ;
3777 PyObject * obj1 = 0 ;
3778 char *kwnames[] = {
3779 (char *) "self",(char *) "h", NULL
3780 };
3781
3782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3784 if (SWIG_arg_fail(1)) SWIG_fail;
3785 {
3786 arg2 = (int)(SWIG_As_int(obj1));
3787 if (SWIG_arg_fail(2)) SWIG_fail;
3788 }
3789 {
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 (arg1)->SetHeight(arg2);
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_wxSize_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 wxSize *arg1 = (wxSize *) 0 ;
3806 int result;
3807 PyObject * obj0 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "self", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSize_GetWidth",kwnames,&obj0)) goto fail;
3813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3814 if (SWIG_arg_fail(1)) SWIG_fail;
3815 {
3816 PyThreadState* __tstate = wxPyBeginAllowThreads();
3817 result = (int)((wxSize const *)arg1)->GetWidth();
3818
3819 wxPyEndAllowThreads(__tstate);
3820 if (PyErr_Occurred()) SWIG_fail;
3821 }
3822 {
3823 resultobj = SWIG_From_int((int)(result));
3824 }
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_wxSize_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3832 PyObject *resultobj;
3833 wxSize *arg1 = (wxSize *) 0 ;
3834 int result;
3835 PyObject * obj0 = 0 ;
3836 char *kwnames[] = {
3837 (char *) "self", NULL
3838 };
3839
3840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSize_GetHeight",kwnames,&obj0)) goto fail;
3841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3842 if (SWIG_arg_fail(1)) SWIG_fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = (int)((wxSize const *)arg1)->GetHeight();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 resultobj = SWIG_From_int((int)(result));
3852 }
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 static PyObject *_wrap_wxSize_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3860 PyObject *resultobj;
3861 wxSize *arg1 = (wxSize *) 0 ;
3862 bool result;
3863 PyObject * obj0 = 0 ;
3864 char *kwnames[] = {
3865 (char *) "self", NULL
3866 };
3867
3868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSize_IsFullySpecified",kwnames,&obj0)) goto fail;
3869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3870 if (SWIG_arg_fail(1)) SWIG_fail;
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 {
3879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3880 }
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_wxSize_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 wxSize *arg2 = 0 ;
3891 wxSize temp2 ;
3892 PyObject * obj0 = 0 ;
3893 PyObject * obj1 = 0 ;
3894 char *kwnames[] = {
3895 (char *) "self",(char *) "size", NULL
3896 };
3897
3898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSize_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3900 if (SWIG_arg_fail(1)) SWIG_fail;
3901 {
3902 arg2 = &temp2;
3903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3904 }
3905 {
3906 PyThreadState* __tstate = wxPyBeginAllowThreads();
3907 (arg1)->SetDefaults((wxSize const &)*arg2);
3908
3909 wxPyEndAllowThreads(__tstate);
3910 if (PyErr_Occurred()) SWIG_fail;
3911 }
3912 Py_INCREF(Py_None); resultobj = Py_None;
3913 return resultobj;
3914 fail:
3915 return NULL;
3916 }
3917
3918
3919 static PyObject *_wrap_wxSize_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3920 PyObject *resultobj;
3921 wxSize *arg1 = (wxSize *) 0 ;
3922 PyObject *result;
3923 PyObject * obj0 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "self", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSize_Get",kwnames,&obj0)) goto fail;
3929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3930 if (SWIG_arg_fail(1)) SWIG_fail;
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 result = (PyObject *)wxSize_Get(arg1);
3934
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 resultobj = result;
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 static PyObject * wxSize_swigregister(PyObject *, PyObject *args) {
3946 PyObject *obj;
3947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3948 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3949 Py_INCREF(obj);
3950 return Py_BuildValue((char *)"");
3951 }
3952 static PyObject *_wrap_wxRealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3955 double arg2 ;
3956 PyObject * obj0 = 0 ;
3957 PyObject * obj1 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "self",(char *) "x", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3964 if (SWIG_arg_fail(1)) SWIG_fail;
3965 {
3966 arg2 = (double)(SWIG_As_double(obj1));
3967 if (SWIG_arg_fail(2)) SWIG_fail;
3968 }
3969 if (arg1) (arg1)->x = arg2;
3970
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_wxRealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3981 double result;
3982 PyObject * obj0 = 0 ;
3983 char *kwnames[] = {
3984 (char *) "self", NULL
3985 };
3986
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRealPoint_x_get",kwnames,&obj0)) goto fail;
3988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3989 if (SWIG_arg_fail(1)) SWIG_fail;
3990 result = (double) ((arg1)->x);
3991
3992 {
3993 resultobj = SWIG_From_double((double)(result));
3994 }
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 static PyObject *_wrap_wxRealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj;
4003 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4004 double arg2 ;
4005 PyObject * obj0 = 0 ;
4006 PyObject * obj1 = 0 ;
4007 char *kwnames[] = {
4008 (char *) "self",(char *) "y", NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4013 if (SWIG_arg_fail(1)) SWIG_fail;
4014 {
4015 arg2 = (double)(SWIG_As_double(obj1));
4016 if (SWIG_arg_fail(2)) SWIG_fail;
4017 }
4018 if (arg1) (arg1)->y = arg2;
4019
4020 Py_INCREF(Py_None); resultobj = Py_None;
4021 return resultobj;
4022 fail:
4023 return NULL;
4024 }
4025
4026
4027 static PyObject *_wrap_wxRealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4028 PyObject *resultobj;
4029 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4030 double result;
4031 PyObject * obj0 = 0 ;
4032 char *kwnames[] = {
4033 (char *) "self", NULL
4034 };
4035
4036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRealPoint_y_get",kwnames,&obj0)) goto fail;
4037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4038 if (SWIG_arg_fail(1)) SWIG_fail;
4039 result = (double) ((arg1)->y);
4040
4041 {
4042 resultobj = SWIG_From_double((double)(result));
4043 }
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_wxRealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 double arg1 = (double) 0.0 ;
4053 double arg2 = (double) 0.0 ;
4054 wxRealPoint *result;
4055 PyObject * obj0 = 0 ;
4056 PyObject * obj1 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "x",(char *) "y", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxRealPoint",kwnames,&obj0,&obj1)) goto fail;
4062 if (obj0) {
4063 {
4064 arg1 = (double)(SWIG_As_double(obj0));
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 }
4067 }
4068 if (obj1) {
4069 {
4070 arg2 = (double)(SWIG_As_double(obj1));
4071 if (SWIG_arg_fail(2)) SWIG_fail;
4072 }
4073 }
4074 {
4075 PyThreadState* __tstate = wxPyBeginAllowThreads();
4076 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4077
4078 wxPyEndAllowThreads(__tstate);
4079 if (PyErr_Occurred()) SWIG_fail;
4080 }
4081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_delete_wxRealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4091 PyObject * obj0 = 0 ;
4092 char *kwnames[] = {
4093 (char *) "self", NULL
4094 };
4095
4096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxRealPoint",kwnames,&obj0)) goto fail;
4097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4098 if (SWIG_arg_fail(1)) SWIG_fail;
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 delete arg1;
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 Py_INCREF(Py_None); resultobj = Py_None;
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_wxRealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4116 wxRealPoint *arg2 = 0 ;
4117 bool result;
4118 wxRealPoint temp2 ;
4119 PyObject * obj0 = 0 ;
4120 PyObject * obj1 = 0 ;
4121 char *kwnames[] = {
4122 (char *) "self",(char *) "pt", NULL
4123 };
4124
4125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 {
4129 arg2 = &temp2;
4130 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 {
4140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4141 }
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_wxRealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4151 wxRealPoint *arg2 = 0 ;
4152 bool result;
4153 wxRealPoint temp2 ;
4154 PyObject * obj0 = 0 ;
4155 PyObject * obj1 = 0 ;
4156 char *kwnames[] = {
4157 (char *) "self",(char *) "pt", NULL
4158 };
4159
4160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4162 if (SWIG_arg_fail(1)) SWIG_fail;
4163 {
4164 arg2 = &temp2;
4165 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 {
4175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4176 }
4177 return resultobj;
4178 fail:
4179 return NULL;
4180 }
4181
4182
4183 static PyObject *_wrap_wxRealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4184 PyObject *resultobj;
4185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4186 wxRealPoint *arg2 = 0 ;
4187 wxRealPoint result;
4188 wxRealPoint temp2 ;
4189 PyObject * obj0 = 0 ;
4190 PyObject * obj1 = 0 ;
4191 char *kwnames[] = {
4192 (char *) "self",(char *) "pt", NULL
4193 };
4194
4195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4197 if (SWIG_arg_fail(1)) SWIG_fail;
4198 {
4199 arg2 = &temp2;
4200 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4201 }
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4205
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 {
4210 wxRealPoint * resultptr;
4211 resultptr = new wxRealPoint((wxRealPoint &)(result));
4212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4213 }
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 static PyObject *_wrap_wxRealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj;
4222 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4223 wxRealPoint *arg2 = 0 ;
4224 wxRealPoint result;
4225 wxRealPoint temp2 ;
4226 PyObject * obj0 = 0 ;
4227 PyObject * obj1 = 0 ;
4228 char *kwnames[] = {
4229 (char *) "self",(char *) "pt", NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4234 if (SWIG_arg_fail(1)) SWIG_fail;
4235 {
4236 arg2 = &temp2;
4237 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4238 }
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4242
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 {
4247 wxRealPoint * resultptr;
4248 resultptr = new wxRealPoint((wxRealPoint &)(result));
4249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4250 }
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_wxRealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4260 double arg2 ;
4261 double arg3 ;
4262 PyObject * obj0 = 0 ;
4263 PyObject * obj1 = 0 ;
4264 PyObject * obj2 = 0 ;
4265 char *kwnames[] = {
4266 (char *) "self",(char *) "x",(char *) "y", NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxRealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4271 if (SWIG_arg_fail(1)) SWIG_fail;
4272 {
4273 arg2 = (double)(SWIG_As_double(obj1));
4274 if (SWIG_arg_fail(2)) SWIG_fail;
4275 }
4276 {
4277 arg3 = (double)(SWIG_As_double(obj2));
4278 if (SWIG_arg_fail(3)) SWIG_fail;
4279 }
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxRealPoint_Set(arg1,arg2,arg3);
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 Py_INCREF(Py_None); resultobj = Py_None;
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 static PyObject *_wrap_wxRealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4297 PyObject *result;
4298 PyObject * obj0 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRealPoint_Get",kwnames,&obj0)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 result = (PyObject *)wxRealPoint_Get(arg1);
4309
4310 wxPyEndAllowThreads(__tstate);
4311 if (PyErr_Occurred()) SWIG_fail;
4312 }
4313 resultobj = result;
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject * wxRealPoint_swigregister(PyObject *, PyObject *args) {
4321 PyObject *obj;
4322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4323 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4324 Py_INCREF(obj);
4325 return Py_BuildValue((char *)"");
4326 }
4327 static PyObject *_wrap_wxPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxPoint *arg1 = (wxPoint *) 0 ;
4330 int arg2 ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char *kwnames[] = {
4334 (char *) "self",(char *) "x", NULL
4335 };
4336
4337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4339 if (SWIG_arg_fail(1)) SWIG_fail;
4340 {
4341 arg2 = (int)(SWIG_As_int(obj1));
4342 if (SWIG_arg_fail(2)) SWIG_fail;
4343 }
4344 if (arg1) (arg1)->x = arg2;
4345
4346 Py_INCREF(Py_None); resultobj = Py_None;
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 static PyObject *_wrap_wxPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4354 PyObject *resultobj;
4355 wxPoint *arg1 = (wxPoint *) 0 ;
4356 int result;
4357 PyObject * obj0 = 0 ;
4358 char *kwnames[] = {
4359 (char *) "self", NULL
4360 };
4361
4362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint_x_get",kwnames,&obj0)) goto fail;
4363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4364 if (SWIG_arg_fail(1)) SWIG_fail;
4365 result = (int) ((arg1)->x);
4366
4367 {
4368 resultobj = SWIG_From_int((int)(result));
4369 }
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_wxPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj;
4378 wxPoint *arg1 = (wxPoint *) 0 ;
4379 int arg2 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self",(char *) "y", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 arg2 = (int)(SWIG_As_int(obj1));
4391 if (SWIG_arg_fail(2)) SWIG_fail;
4392 }
4393 if (arg1) (arg1)->y = arg2;
4394
4395 Py_INCREF(Py_None); resultobj = Py_None;
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_wxPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 wxPoint *arg1 = (wxPoint *) 0 ;
4405 int result;
4406 PyObject * obj0 = 0 ;
4407 char *kwnames[] = {
4408 (char *) "self", NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint_y_get",kwnames,&obj0)) goto fail;
4412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(1)) SWIG_fail;
4414 result = (int) ((arg1)->y);
4415
4416 {
4417 resultobj = SWIG_From_int((int)(result));
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_new_wxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 int arg1 = (int) 0 ;
4428 int arg2 = (int) 0 ;
4429 wxPoint *result;
4430 PyObject * obj0 = 0 ;
4431 PyObject * obj1 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "x",(char *) "y", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxPoint",kwnames,&obj0,&obj1)) goto fail;
4437 if (obj0) {
4438 {
4439 arg1 = (int)(SWIG_As_int(obj0));
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 }
4442 }
4443 if (obj1) {
4444 {
4445 arg2 = (int)(SWIG_As_int(obj1));
4446 if (SWIG_arg_fail(2)) SWIG_fail;
4447 }
4448 }
4449 {
4450 PyThreadState* __tstate = wxPyBeginAllowThreads();
4451 result = (wxPoint *)new wxPoint(arg1,arg2);
4452
4453 wxPyEndAllowThreads(__tstate);
4454 if (PyErr_Occurred()) SWIG_fail;
4455 }
4456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 static PyObject *_wrap_delete_wxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4464 PyObject *resultobj;
4465 wxPoint *arg1 = (wxPoint *) 0 ;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxPoint",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 delete arg1;
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 Py_INCREF(Py_None); resultobj = Py_None;
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_wxPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxPoint *arg1 = (wxPoint *) 0 ;
4491 wxPoint *arg2 = 0 ;
4492 bool result;
4493 wxPoint temp2 ;
4494 PyObject * obj0 = 0 ;
4495 PyObject * obj1 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "self",(char *) "pt", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(1)) SWIG_fail;
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4510
4511 wxPyEndAllowThreads(__tstate);
4512 if (PyErr_Occurred()) SWIG_fail;
4513 }
4514 {
4515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516 }
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_wxPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxPoint *arg1 = (wxPoint *) 0 ;
4526 wxPoint *arg2 = 0 ;
4527 bool result;
4528 wxPoint temp2 ;
4529 PyObject * obj0 = 0 ;
4530 PyObject * obj1 = 0 ;
4531 char *kwnames[] = {
4532 (char *) "self",(char *) "pt", NULL
4533 };
4534
4535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(1)) SWIG_fail;
4538 {
4539 arg2 = &temp2;
4540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4541 }
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4545
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 static PyObject *_wrap_wxPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj;
4560 wxPoint *arg1 = (wxPoint *) 0 ;
4561 wxPoint *arg2 = 0 ;
4562 wxPoint result;
4563 wxPoint temp2 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char *kwnames[] = {
4567 (char *) "self",(char *) "pt", NULL
4568 };
4569
4570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4572 if (SWIG_arg_fail(1)) SWIG_fail;
4573 {
4574 arg2 = &temp2;
4575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (arg1)->operator +((wxPoint const &)*arg2);
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 {
4585 wxPoint * resultptr;
4586 resultptr = new wxPoint((wxPoint &)(result));
4587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4588 }
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 static PyObject *_wrap_wxPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4596 PyObject *resultobj;
4597 wxPoint *arg1 = (wxPoint *) 0 ;
4598 wxPoint *arg2 = 0 ;
4599 wxPoint result;
4600 wxPoint temp2 ;
4601 PyObject * obj0 = 0 ;
4602 PyObject * obj1 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self",(char *) "pt", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 arg2 = &temp2;
4612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4613 }
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 result = (arg1)->operator -((wxPoint const &)*arg2);
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 {
4622 wxPoint * resultptr;
4623 resultptr = new wxPoint((wxPoint &)(result));
4624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4625 }
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_wxPoint___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj;
4634 wxPoint *arg1 = (wxPoint *) 0 ;
4635 wxPoint *arg2 = 0 ;
4636 wxPoint *result;
4637 wxPoint temp2 ;
4638 PyObject * obj0 = 0 ;
4639 PyObject * obj1 = 0 ;
4640 char *kwnames[] = {
4641 (char *) "self",(char *) "pt", NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint___iadd__",kwnames,&obj0,&obj1)) goto fail;
4645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4646 if (SWIG_arg_fail(1)) SWIG_fail;
4647 {
4648 arg2 = &temp2;
4649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 {
4654 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4655 result = (wxPoint *) &_result_ref;
4656 }
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_wxPoint___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj;
4670 wxPoint *arg1 = (wxPoint *) 0 ;
4671 wxPoint *arg2 = 0 ;
4672 wxPoint *result;
4673 wxPoint temp2 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char *kwnames[] = {
4677 (char *) "self",(char *) "pt", NULL
4678 };
4679
4680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint___isub__",kwnames,&obj0,&obj1)) goto fail;
4681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4682 if (SWIG_arg_fail(1)) SWIG_fail;
4683 {
4684 arg2 = &temp2;
4685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4686 }
4687 {
4688 PyThreadState* __tstate = wxPyBeginAllowThreads();
4689 {
4690 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4691 result = (wxPoint *) &_result_ref;
4692 }
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 static PyObject *_wrap_wxPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj;
4706 wxPoint *arg1 = (wxPoint *) 0 ;
4707 long arg2 ;
4708 long arg3 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self",(char *) "x",(char *) "y", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 arg2 = (long)(SWIG_As_long(obj1));
4721 if (SWIG_arg_fail(2)) SWIG_fail;
4722 }
4723 {
4724 arg3 = (long)(SWIG_As_long(obj2));
4725 if (SWIG_arg_fail(3)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 wxPoint_Set(arg1,arg2,arg3);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 Py_INCREF(Py_None); resultobj = Py_None;
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 static PyObject *_wrap_wxPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj;
4743 wxPoint *arg1 = (wxPoint *) 0 ;
4744 PyObject *result;
4745 PyObject * obj0 = 0 ;
4746 char *kwnames[] = {
4747 (char *) "self", NULL
4748 };
4749
4750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint_Get",kwnames,&obj0)) goto fail;
4751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4752 if (SWIG_arg_fail(1)) SWIG_fail;
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (PyObject *)wxPoint_Get(arg1);
4756
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = result;
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 static PyObject * wxPoint_swigregister(PyObject *, PyObject *args) {
4768 PyObject *obj;
4769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4770 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4771 Py_INCREF(obj);
4772 return Py_BuildValue((char *)"");
4773 }
4774 static PyObject *_wrap_new_wxRect(PyObject *, PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj;
4776 int arg1 = (int) 0 ;
4777 int arg2 = (int) 0 ;
4778 int arg3 = (int) 0 ;
4779 int arg4 = (int) 0 ;
4780 wxRect *result;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 PyObject * obj2 = 0 ;
4784 PyObject * obj3 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_wxRect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4790 if (obj0) {
4791 {
4792 arg1 = (int)(SWIG_As_int(obj0));
4793 if (SWIG_arg_fail(1)) SWIG_fail;
4794 }
4795 }
4796 if (obj1) {
4797 {
4798 arg2 = (int)(SWIG_As_int(obj1));
4799 if (SWIG_arg_fail(2)) SWIG_fail;
4800 }
4801 }
4802 if (obj2) {
4803 {
4804 arg3 = (int)(SWIG_As_int(obj2));
4805 if (SWIG_arg_fail(3)) SWIG_fail;
4806 }
4807 }
4808 if (obj3) {
4809 {
4810 arg4 = (int)(SWIG_As_int(obj3));
4811 if (SWIG_arg_fail(4)) SWIG_fail;
4812 }
4813 }
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4817
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj;
4830 wxPoint *arg1 = 0 ;
4831 wxPoint *arg2 = 0 ;
4832 wxRect *result;
4833 wxPoint temp1 ;
4834 wxPoint temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "topLeft",(char *) "bottomRight", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4842 {
4843 arg1 = &temp1;
4844 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4845 }
4846 {
4847 arg2 = &temp2;
4848 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4849 }
4850 {
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4853
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxPoint *arg1 = 0 ;
4867 wxSize *arg2 = 0 ;
4868 wxRect *result;
4869 wxPoint temp1 ;
4870 wxSize temp2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "pos",(char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4878 {
4879 arg1 = &temp1;
4880 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4881 }
4882 {
4883 arg2 = &temp2;
4884 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4885 }
4886 {
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4894 return resultobj;
4895 fail:
4896 return NULL;
4897 }
4898
4899
4900 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4901 PyObject *resultobj;
4902 wxSize *arg1 = 0 ;
4903 wxRect *result;
4904 wxSize temp1 ;
4905 PyObject * obj0 = 0 ;
4906 char *kwnames[] = {
4907 (char *) "size", NULL
4908 };
4909
4910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4911 {
4912 arg1 = &temp1;
4913 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_delete_wxRect(PyObject *, PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj;
4931 wxRect *arg1 = (wxRect *) 0 ;
4932 PyObject * obj0 = 0 ;
4933 char *kwnames[] = {
4934 (char *) "self", NULL
4935 };
4936
4937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxRect",kwnames,&obj0)) goto fail;
4938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4939 if (SWIG_arg_fail(1)) SWIG_fail;
4940 {
4941 PyThreadState* __tstate = wxPyBeginAllowThreads();
4942 delete arg1;
4943
4944 wxPyEndAllowThreads(__tstate);
4945 if (PyErr_Occurred()) SWIG_fail;
4946 }
4947 Py_INCREF(Py_None); resultobj = Py_None;
4948 return resultobj;
4949 fail:
4950 return NULL;
4951 }
4952
4953
4954 static PyObject *_wrap_wxRect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4955 PyObject *resultobj;
4956 wxRect *arg1 = (wxRect *) 0 ;
4957 int result;
4958 PyObject * obj0 = 0 ;
4959 char *kwnames[] = {
4960 (char *) "self", NULL
4961 };
4962
4963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetX",kwnames,&obj0)) goto fail;
4964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4965 if (SWIG_arg_fail(1)) SWIG_fail;
4966 {
4967 PyThreadState* __tstate = wxPyBeginAllowThreads();
4968 result = (int)((wxRect const *)arg1)->GetX();
4969
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 {
4974 resultobj = SWIG_From_int((int)(result));
4975 }
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 static PyObject *_wrap_wxRect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj;
4984 wxRect *arg1 = (wxRect *) 0 ;
4985 int arg2 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 char *kwnames[] = {
4989 (char *) "self",(char *) "x", NULL
4990 };
4991
4992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetX",kwnames,&obj0,&obj1)) goto fail;
4993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4994 if (SWIG_arg_fail(1)) SWIG_fail;
4995 {
4996 arg2 = (int)(SWIG_As_int(obj1));
4997 if (SWIG_arg_fail(2)) SWIG_fail;
4998 }
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 (arg1)->SetX(arg2);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 Py_INCREF(Py_None); resultobj = Py_None;
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 static PyObject *_wrap_wxRect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj;
5015 wxRect *arg1 = (wxRect *) 0 ;
5016 int result;
5017 PyObject * obj0 = 0 ;
5018 char *kwnames[] = {
5019 (char *) "self", NULL
5020 };
5021
5022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetY",kwnames,&obj0)) goto fail;
5023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5024 if (SWIG_arg_fail(1)) SWIG_fail;
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (int)(arg1)->GetY();
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = SWIG_From_int((int)(result));
5034 }
5035 return resultobj;
5036 fail:
5037 return NULL;
5038 }
5039
5040
5041 static PyObject *_wrap_wxRect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5042 PyObject *resultobj;
5043 wxRect *arg1 = (wxRect *) 0 ;
5044 int arg2 ;
5045 PyObject * obj0 = 0 ;
5046 PyObject * obj1 = 0 ;
5047 char *kwnames[] = {
5048 (char *) "self",(char *) "y", NULL
5049 };
5050
5051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetY",kwnames,&obj0,&obj1)) goto fail;
5052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5053 if (SWIG_arg_fail(1)) SWIG_fail;
5054 {
5055 arg2 = (int)(SWIG_As_int(obj1));
5056 if (SWIG_arg_fail(2)) SWIG_fail;
5057 }
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 (arg1)->SetY(arg2);
5061
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 Py_INCREF(Py_None); resultobj = Py_None;
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 static PyObject *_wrap_wxRect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj;
5074 wxRect *arg1 = (wxRect *) 0 ;
5075 int result;
5076 PyObject * obj0 = 0 ;
5077 char *kwnames[] = {
5078 (char *) "self", NULL
5079 };
5080
5081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetWidth",kwnames,&obj0)) goto fail;
5082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5083 if (SWIG_arg_fail(1)) SWIG_fail;
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (int)((wxRect const *)arg1)->GetWidth();
5087
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 {
5092 resultobj = SWIG_From_int((int)(result));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 static PyObject *_wrap_wxRect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5101 PyObject *resultobj;
5102 wxRect *arg1 = (wxRect *) 0 ;
5103 int arg2 ;
5104 PyObject * obj0 = 0 ;
5105 PyObject * obj1 = 0 ;
5106 char *kwnames[] = {
5107 (char *) "self",(char *) "w", NULL
5108 };
5109
5110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5112 if (SWIG_arg_fail(1)) SWIG_fail;
5113 {
5114 arg2 = (int)(SWIG_As_int(obj1));
5115 if (SWIG_arg_fail(2)) SWIG_fail;
5116 }
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 (arg1)->SetWidth(arg2);
5120
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 Py_INCREF(Py_None); resultobj = Py_None;
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 static PyObject *_wrap_wxRect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj;
5133 wxRect *arg1 = (wxRect *) 0 ;
5134 int result;
5135 PyObject * obj0 = 0 ;
5136 char *kwnames[] = {
5137 (char *) "self", NULL
5138 };
5139
5140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetHeight",kwnames,&obj0)) goto fail;
5141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5142 if (SWIG_arg_fail(1)) SWIG_fail;
5143 {
5144 PyThreadState* __tstate = wxPyBeginAllowThreads();
5145 result = (int)((wxRect const *)arg1)->GetHeight();
5146
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 {
5151 resultobj = SWIG_From_int((int)(result));
5152 }
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_wxRect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxRect *arg1 = (wxRect *) 0 ;
5162 int arg2 ;
5163 PyObject * obj0 = 0 ;
5164 PyObject * obj1 = 0 ;
5165 char *kwnames[] = {
5166 (char *) "self",(char *) "h", NULL
5167 };
5168
5169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5171 if (SWIG_arg_fail(1)) SWIG_fail;
5172 {
5173 arg2 = (int)(SWIG_As_int(obj1));
5174 if (SWIG_arg_fail(2)) SWIG_fail;
5175 }
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 (arg1)->SetHeight(arg2);
5179
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 Py_INCREF(Py_None); resultobj = Py_None;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 static PyObject *_wrap_wxRect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj;
5192 wxRect *arg1 = (wxRect *) 0 ;
5193 wxPoint result;
5194 PyObject * obj0 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetPosition",kwnames,&obj0)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = ((wxRect const *)arg1)->GetPosition();
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 wxPoint * resultptr;
5211 resultptr = new wxPoint((wxPoint &)(result));
5212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5213 }
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_wxRect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxPoint *arg2 = 0 ;
5224 wxPoint temp2 ;
5225 PyObject * obj0 = 0 ;
5226 PyObject * obj1 = 0 ;
5227 char *kwnames[] = {
5228 (char *) "self",(char *) "p", NULL
5229 };
5230
5231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(1)) SWIG_fail;
5234 {
5235 arg2 = &temp2;
5236 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5237 }
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 (arg1)->SetPosition((wxPoint const &)*arg2);
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 Py_INCREF(Py_None); resultobj = Py_None;
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_wxRect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxRect *arg1 = (wxRect *) 0 ;
5255 wxSize result;
5256 PyObject * obj0 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetSize",kwnames,&obj0)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 result = ((wxRect const *)arg1)->GetSize();
5267
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 wxSize * resultptr;
5273 resultptr = new wxSize((wxSize &)(result));
5274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5275 }
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_wxRect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 wxSize *arg2 = 0 ;
5286 wxSize temp2 ;
5287 PyObject * obj0 = 0 ;
5288 PyObject * obj1 = 0 ;
5289 char *kwnames[] = {
5290 (char *) "self",(char *) "s", NULL
5291 };
5292
5293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5295 if (SWIG_arg_fail(1)) SWIG_fail;
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 (arg1)->SetSize((wxSize const &)*arg2);
5303
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 Py_INCREF(Py_None); resultobj = Py_None;
5308 return resultobj;
5309 fail:
5310 return NULL;
5311 }
5312
5313
5314 static PyObject *_wrap_wxRect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj;
5316 wxRect *arg1 = (wxRect *) 0 ;
5317 bool result;
5318 PyObject * obj0 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_IsEmpty",kwnames,&obj0)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 result = (bool)((wxRect const *)arg1)->IsEmpty();
5329
5330 wxPyEndAllowThreads(__tstate);
5331 if (PyErr_Occurred()) SWIG_fail;
5332 }
5333 {
5334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5335 }
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 static PyObject *_wrap_wxRect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj;
5344 wxRect *arg1 = (wxRect *) 0 ;
5345 wxPoint result;
5346 PyObject * obj0 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetTopLeft",kwnames,&obj0)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = ((wxRect const *)arg1)->GetTopLeft();
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 wxPoint * resultptr;
5363 resultptr = new wxPoint((wxPoint &)(result));
5364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_wxRect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint *arg2 = 0 ;
5376 wxPoint temp2 ;
5377 PyObject * obj0 = 0 ;
5378 PyObject * obj1 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "self",(char *) "p", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5385 if (SWIG_arg_fail(1)) SWIG_fail;
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5393
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 Py_INCREF(Py_None); resultobj = Py_None;
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_wxRect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxRect *arg1 = (wxRect *) 0 ;
5407 wxPoint result;
5408 PyObject * obj0 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetBottomRight",kwnames,&obj0)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 result = ((wxRect const *)arg1)->GetBottomRight();
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 wxPoint * resultptr;
5425 resultptr = new wxPoint((wxPoint &)(result));
5426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5427 }
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_wxRect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 wxPoint *arg2 = 0 ;
5438 wxPoint temp2 ;
5439 PyObject * obj0 = 0 ;
5440 PyObject * obj1 = 0 ;
5441 char *kwnames[] = {
5442 (char *) "self",(char *) "p", NULL
5443 };
5444
5445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5447 if (SWIG_arg_fail(1)) SWIG_fail;
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5455
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 Py_INCREF(Py_None); resultobj = Py_None;
5460 return resultobj;
5461 fail:
5462 return NULL;
5463 }
5464
5465
5466 static PyObject *_wrap_wxRect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj;
5468 wxRect *arg1 = (wxRect *) 0 ;
5469 int result;
5470 PyObject * obj0 = 0 ;
5471 char *kwnames[] = {
5472 (char *) "self", NULL
5473 };
5474
5475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetLeft",kwnames,&obj0)) goto fail;
5476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5477 if (SWIG_arg_fail(1)) SWIG_fail;
5478 {
5479 PyThreadState* __tstate = wxPyBeginAllowThreads();
5480 result = (int)((wxRect const *)arg1)->GetLeft();
5481
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 {
5486 resultobj = SWIG_From_int((int)(result));
5487 }
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 static PyObject *_wrap_wxRect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5495 PyObject *resultobj;
5496 wxRect *arg1 = (wxRect *) 0 ;
5497 int result;
5498 PyObject * obj0 = 0 ;
5499 char *kwnames[] = {
5500 (char *) "self", NULL
5501 };
5502
5503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetTop",kwnames,&obj0)) goto fail;
5504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5505 if (SWIG_arg_fail(1)) SWIG_fail;
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 result = (int)((wxRect const *)arg1)->GetTop();
5509
5510 wxPyEndAllowThreads(__tstate);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 {
5514 resultobj = SWIG_From_int((int)(result));
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_wxRect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj;
5524 wxRect *arg1 = (wxRect *) 0 ;
5525 int result;
5526 PyObject * obj0 = 0 ;
5527 char *kwnames[] = {
5528 (char *) "self", NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetBottom",kwnames,&obj0)) goto fail;
5532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5533 if (SWIG_arg_fail(1)) SWIG_fail;
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (int)((wxRect const *)arg1)->GetBottom();
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_int((int)(result));
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_wxRect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj;
5552 wxRect *arg1 = (wxRect *) 0 ;
5553 int result;
5554 PyObject * obj0 = 0 ;
5555 char *kwnames[] = {
5556 (char *) "self", NULL
5557 };
5558
5559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_GetRight",kwnames,&obj0)) goto fail;
5560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5561 if (SWIG_arg_fail(1)) SWIG_fail;
5562 {
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 result = (int)((wxRect const *)arg1)->GetRight();
5565
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 {
5570 resultobj = SWIG_From_int((int)(result));
5571 }
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 static PyObject *_wrap_wxRect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5579 PyObject *resultobj;
5580 wxRect *arg1 = (wxRect *) 0 ;
5581 int arg2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "left", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = (int)(SWIG_As_int(obj1));
5593 if (SWIG_arg_fail(2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetLeft(arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_wxRect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int arg2 ;
5613 PyObject * obj0 = 0 ;
5614 PyObject * obj1 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self",(char *) "right", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 arg2 = (int)(SWIG_As_int(obj1));
5624 if (SWIG_arg_fail(2)) SWIG_fail;
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 (arg1)->SetRight(arg2);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 Py_INCREF(Py_None); resultobj = Py_None;
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_wxRect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect *arg1 = (wxRect *) 0 ;
5643 int arg2 ;
5644 PyObject * obj0 = 0 ;
5645 PyObject * obj1 = 0 ;
5646 char *kwnames[] = {
5647 (char *) "self",(char *) "top", NULL
5648 };
5649
5650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5652 if (SWIG_arg_fail(1)) SWIG_fail;
5653 {
5654 arg2 = (int)(SWIG_As_int(obj1));
5655 if (SWIG_arg_fail(2)) SWIG_fail;
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 (arg1)->SetTop(arg2);
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 Py_INCREF(Py_None); resultobj = Py_None;
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_wxRect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxRect *arg1 = (wxRect *) 0 ;
5674 int arg2 ;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "self",(char *) "bottom", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5683 if (SWIG_arg_fail(1)) SWIG_fail;
5684 {
5685 arg2 = (int)(SWIG_As_int(obj1));
5686 if (SWIG_arg_fail(2)) SWIG_fail;
5687 }
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 (arg1)->SetBottom(arg2);
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 Py_INCREF(Py_None); resultobj = Py_None;
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 static PyObject *_wrap_wxRect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj;
5704 wxRect *arg1 = (wxRect *) 0 ;
5705 int arg2 ;
5706 int arg3 ;
5707 wxRect *result;
5708 PyObject * obj0 = 0 ;
5709 PyObject * obj1 = 0 ;
5710 PyObject * obj2 = 0 ;
5711 char *kwnames[] = {
5712 (char *) "self",(char *) "dx",(char *) "dy", NULL
5713 };
5714
5715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxRect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 {
5719 arg2 = (int)(SWIG_As_int(obj1));
5720 if (SWIG_arg_fail(2)) SWIG_fail;
5721 }
5722 {
5723 arg3 = (int)(SWIG_As_int(obj2));
5724 if (SWIG_arg_fail(3)) SWIG_fail;
5725 }
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 {
5729 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5730 result = (wxRect *) &_result_ref;
5731 }
5732
5733 wxPyEndAllowThreads(__tstate);
5734 if (PyErr_Occurred()) SWIG_fail;
5735 }
5736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_wxRect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxRect *arg1 = (wxRect *) 0 ;
5746 int arg2 ;
5747 int arg3 ;
5748 wxRect *result;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 PyObject * obj2 = 0 ;
5752 char *kwnames[] = {
5753 (char *) "self",(char *) "dx",(char *) "dy", NULL
5754 };
5755
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxRect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5758 if (SWIG_arg_fail(1)) SWIG_fail;
5759 {
5760 arg2 = (int)(SWIG_As_int(obj1));
5761 if (SWIG_arg_fail(2)) SWIG_fail;
5762 }
5763 {
5764 arg3 = (int)(SWIG_As_int(obj2));
5765 if (SWIG_arg_fail(3)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 {
5770 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5771 result = (wxRect *) &_result_ref;
5772 }
5773
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_wxRect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxRect *arg1 = (wxRect *) 0 ;
5787 int arg2 ;
5788 int arg3 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 char *kwnames[] = {
5793 (char *) "self",(char *) "dx",(char *) "dy", NULL
5794 };
5795
5796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxRect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 {
5800 arg2 = (int)(SWIG_As_int(obj1));
5801 if (SWIG_arg_fail(2)) SWIG_fail;
5802 }
5803 {
5804 arg3 = (int)(SWIG_As_int(obj2));
5805 if (SWIG_arg_fail(3)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->Offset(arg2,arg3);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 Py_INCREF(Py_None); resultobj = Py_None;
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_wxRect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxPoint *arg2 = 0 ;
5825 wxPoint temp2 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "self",(char *) "pt", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_Offset",kwnames,&obj0,&obj1)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 arg2 = &temp2;
5837 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5838 }
5839 {
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 (arg1)->Offset((wxPoint const &)*arg2);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 Py_INCREF(Py_None); resultobj = Py_None;
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_wxRect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = (arg1)->Intersect((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_wxRect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_Union",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = (arg1)->Union((wxRect const &)*arg2);
5912
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 {
5917 wxRect * resultptr;
5918 resultptr = new wxRect((wxRect &)(result));
5919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_wxRect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 wxRect *arg1 = (wxRect *) 0 ;
5930 wxRect *arg2 = 0 ;
5931 wxRect result;
5932 wxRect temp2 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char *kwnames[] = {
5936 (char *) "self",(char *) "rect", NULL
5937 };
5938
5939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect___add__",kwnames,&obj0,&obj1)) goto fail;
5940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5941 if (SWIG_arg_fail(1)) SWIG_fail;
5942 {
5943 arg2 = &temp2;
5944 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5945 }
5946 {
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 {
5954 wxRect * resultptr;
5955 resultptr = new wxRect((wxRect &)(result));
5956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_wxRect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj;
5966 wxRect *arg1 = (wxRect *) 0 ;
5967 wxRect *arg2 = 0 ;
5968 wxRect *result;
5969 wxRect temp2 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 char *kwnames[] = {
5973 (char *) "self",(char *) "rect", NULL
5974 };
5975
5976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5978 if (SWIG_arg_fail(1)) SWIG_fail;
5979 {
5980 arg2 = &temp2;
5981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5982 }
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 {
5986 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5987 result = (wxRect *) &_result_ref;
5988 }
5989
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 static PyObject *_wrap_wxRect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj;
6002 wxRect *arg1 = (wxRect *) 0 ;
6003 wxRect *arg2 = 0 ;
6004 bool result;
6005 wxRect temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char *kwnames[] = {
6009 (char *) "self",(char *) "rect", NULL
6010 };
6011
6012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect___eq__",kwnames,&obj0,&obj1)) goto fail;
6013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6014 if (SWIG_arg_fail(1)) SWIG_fail;
6015 {
6016 arg2 = &temp2;
6017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6018 }
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 {
6027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6028 }
6029 return resultobj;
6030 fail:
6031 return NULL;
6032 }
6033
6034
6035 static PyObject *_wrap_wxRect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6036 PyObject *resultobj;
6037 wxRect *arg1 = (wxRect *) 0 ;
6038 wxRect *arg2 = 0 ;
6039 bool result;
6040 wxRect temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "self",(char *) "rect", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect___ne__",kwnames,&obj0,&obj1)) goto fail;
6048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 {
6051 arg2 = &temp2;
6052 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6053 }
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6063 }
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_wxRect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj;
6072 wxRect *arg1 = (wxRect *) 0 ;
6073 int arg2 ;
6074 int arg3 ;
6075 bool result;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 PyObject * obj2 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "x",(char *) "y", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxRect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = (int)(SWIG_As_int(obj1));
6088 if (SWIG_arg_fail(2)) SWIG_fail;
6089 }
6090 {
6091 arg3 = (int)(SWIG_As_int(obj2));
6092 if (SWIG_arg_fail(3)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_wxRect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 wxPoint *arg2 = 0 ;
6114 bool result;
6115 wxPoint temp2 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 char *kwnames[] = {
6119 (char *) "self",(char *) "pt", NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_Inside",kwnames,&obj0,&obj1)) goto fail;
6123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6124 if (SWIG_arg_fail(1)) SWIG_fail;
6125 {
6126 arg2 = &temp2;
6127 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6128 }
6129 {
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6132
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 {
6137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6138 }
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_wxRect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 wxRect *arg2 = 0 ;
6149 bool result;
6150 wxRect temp2 ;
6151 PyObject * obj0 = 0 ;
6152 PyObject * obj1 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "self",(char *) "rect", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6159 if (SWIG_arg_fail(1)) SWIG_fail;
6160 {
6161 arg2 = &temp2;
6162 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6163 }
6164 {
6165 PyThreadState* __tstate = wxPyBeginAllowThreads();
6166 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6167
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 {
6172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6173 }
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_wxRect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxRect *arg1 = (wxRect *) 0 ;
6183 int arg2 ;
6184 PyObject * obj0 = 0 ;
6185 PyObject * obj1 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self",(char *) "x", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_x_set",kwnames,&obj0,&obj1)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 arg2 = (int)(SWIG_As_int(obj1));
6195 if (SWIG_arg_fail(2)) SWIG_fail;
6196 }
6197 if (arg1) (arg1)->x = arg2;
6198
6199 Py_INCREF(Py_None); resultobj = Py_None;
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_wxRect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int result;
6210 PyObject * obj0 = 0 ;
6211 char *kwnames[] = {
6212 (char *) "self", NULL
6213 };
6214
6215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_x_get",kwnames,&obj0)) goto fail;
6216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6217 if (SWIG_arg_fail(1)) SWIG_fail;
6218 result = (int) ((arg1)->x);
6219
6220 {
6221 resultobj = SWIG_From_int((int)(result));
6222 }
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject *_wrap_wxRect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int arg2 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self",(char *) "y", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_y_set",kwnames,&obj0,&obj1)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 arg2 = (int)(SWIG_As_int(obj1));
6244 if (SWIG_arg_fail(2)) SWIG_fail;
6245 }
6246 if (arg1) (arg1)->y = arg2;
6247
6248 Py_INCREF(Py_None); resultobj = Py_None;
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_wxRect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 int result;
6259 PyObject * obj0 = 0 ;
6260 char *kwnames[] = {
6261 (char *) "self", NULL
6262 };
6263
6264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_y_get",kwnames,&obj0)) goto fail;
6265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6266 if (SWIG_arg_fail(1)) SWIG_fail;
6267 result = (int) ((arg1)->y);
6268
6269 {
6270 resultobj = SWIG_From_int((int)(result));
6271 }
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_wxRect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int arg2 ;
6282 PyObject * obj0 = 0 ;
6283 PyObject * obj1 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self",(char *) "width", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_width_set",kwnames,&obj0,&obj1)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 {
6292 arg2 = (int)(SWIG_As_int(obj1));
6293 if (SWIG_arg_fail(2)) SWIG_fail;
6294 }
6295 if (arg1) (arg1)->width = arg2;
6296
6297 Py_INCREF(Py_None); resultobj = Py_None;
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_wxRect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int result;
6308 PyObject * obj0 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_width_get",kwnames,&obj0)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 result = (int) ((arg1)->width);
6317
6318 {
6319 resultobj = SWIG_From_int((int)(result));
6320 }
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_wxRect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int arg2 ;
6331 PyObject * obj0 = 0 ;
6332 PyObject * obj1 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "self",(char *) "height", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxRect_height_set",kwnames,&obj0,&obj1)) goto fail;
6338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 {
6341 arg2 = (int)(SWIG_As_int(obj1));
6342 if (SWIG_arg_fail(2)) SWIG_fail;
6343 }
6344 if (arg1) (arg1)->height = arg2;
6345
6346 Py_INCREF(Py_None); resultobj = Py_None;
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_wxRect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRect *arg1 = (wxRect *) 0 ;
6356 int result;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "self", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_height_get",kwnames,&obj0)) goto fail;
6363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6364 if (SWIG_arg_fail(1)) SWIG_fail;
6365 result = (int) ((arg1)->height);
6366
6367 {
6368 resultobj = SWIG_From_int((int)(result));
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_wxRect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxRect *arg1 = (wxRect *) 0 ;
6379 int arg2 = (int) 0 ;
6380 int arg3 = (int) 0 ;
6381 int arg4 = (int) 0 ;
6382 int arg5 = (int) 0 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 PyObject * obj2 = 0 ;
6386 PyObject * obj3 = 0 ;
6387 PyObject * obj4 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6390 };
6391
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:wxRect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 if (obj1) {
6396 {
6397 arg2 = (int)(SWIG_As_int(obj1));
6398 if (SWIG_arg_fail(2)) SWIG_fail;
6399 }
6400 }
6401 if (obj2) {
6402 {
6403 arg3 = (int)(SWIG_As_int(obj2));
6404 if (SWIG_arg_fail(3)) SWIG_fail;
6405 }
6406 }
6407 if (obj3) {
6408 {
6409 arg4 = (int)(SWIG_As_int(obj3));
6410 if (SWIG_arg_fail(4)) SWIG_fail;
6411 }
6412 }
6413 if (obj4) {
6414 {
6415 arg5 = (int)(SWIG_As_int(obj4));
6416 if (SWIG_arg_fail(5)) SWIG_fail;
6417 }
6418 }
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 Py_INCREF(Py_None); resultobj = Py_None;
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_wxRect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 wxRect *arg1 = (wxRect *) 0 ;
6436 PyObject *result;
6437 PyObject * obj0 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxRect_Get",kwnames,&obj0)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (PyObject *)wxRect_Get(arg1);
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = result;
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject * wxRect_swigregister(PyObject *, PyObject *args) {
6460 PyObject *obj;
6461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6462 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6463 Py_INCREF(obj);
6464 return Py_BuildValue((char *)"");
6465 }
6466 static PyObject *_wrap_wxIntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxRect *arg1 = (wxRect *) 0 ;
6469 wxRect *arg2 = (wxRect *) 0 ;
6470 PyObject *result;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "r1",(char *) "r2", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIntersectRect",kwnames,&obj0,&obj1)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6481 if (SWIG_arg_fail(2)) SWIG_fail;
6482 {
6483 if (!wxPyCheckForApp()) SWIG_fail;
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (PyObject *)wxIntersectRect(arg1,arg2);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = result;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_new_wxPoint2D(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 double arg1 = (double) 0.0 ;
6500 double arg2 = (double) 0.0 ;
6501 wxPoint2D *result;
6502 PyObject * obj0 = 0 ;
6503 PyObject * obj1 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "x",(char *) "y", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxPoint2D",kwnames,&obj0,&obj1)) goto fail;
6509 if (obj0) {
6510 {
6511 arg1 = (double)(SWIG_As_double(obj0));
6512 if (SWIG_arg_fail(1)) SWIG_fail;
6513 }
6514 }
6515 if (obj1) {
6516 {
6517 arg2 = (double)(SWIG_As_double(obj1));
6518 if (SWIG_arg_fail(2)) SWIG_fail;
6519 }
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxPoint2D *arg1 = 0 ;
6538 wxPoint2D *result;
6539 wxPoint2D temp1 ;
6540 PyObject * obj0 = 0 ;
6541 char *kwnames[] = {
6542 (char *) "pt", NULL
6543 };
6544
6545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6546 {
6547 arg1 = &temp1;
6548 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6549 }
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6553
6554 wxPyEndAllowThreads(__tstate);
6555 if (PyErr_Occurred()) SWIG_fail;
6556 }
6557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6558 return resultobj;
6559 fail:
6560 return NULL;
6561 }
6562
6563
6564 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6565 PyObject *resultobj;
6566 wxPoint *arg1 = 0 ;
6567 wxPoint2D *result;
6568 wxPoint temp1 ;
6569 PyObject * obj0 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "pt", NULL
6572 };
6573
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6575 {
6576 arg1 = &temp1;
6577 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_wxPoint2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 int *arg2 = (int *) 0 ;
6597 int *arg3 = (int *) 0 ;
6598 int temp2 ;
6599 int res2 = 0 ;
6600 int temp3 ;
6601 int res3 = 0 ;
6602 PyObject * obj0 = 0 ;
6603 char *kwnames[] = {
6604 (char *) "self", NULL
6605 };
6606
6607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_GetFloor",kwnames,&obj0)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 Py_INCREF(Py_None); resultobj = Py_None;
6620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6621 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6623 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6624 return resultobj;
6625 fail:
6626 return NULL;
6627 }
6628
6629
6630 static PyObject *_wrap_wxPoint2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6631 PyObject *resultobj;
6632 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6633 int *arg2 = (int *) 0 ;
6634 int *arg3 = (int *) 0 ;
6635 int temp2 ;
6636 int res2 = 0 ;
6637 int temp3 ;
6638 int res3 = 0 ;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6645 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_GetRounded",kwnames,&obj0)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 Py_INCREF(Py_None); resultobj = Py_None;
6657 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6658 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6659 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6660 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_wxPoint2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6670 double result;
6671 PyObject * obj0 = 0 ;
6672 char *kwnames[] = {
6673 (char *) "self", NULL
6674 };
6675
6676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_GetVectorLength",kwnames,&obj0)) goto fail;
6677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(1)) SWIG_fail;
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6682
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 {
6687 resultobj = SWIG_From_double((double)(result));
6688 }
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 static PyObject *_wrap_wxPoint2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6696 PyObject *resultobj;
6697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6698 double result;
6699 PyObject * obj0 = 0 ;
6700 char *kwnames[] = {
6701 (char *) "self", NULL
6702 };
6703
6704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6706 if (SWIG_arg_fail(1)) SWIG_fail;
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 {
6715 resultobj = SWIG_From_double((double)(result));
6716 }
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_wxPoint2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6726 double arg2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "self",(char *) "length", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 {
6737 arg2 = (double)(SWIG_As_double(obj1));
6738 if (SWIG_arg_fail(2)) SWIG_fail;
6739 }
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 (arg1)->SetVectorLength(arg2);
6743
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 Py_INCREF(Py_None); resultobj = Py_None;
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 static PyObject *_wrap_wxPoint2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6755 PyObject *resultobj;
6756 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6757 double arg2 ;
6758 PyObject * obj0 = 0 ;
6759 PyObject * obj1 = 0 ;
6760 char *kwnames[] = {
6761 (char *) "self",(char *) "degrees", NULL
6762 };
6763
6764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6766 if (SWIG_arg_fail(1)) SWIG_fail;
6767 {
6768 arg2 = (double)(SWIG_As_double(obj1));
6769 if (SWIG_arg_fail(2)) SWIG_fail;
6770 }
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 (arg1)->SetVectorAngle(arg2);
6774
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 Py_INCREF(Py_None); resultobj = Py_None;
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_wxPoint2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6788 wxPoint2D *arg2 = 0 ;
6789 double result;
6790 wxPoint2D temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "pt", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = SWIG_From_double((double)(result));
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_wxPoint2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6823 wxPoint2D *arg2 = 0 ;
6824 double result;
6825 wxPoint2D temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "pt", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = &temp2;
6837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 {
6847 resultobj = SWIG_From_double((double)(result));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_wxPoint2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6858 wxPoint2D *arg2 = 0 ;
6859 double result;
6860 wxPoint2D temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char *kwnames[] = {
6864 (char *) "self",(char *) "vec", NULL
6865 };
6866
6867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6869 if (SWIG_arg_fail(1)) SWIG_fail;
6870 {
6871 arg2 = &temp2;
6872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6873 }
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 {
6882 resultobj = SWIG_From_double((double)(result));
6883 }
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 static PyObject *_wrap_wxPoint2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6891 PyObject *resultobj;
6892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6893 wxPoint2D *arg2 = 0 ;
6894 double result;
6895 wxPoint2D temp2 ;
6896 PyObject * obj0 = 0 ;
6897 PyObject * obj1 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "self",(char *) "vec", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6904 if (SWIG_arg_fail(1)) SWIG_fail;
6905 {
6906 arg2 = &temp2;
6907 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6908 }
6909 {
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6912
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 {
6917 resultobj = SWIG_From_double((double)(result));
6918 }
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 static PyObject *_wrap_wxPoint2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj;
6927 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6928 wxPoint2D result;
6929 PyObject * obj0 = 0 ;
6930 char *kwnames[] = {
6931 (char *) "self", NULL
6932 };
6933
6934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D___neg__",kwnames,&obj0)) goto fail;
6935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6936 if (SWIG_arg_fail(1)) SWIG_fail;
6937 {
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = (arg1)->operator -();
6940
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 {
6945 wxPoint2D * resultptr;
6946 resultptr = new wxPoint2D((wxPoint2D &)(result));
6947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_wxPoint2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6958 wxPoint2D *arg2 = 0 ;
6959 wxPoint2D *result;
6960 wxPoint2D temp2 ;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "pt", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 {
6977 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6978 result = (wxPoint2D *) &_result_ref;
6979 }
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_wxPoint2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6994 wxPoint2D *arg2 = 0 ;
6995 wxPoint2D *result;
6996 wxPoint2D temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "self",(char *) "pt", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7005 if (SWIG_arg_fail(1)) SWIG_fail;
7006 {
7007 arg2 = &temp2;
7008 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 {
7013 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7014 result = (wxPoint2D *) &_result_ref;
7015 }
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_wxPoint2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7030 wxPoint2D *arg2 = 0 ;
7031 wxPoint2D *result;
7032 wxPoint2D temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "pt", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 arg2 = &temp2;
7044 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7045 }
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 {
7049 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7050 result = (wxPoint2D *) &_result_ref;
7051 }
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 static PyObject *_wrap_wxPoint2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj;
7065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7066 wxPoint2D *arg2 = 0 ;
7067 wxPoint2D *result;
7068 wxPoint2D temp2 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self",(char *) "pt", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 arg2 = &temp2;
7080 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7081 }
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 {
7085 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7086 result = (wxPoint2D *) &_result_ref;
7087 }
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_wxPoint2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7102 wxPoint2D *arg2 = 0 ;
7103 bool result;
7104 wxPoint2D temp2 ;
7105 PyObject * obj0 = 0 ;
7106 PyObject * obj1 = 0 ;
7107 char *kwnames[] = {
7108 (char *) "self",(char *) "pt", NULL
7109 };
7110
7111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7113 if (SWIG_arg_fail(1)) SWIG_fail;
7114 {
7115 arg2 = &temp2;
7116 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7117 }
7118 {
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7121
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 {
7126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7127 }
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_wxPoint2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 wxPoint2D *arg2 = 0 ;
7138 bool result;
7139 wxPoint2D temp2 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self",(char *) "pt", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 {
7150 arg2 = &temp2;
7151 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7152 }
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7156
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 {
7161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7162 }
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_wxPoint2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj;
7171 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7172 double arg2 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self",(char *) "m_x", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 {
7183 arg2 = (double)(SWIG_As_double(obj1));
7184 if (SWIG_arg_fail(2)) SWIG_fail;
7185 }
7186 if (arg1) (arg1)->m_x = arg2;
7187
7188 Py_INCREF(Py_None); resultobj = Py_None;
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_wxPoint2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7198 double result;
7199 PyObject * obj0 = 0 ;
7200 char *kwnames[] = {
7201 (char *) "self", NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_x_get",kwnames,&obj0)) goto fail;
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 result = (double) ((arg1)->m_x);
7208
7209 {
7210 resultobj = SWIG_From_double((double)(result));
7211 }
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_wxPoint2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7221 double arg2 ;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self",(char *) "m_y", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPoint2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 {
7232 arg2 = (double)(SWIG_As_double(obj1));
7233 if (SWIG_arg_fail(2)) SWIG_fail;
7234 }
7235 if (arg1) (arg1)->m_y = arg2;
7236
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_wxPoint2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7247 double result;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_y_get",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 result = (double) ((arg1)->m_y);
7257
7258 {
7259 resultobj = SWIG_From_double((double)(result));
7260 }
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_wxPoint2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7270 double arg2 = (double) 0 ;
7271 double arg3 = (double) 0 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 PyObject * obj2 = 0 ;
7275 char *kwnames[] = {
7276 (char *) "self",(char *) "x",(char *) "y", NULL
7277 };
7278
7279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:wxPoint2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7281 if (SWIG_arg_fail(1)) SWIG_fail;
7282 if (obj1) {
7283 {
7284 arg2 = (double)(SWIG_As_double(obj1));
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 }
7287 }
7288 if (obj2) {
7289 {
7290 arg3 = (double)(SWIG_As_double(obj2));
7291 if (SWIG_arg_fail(3)) SWIG_fail;
7292 }
7293 }
7294 {
7295 PyThreadState* __tstate = wxPyBeginAllowThreads();
7296 wxPoint2D_Set(arg1,arg2,arg3);
7297
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 Py_INCREF(Py_None); resultobj = Py_None;
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_wxPoint2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7311 PyObject *result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "self", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPoint2D_Get",kwnames,&obj0)) goto fail;
7318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(1)) SWIG_fail;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (PyObject *)wxPoint2D_Get(arg1);
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = result;
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 static PyObject * wxPoint2D_swigregister(PyObject *, PyObject *args) {
7335 PyObject *obj;
7336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7337 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7338 Py_INCREF(obj);
7339 return Py_BuildValue((char *)"");
7340 }
7341 static int _wrap_wxDefaultPosition_set(PyObject *) {
7342 PyErr_SetString(PyExc_TypeError,"Variable wxDefaultPosition is read-only.");
7343 return 1;
7344 }
7345
7346
7347 static PyObject *_wrap_wxDefaultPosition_get(void) {
7348 PyObject *pyobj;
7349
7350 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7351 return pyobj;
7352 }
7353
7354
7355 static int _wrap_wxDefaultSize_set(PyObject *) {
7356 PyErr_SetString(PyExc_TypeError,"Variable wxDefaultSize is read-only.");
7357 return 1;
7358 }
7359
7360
7361 static PyObject *_wrap_wxDefaultSize_get(void) {
7362 PyObject *pyobj;
7363
7364 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7365 return pyobj;
7366 }
7367
7368
7369 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 PyObject *arg1 = (PyObject *) 0 ;
7372 wxPyInputStream *result;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "p", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7379 arg1 = obj0;
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7383
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj;
7396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7397 PyObject * obj0 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 delete arg1;
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 Py_INCREF(Py_None); resultobj = Py_None;
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7422 PyObject * obj0 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 (arg1)->close();
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 Py_INCREF(Py_None); resultobj = Py_None;
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj;
7446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7447 PyObject * obj0 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 (arg1)->flush();
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 Py_INCREF(Py_None); resultobj = Py_None;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 bool result;
7473 PyObject * obj0 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->eof();
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 {
7489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7490 }
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7500 int arg2 = (int) -1 ;
7501 PyObject *result;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 char *kwnames[] = {
7505 (char *) "self",(char *) "size", NULL
7506 };
7507
7508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7510 if (SWIG_arg_fail(1)) SWIG_fail;
7511 if (obj1) {
7512 {
7513 arg2 = (int)(SWIG_As_int(obj1));
7514 if (SWIG_arg_fail(2)) SWIG_fail;
7515 }
7516 }
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (PyObject *)(arg1)->read(arg2);
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 resultobj = result;
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7534 int arg2 = (int) -1 ;
7535 PyObject *result;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char *kwnames[] = {
7539 (char *) "self",(char *) "size", NULL
7540 };
7541
7542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(1)) SWIG_fail;
7545 if (obj1) {
7546 {
7547 arg2 = (int)(SWIG_As_int(obj1));
7548 if (SWIG_arg_fail(2)) SWIG_fail;
7549 }
7550 }
7551 {
7552 PyThreadState* __tstate = wxPyBeginAllowThreads();
7553 result = (PyObject *)(arg1)->readline(arg2);
7554
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 resultobj = result;
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7566 PyObject *resultobj;
7567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7568 int arg2 = (int) -1 ;
7569 PyObject *result;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char *kwnames[] = {
7573 (char *) "self",(char *) "sizehint", NULL
7574 };
7575
7576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7578 if (SWIG_arg_fail(1)) SWIG_fail;
7579 if (obj1) {
7580 {
7581 arg2 = (int)(SWIG_As_int(obj1));
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 }
7584 }
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 result = (PyObject *)(arg1)->readlines(arg2);
7588
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = result;
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj;
7601 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7602 int arg2 ;
7603 int arg3 = (int) 0 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 PyObject * obj2 = 0 ;
7607 char *kwnames[] = {
7608 (char *) "self",(char *) "offset",(char *) "whence", NULL
7609 };
7610
7611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7613 if (SWIG_arg_fail(1)) SWIG_fail;
7614 {
7615 arg2 = (int)(SWIG_As_int(obj1));
7616 if (SWIG_arg_fail(2)) SWIG_fail;
7617 }
7618 if (obj2) {
7619 {
7620 arg3 = (int)(SWIG_As_int(obj2));
7621 if (SWIG_arg_fail(3)) SWIG_fail;
7622 }
7623 }
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->seek(arg2,arg3);
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 Py_INCREF(Py_None); resultobj = Py_None;
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj;
7640 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7641 int result;
7642 PyObject * obj0 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "self", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(1)) SWIG_fail;
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (int)(arg1)->tell();
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = SWIG_From_int((int)(result));
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj;
7668 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7669 char result;
7670 PyObject * obj0 = 0 ;
7671 char *kwnames[] = {
7672 (char *) "self", NULL
7673 };
7674
7675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7677 if (SWIG_arg_fail(1)) SWIG_fail;
7678 {
7679 PyThreadState* __tstate = wxPyBeginAllowThreads();
7680 result = (char)(arg1)->Peek();
7681
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 {
7686 resultobj = SWIG_From_char((char)(result));
7687 }
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7695 PyObject *resultobj;
7696 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7697 char result;
7698 PyObject * obj0 = 0 ;
7699 char *kwnames[] = {
7700 (char *) "self", NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7705 if (SWIG_arg_fail(1)) SWIG_fail;
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 result = (char)(arg1)->GetC();
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 {
7714 resultobj = SWIG_From_char((char)(result));
7715 }
7716 return resultobj;
7717 fail:
7718 return NULL;
7719 }
7720
7721
7722 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7723 PyObject *resultobj;
7724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7725 size_t result;
7726 PyObject * obj0 = 0 ;
7727 char *kwnames[] = {
7728 (char *) "self", NULL
7729 };
7730
7731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7733 if (SWIG_arg_fail(1)) SWIG_fail;
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 result = (size_t)(arg1)->LastRead();
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7743 }
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj;
7752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7753 bool result;
7754 PyObject * obj0 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->CanRead();
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7781 bool result;
7782 PyObject * obj0 = 0 ;
7783 char *kwnames[] = {
7784 (char *) "self", NULL
7785 };
7786
7787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7789 if (SWIG_arg_fail(1)) SWIG_fail;
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = (bool)(arg1)->Eof();
7793
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7809 char arg2 ;
7810 bool result;
7811 PyObject * obj0 = 0 ;
7812 PyObject * obj1 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self",(char *) "c", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 arg2 = (char)(SWIG_As_char(obj1));
7822 if (SWIG_arg_fail(2)) SWIG_fail;
7823 }
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (bool)(arg1)->Ungetch(arg2);
7827
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 {
7832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7833 }
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7841 PyObject *resultobj;
7842 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7843 long arg2 ;
7844 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7845 long result;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 PyObject * obj2 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "pos",(char *) "mode", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 {
7857 arg2 = (long)(SWIG_As_long(obj1));
7858 if (SWIG_arg_fail(2)) SWIG_fail;
7859 }
7860 if (obj2) {
7861 {
7862 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7863 if (SWIG_arg_fail(3)) SWIG_fail;
7864 }
7865 }
7866 {
7867 PyThreadState* __tstate = wxPyBeginAllowThreads();
7868 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7869
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 {
7874 resultobj = SWIG_From_long((long)(result));
7875 }
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7885 long result;
7886 PyObject * obj0 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (long)(arg1)->TellI();
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 {
7902 resultobj = SWIG_From_long((long)(result));
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7911 PyObject *obj;
7912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7913 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7914 Py_INCREF(obj);
7915 return Py_BuildValue((char *)"");
7916 }
7917 static PyObject *_wrap_wxOutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj;
7919 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7920 PyObject *arg2 = (PyObject *) 0 ;
7921 PyObject * obj0 = 0 ;
7922 PyObject * obj1 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "self",(char *) "obj", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxOutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 arg2 = obj1;
7931 {
7932 PyThreadState* __tstate = wxPyBeginAllowThreads();
7933 wxOutputStream_write(arg1,arg2);
7934
7935 wxPyEndAllowThreads(__tstate);
7936 if (PyErr_Occurred()) SWIG_fail;
7937 }
7938 Py_INCREF(Py_None); resultobj = Py_None;
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject * wxOutputStream_swigregister(PyObject *, PyObject *args) {
7946 PyObject *obj;
7947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7948 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7949 Py_INCREF(obj);
7950 return Py_BuildValue((char *)"");
7951 }
7952 static PyObject *_wrap_new_wxFSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxInputStream *arg1 = (wxInputStream *) 0 ;
7955 wxString *arg2 = 0 ;
7956 wxString *arg3 = 0 ;
7957 wxString *arg4 = 0 ;
7958 wxDateTime arg5 ;
7959 wxFSFile *result;
7960 wxPyInputStream *temp1 ;
7961 bool temp2 = false ;
7962 bool temp3 = false ;
7963 bool temp4 = false ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 PyObject * obj2 = 0 ;
7967 PyObject * obj3 = 0 ;
7968 PyObject * obj4 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_wxFSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7974 {
7975 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7976 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7977 } else {
7978 PyErr_Clear(); // clear the failure of the wxPyConvert above
7979 arg1 = wxPyCBInputStream_create(obj0, true);
7980 if (arg1 == NULL) {
7981 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7982 SWIG_fail;
7983 }
7984 }
7985 }
7986 {
7987 arg2 = wxString_in_helper(obj1);
7988 if (arg2 == NULL) SWIG_fail;
7989 temp2 = true;
7990 }
7991 {
7992 arg3 = wxString_in_helper(obj2);
7993 if (arg3 == NULL) SWIG_fail;
7994 temp3 = true;
7995 }
7996 {
7997 arg4 = wxString_in_helper(obj3);
7998 if (arg4 == NULL) SWIG_fail;
7999 temp4 = true;
8000 }
8001 {
8002 wxDateTime * argp;
8003 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8004 if (SWIG_arg_fail(5)) SWIG_fail;
8005 if (argp == NULL) {
8006 SWIG_null_ref("wxDateTime");
8007 }
8008 if (SWIG_arg_fail(5)) SWIG_fail;
8009 arg5 = *argp;
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 {
8019 resultobj = wxPyMake_wxObject(result, 1);
8020 }
8021 {
8022 if (temp2)
8023 delete arg2;
8024 }
8025 {
8026 if (temp3)
8027 delete arg3;
8028 }
8029 {
8030 if (temp4)
8031 delete arg4;
8032 }
8033 return resultobj;
8034 fail:
8035 {
8036 if (temp2)
8037 delete arg2;
8038 }
8039 {
8040 if (temp3)
8041 delete arg3;
8042 }
8043 {
8044 if (temp4)
8045 delete arg4;
8046 }
8047 return NULL;
8048 }
8049
8050
8051 static PyObject *_wrap_delete_wxFSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 wxFSFile *arg1 = (wxFSFile *) 0 ;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxFSFile",kwnames,&obj0)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 delete arg1;
8065
8066 wxPyEndAllowThreads(__tstate);
8067 if (PyErr_Occurred()) SWIG_fail;
8068 }
8069 Py_INCREF(Py_None); resultobj = Py_None;
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 static PyObject *_wrap_wxFSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8077 PyObject *resultobj;
8078 wxFSFile *arg1 = (wxFSFile *) 0 ;
8079 wxInputStream *result;
8080 PyObject * obj0 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFSFile_GetStream",kwnames,&obj0)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxInputStream *)(arg1)->GetStream();
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 {
8096 wxPyInputStream * _ptr = NULL;
8097
8098 if (result) {
8099 _ptr = new wxPyInputStream(result);
8100 }
8101 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 static PyObject *_wrap_wxFSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj;
8111 wxFSFile *arg1 = (wxFSFile *) 0 ;
8112 wxString *result;
8113 PyObject * obj0 = 0 ;
8114 char *kwnames[] = {
8115 (char *) "self", NULL
8116 };
8117
8118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFSFile_GetMimeType",kwnames,&obj0)) goto fail;
8119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8120 if (SWIG_arg_fail(1)) SWIG_fail;
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 {
8124 wxString const &_result_ref = (arg1)->GetMimeType();
8125 result = (wxString *) &_result_ref;
8126 }
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 {
8132 #if wxUSE_UNICODE
8133 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8134 #else
8135 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8136 #endif
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 static PyObject *_wrap_wxFSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj;
8146 wxFSFile *arg1 = (wxFSFile *) 0 ;
8147 wxString *result;
8148 PyObject * obj0 = 0 ;
8149 char *kwnames[] = {
8150 (char *) "self", NULL
8151 };
8152
8153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFSFile_GetLocation",kwnames,&obj0)) goto fail;
8154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8155 if (SWIG_arg_fail(1)) SWIG_fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 {
8159 wxString const &_result_ref = (arg1)->GetLocation();
8160 result = (wxString *) &_result_ref;
8161 }
8162
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 {
8167 #if wxUSE_UNICODE
8168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8169 #else
8170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8171 #endif
8172 }
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 static PyObject *_wrap_wxFSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj;
8181 wxFSFile *arg1 = (wxFSFile *) 0 ;
8182 wxString *result;
8183 PyObject * obj0 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFSFile_GetAnchor",kwnames,&obj0)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 {
8194 wxString const &_result_ref = (arg1)->GetAnchor();
8195 result = (wxString *) &_result_ref;
8196 }
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 #if wxUSE_UNICODE
8203 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8204 #else
8205 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8206 #endif
8207 }
8208 return resultobj;
8209 fail:
8210 return NULL;
8211 }
8212
8213
8214 static PyObject *_wrap_wxFSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8215 PyObject *resultobj;
8216 wxFSFile *arg1 = (wxFSFile *) 0 ;
8217 wxDateTime result;
8218 PyObject * obj0 = 0 ;
8219 char *kwnames[] = {
8220 (char *) "self", NULL
8221 };
8222
8223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8225 if (SWIG_arg_fail(1)) SWIG_fail;
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (arg1)->GetModificationTime();
8229
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 {
8234 wxDateTime * resultptr;
8235 resultptr = new wxDateTime((wxDateTime &)(result));
8236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8237 }
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 static PyObject * wxFSFile_swigregister(PyObject *, PyObject *args) {
8245 PyObject *obj;
8246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8247 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8248 Py_INCREF(obj);
8249 return Py_BuildValue((char *)"");
8250 }
8251 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8252 PyObject *obj;
8253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8254 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8255 Py_INCREF(obj);
8256 return Py_BuildValue((char *)"");
8257 }
8258 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyFileSystemHandler *result;
8261 char *kwnames[] = {
8262 NULL
8263 };
8264
8265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj;
8282 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8283 PyObject *arg2 = (PyObject *) 0 ;
8284 PyObject *arg3 = (PyObject *) 0 ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 PyObject * obj2 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self",(char *) "self",(char *) "_class", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 arg2 = obj1;
8296 arg3 = obj2;
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 (arg1)->_setCallbackInfo(arg2,arg3);
8300
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 Py_INCREF(Py_None); resultobj = Py_None;
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8314 wxString *arg2 = 0 ;
8315 bool result;
8316 bool temp2 = false ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self",(char *) "location", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 arg2 = wxString_in_helper(obj1);
8328 if (arg2 == NULL) SWIG_fail;
8329 temp2 = true;
8330 }
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 {
8339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8340 }
8341 {
8342 if (temp2)
8343 delete arg2;
8344 }
8345 return resultobj;
8346 fail:
8347 {
8348 if (temp2)
8349 delete arg2;
8350 }
8351 return NULL;
8352 }
8353
8354
8355 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj;
8357 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8358 wxFileSystem *arg2 = 0 ;
8359 wxString *arg3 = 0 ;
8360 wxFSFile *result;
8361 bool temp3 = false ;
8362 PyObject * obj0 = 0 ;
8363 PyObject * obj1 = 0 ;
8364 PyObject * obj2 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self",(char *) "fs",(char *) "location", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 {
8373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(2)) SWIG_fail;
8375 if (arg2 == NULL) {
8376 SWIG_null_ref("wxFileSystem");
8377 }
8378 if (SWIG_arg_fail(2)) SWIG_fail;
8379 }
8380 {
8381 arg3 = wxString_in_helper(obj2);
8382 if (arg3 == NULL) SWIG_fail;
8383 temp3 = true;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 resultobj = wxPyMake_wxObject(result, 1);
8394 }
8395 {
8396 if (temp3)
8397 delete arg3;
8398 }
8399 return resultobj;
8400 fail:
8401 {
8402 if (temp3)
8403 delete arg3;
8404 }
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8412 wxString *arg2 = 0 ;
8413 int arg3 = (int) 0 ;
8414 wxString result;
8415 bool temp2 = false ;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self",(char *) "spec",(char *) "flags", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 {
8427 arg2 = wxString_in_helper(obj1);
8428 if (arg2 == NULL) SWIG_fail;
8429 temp2 = true;
8430 }
8431 if (obj2) {
8432 {
8433 arg3 = (int)(SWIG_As_int(obj2));
8434 if (SWIG_arg_fail(3)) SWIG_fail;
8435 }
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 #if wxUSE_UNICODE
8446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8447 #else
8448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8449 #endif
8450 }
8451 {
8452 if (temp2)
8453 delete arg2;
8454 }
8455 return resultobj;
8456 fail:
8457 {
8458 if (temp2)
8459 delete arg2;
8460 }
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString result;
8469 PyObject * obj0 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (arg1)->FindNext();
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 #if wxUSE_UNICODE
8486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8487 #else
8488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8489 #endif
8490 }
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj;
8499 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8500 wxString *arg2 = 0 ;
8501 wxString result;
8502 bool temp2 = false ;
8503 PyObject * obj0 = 0 ;
8504 PyObject * obj1 = 0 ;
8505 char *kwnames[] = {
8506 (char *) "self",(char *) "location", NULL
8507 };
8508
8509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8511 if (SWIG_arg_fail(1)) SWIG_fail;
8512 {
8513 arg2 = wxString_in_helper(obj1);
8514 if (arg2 == NULL) SWIG_fail;
8515 temp2 = true;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (arg1)->GetProtocol((wxString const &)*arg2);
8520
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 #if wxUSE_UNICODE
8526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8527 #else
8528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8529 #endif
8530 }
8531 {
8532 if (temp2)
8533 delete arg2;
8534 }
8535 return resultobj;
8536 fail:
8537 {
8538 if (temp2)
8539 delete arg2;
8540 }
8541 return NULL;
8542 }
8543
8544
8545 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8546 PyObject *resultobj;
8547 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8548 wxString *arg2 = 0 ;
8549 wxString result;
8550 bool temp2 = false ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self",(char *) "location", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 arg2 = wxString_in_helper(obj1);
8562 if (arg2 == NULL) SWIG_fail;
8563 temp2 = true;
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 {
8573 #if wxUSE_UNICODE
8574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8575 #else
8576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8577 #endif
8578 }
8579 {
8580 if (temp2)
8581 delete arg2;
8582 }
8583 return resultobj;
8584 fail:
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return NULL;
8590 }
8591
8592
8593 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj;
8595 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8596 wxString *arg2 = 0 ;
8597 wxString result;
8598 bool temp2 = false ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self",(char *) "location", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 arg2 = wxString_in_helper(obj1);
8610 if (arg2 == NULL) SWIG_fail;
8611 temp2 = true;
8612 }
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 result = (arg1)->GetAnchor((wxString const &)*arg2);
8616
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 {
8621 #if wxUSE_UNICODE
8622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8623 #else
8624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8625 #endif
8626 }
8627 {
8628 if (temp2)
8629 delete arg2;
8630 }
8631 return resultobj;
8632 fail:
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 return NULL;
8638 }
8639
8640
8641 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8644 wxString *arg2 = 0 ;
8645 wxString result;
8646 bool temp2 = false ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char *kwnames[] = {
8650 (char *) "self",(char *) "location", NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8655 if (SWIG_arg_fail(1)) SWIG_fail;
8656 {
8657 arg2 = wxString_in_helper(obj1);
8658 if (arg2 == NULL) SWIG_fail;
8659 temp2 = true;
8660 }
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8664
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 {
8669 #if wxUSE_UNICODE
8670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8671 #else
8672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8673 #endif
8674 }
8675 {
8676 if (temp2)
8677 delete arg2;
8678 }
8679 return resultobj;
8680 fail:
8681 {
8682 if (temp2)
8683 delete arg2;
8684 }
8685 return NULL;
8686 }
8687
8688
8689 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8690 PyObject *resultobj;
8691 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8692 wxString *arg2 = 0 ;
8693 wxString result;
8694 bool temp2 = false ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char *kwnames[] = {
8698 (char *) "self",(char *) "location", NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8703 if (SWIG_arg_fail(1)) SWIG_fail;
8704 {
8705 arg2 = wxString_in_helper(obj1);
8706 if (arg2 == NULL) SWIG_fail;
8707 temp2 = true;
8708 }
8709 {
8710 PyThreadState* __tstate = wxPyBeginAllowThreads();
8711 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8712
8713 wxPyEndAllowThreads(__tstate);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 {
8717 #if wxUSE_UNICODE
8718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8719 #else
8720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8721 #endif
8722 }
8723 {
8724 if (temp2)
8725 delete arg2;
8726 }
8727 return resultobj;
8728 fail:
8729 {
8730 if (temp2)
8731 delete arg2;
8732 }
8733 return NULL;
8734 }
8735
8736
8737 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8738 PyObject *obj;
8739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8740 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8741 Py_INCREF(obj);
8742 return Py_BuildValue((char *)"");
8743 }
8744 static PyObject *_wrap_new_wxFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj;
8746 wxFileSystem *result;
8747 char *kwnames[] = {
8748 NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxFileSystem",kwnames)) goto fail;
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 result = (wxFileSystem *)new wxFileSystem();
8755
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 resultobj = wxPyMake_wxObject(result, 1);
8761 }
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 static PyObject *_wrap_delete_wxFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj;
8770 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8771 PyObject * obj0 = 0 ;
8772 char *kwnames[] = {
8773 (char *) "self", NULL
8774 };
8775
8776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxFileSystem",kwnames,&obj0)) goto fail;
8777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8778 if (SWIG_arg_fail(1)) SWIG_fail;
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 delete arg1;
8782
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 Py_INCREF(Py_None); resultobj = Py_None;
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_wxFileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8796 wxString *arg2 = 0 ;
8797 bool arg3 = (bool) false ;
8798 bool temp2 = false ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char *kwnames[] = {
8803 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8804 };
8805
8806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxFileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8808 if (SWIG_arg_fail(1)) SWIG_fail;
8809 {
8810 arg2 = wxString_in_helper(obj1);
8811 if (arg2 == NULL) SWIG_fail;
8812 temp2 = true;
8813 }
8814 if (obj2) {
8815 {
8816 arg3 = (bool)(SWIG_As_bool(obj2));
8817 if (SWIG_arg_fail(3)) SWIG_fail;
8818 }
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 Py_INCREF(Py_None); resultobj = Py_None;
8828 {
8829 if (temp2)
8830 delete arg2;
8831 }
8832 return resultobj;
8833 fail:
8834 {
8835 if (temp2)
8836 delete arg2;
8837 }
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_wxFileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8845 wxString result;
8846 PyObject * obj0 = 0 ;
8847 char *kwnames[] = {
8848 (char *) "self", NULL
8849 };
8850
8851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFileSystem_GetPath",kwnames,&obj0)) goto fail;
8852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8853 if (SWIG_arg_fail(1)) SWIG_fail;
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (arg1)->GetPath();
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 {
8862 #if wxUSE_UNICODE
8863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8864 #else
8865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8866 #endif
8867 }
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_wxFileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8877 wxString *arg2 = 0 ;
8878 wxFSFile *result;
8879 bool temp2 = false ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "location", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxFileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 {
8890 arg2 = wxString_in_helper(obj1);
8891 if (arg2 == NULL) SWIG_fail;
8892 temp2 = true;
8893 }
8894 {
8895 PyThreadState* __tstate = wxPyBeginAllowThreads();
8896 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8897
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 {
8902 resultobj = wxPyMake_wxObject(result, 1);
8903 }
8904 {
8905 if (temp2)
8906 delete arg2;
8907 }
8908 return resultobj;
8909 fail:
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return NULL;
8915 }
8916
8917
8918 static PyObject *_wrap_wxFileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj;
8920 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8921 wxString *arg2 = 0 ;
8922 int arg3 = (int) 0 ;
8923 wxString result;
8924 bool temp2 = false ;
8925 PyObject * obj0 = 0 ;
8926 PyObject * obj1 = 0 ;
8927 PyObject * obj2 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self",(char *) "spec",(char *) "flags", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxFileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 arg2 = wxString_in_helper(obj1);
8937 if (arg2 == NULL) SWIG_fail;
8938 temp2 = true;
8939 }
8940 if (obj2) {
8941 {
8942 arg3 = (int)(SWIG_As_int(obj2));
8943 if (SWIG_arg_fail(3)) SWIG_fail;
8944 }
8945 }
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 #if wxUSE_UNICODE
8955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8956 #else
8957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8958 #endif
8959 }
8960 {
8961 if (temp2)
8962 delete arg2;
8963 }
8964 return resultobj;
8965 fail:
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_wxFileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8977 wxString result;
8978 PyObject * obj0 = 0 ;
8979 char *kwnames[] = {
8980 (char *) "self", NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFileSystem_FindNext",kwnames,&obj0)) goto fail;
8984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (arg1)->FindNext();
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 {
8994 #if wxUSE_UNICODE
8995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8996 #else
8997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8998 #endif
8999 }
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_wxFileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9009 PyObject * obj0 = 0 ;
9010 char *kwnames[] = {
9011 (char *) "handler", NULL
9012 };
9013
9014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFileSystem_AddHandler",kwnames,&obj0)) goto fail;
9015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9016 if (SWIG_arg_fail(1)) SWIG_fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxFileSystem::AddHandler(arg1);
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_wxFileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 char *kwnames[] = {
9034 NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxFileSystem_CleanUpHandlers",kwnames)) goto fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 wxFileSystem::CleanUpHandlers();
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_wxFileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxString *arg1 = 0 ;
9055 wxString result;
9056 bool temp1 = false ;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "filename", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9063 {
9064 arg1 = wxString_in_helper(obj0);
9065 if (arg1 == NULL) SWIG_fail;
9066 temp1 = true;
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 {
9076 #if wxUSE_UNICODE
9077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9078 #else
9079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9080 #endif
9081 }
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return resultobj;
9087 fail:
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_wxFileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxString *arg1 = 0 ;
9099 wxString result;
9100 bool temp1 = false ;
9101 PyObject * obj0 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "url", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9107 {
9108 arg1 = wxString_in_helper(obj0);
9109 if (arg1 == NULL) SWIG_fail;
9110 temp1 = true;
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9115
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 {
9120 #if wxUSE_UNICODE
9121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9122 #else
9123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9124 #endif
9125 }
9126 {
9127 if (temp1)
9128 delete arg1;
9129 }
9130 return resultobj;
9131 fail:
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return NULL;
9137 }
9138
9139
9140 static PyObject * wxFileSystem_swigregister(PyObject *, PyObject *args) {
9141 PyObject *obj;
9142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9143 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9144 Py_INCREF(obj);
9145 return Py_BuildValue((char *)"");
9146 }
9147 static PyObject *_wrap_new_wxInternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9148 PyObject *resultobj;
9149 wxInternetFSHandler *result;
9150 char *kwnames[] = {
9151 NULL
9152 };
9153
9154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxInternetFSHandler",kwnames)) goto fail;
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9163 return resultobj;
9164 fail:
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_wxInternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj;
9171 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9172 wxString *arg2 = 0 ;
9173 bool result;
9174 bool temp2 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 char *kwnames[] = {
9178 (char *) "self",(char *) "location", NULL
9179 };
9180
9181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxInternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9183 if (SWIG_arg_fail(1)) SWIG_fail;
9184 {
9185 arg2 = wxString_in_helper(obj1);
9186 if (arg2 == NULL) SWIG_fail;
9187 temp2 = true;
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 {
9197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9198 }
9199 {
9200 if (temp2)
9201 delete arg2;
9202 }
9203 return resultobj;
9204 fail:
9205 {
9206 if (temp2)
9207 delete arg2;
9208 }
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_wxInternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9216 wxFileSystem *arg2 = 0 ;
9217 wxString *arg3 = 0 ;
9218 wxFSFile *result;
9219 bool temp3 = false ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 PyObject * obj2 = 0 ;
9223 char *kwnames[] = {
9224 (char *) "self",(char *) "fs",(char *) "location", NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxInternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9229 if (SWIG_arg_fail(1)) SWIG_fail;
9230 {
9231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9232 if (SWIG_arg_fail(2)) SWIG_fail;
9233 if (arg2 == NULL) {
9234 SWIG_null_ref("wxFileSystem");
9235 }
9236 if (SWIG_arg_fail(2)) SWIG_fail;
9237 }
9238 {
9239 arg3 = wxString_in_helper(obj2);
9240 if (arg3 == NULL) SWIG_fail;
9241 temp3 = true;
9242 }
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = wxPyMake_wxObject(result, 1);
9252 }
9253 {
9254 if (temp3)
9255 delete arg3;
9256 }
9257 return resultobj;
9258 fail:
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return NULL;
9264 }
9265
9266
9267 static PyObject * wxInternetFSHandler_swigregister(PyObject *, PyObject *args) {
9268 PyObject *obj;
9269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9270 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9271 Py_INCREF(obj);
9272 return Py_BuildValue((char *)"");
9273 }
9274 static PyObject *_wrap_new_wxZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 wxZipFSHandler *result;
9277 char *kwnames[] = {
9278 NULL
9279 };
9280
9281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxZipFSHandler",kwnames)) goto fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (wxZipFSHandler *)new wxZipFSHandler();
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_wxZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9299 wxString *arg2 = 0 ;
9300 bool result;
9301 bool temp2 = false ;
9302 PyObject * obj0 = 0 ;
9303 PyObject * obj1 = 0 ;
9304 char *kwnames[] = {
9305 (char *) "self",(char *) "location", NULL
9306 };
9307
9308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9310 if (SWIG_arg_fail(1)) SWIG_fail;
9311 {
9312 arg2 = wxString_in_helper(obj1);
9313 if (arg2 == NULL) SWIG_fail;
9314 temp2 = true;
9315 }
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 {
9324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9325 }
9326 {
9327 if (temp2)
9328 delete arg2;
9329 }
9330 return resultobj;
9331 fail:
9332 {
9333 if (temp2)
9334 delete arg2;
9335 }
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_wxZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9343 wxFileSystem *arg2 = 0 ;
9344 wxString *arg3 = 0 ;
9345 wxFSFile *result;
9346 bool temp3 = false ;
9347 PyObject * obj0 = 0 ;
9348 PyObject * obj1 = 0 ;
9349 PyObject * obj2 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "self",(char *) "fs",(char *) "location", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(2)) SWIG_fail;
9360 if (arg2 == NULL) {
9361 SWIG_null_ref("wxFileSystem");
9362 }
9363 if (SWIG_arg_fail(2)) SWIG_fail;
9364 }
9365 {
9366 arg3 = wxString_in_helper(obj2);
9367 if (arg3 == NULL) SWIG_fail;
9368 temp3 = true;
9369 }
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9373
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 resultobj = wxPyMake_wxObject(result, 1);
9379 }
9380 {
9381 if (temp3)
9382 delete arg3;
9383 }
9384 return resultobj;
9385 fail:
9386 {
9387 if (temp3)
9388 delete arg3;
9389 }
9390 return NULL;
9391 }
9392
9393
9394 static PyObject *_wrap_wxZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj;
9396 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9397 wxString *arg2 = 0 ;
9398 int arg3 = (int) 0 ;
9399 wxString result;
9400 bool temp2 = false ;
9401 PyObject * obj0 = 0 ;
9402 PyObject * obj1 = 0 ;
9403 PyObject * obj2 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "self",(char *) "spec",(char *) "flags", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 {
9412 arg2 = wxString_in_helper(obj1);
9413 if (arg2 == NULL) SWIG_fail;
9414 temp2 = true;
9415 }
9416 if (obj2) {
9417 {
9418 arg3 = (int)(SWIG_As_int(obj2));
9419 if (SWIG_arg_fail(3)) SWIG_fail;
9420 }
9421 }
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 #if wxUSE_UNICODE
9431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9432 #else
9433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9434 #endif
9435 }
9436 {
9437 if (temp2)
9438 delete arg2;
9439 }
9440 return resultobj;
9441 fail:
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return NULL;
9447 }
9448
9449
9450 static PyObject *_wrap_wxZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj;
9452 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9453 wxString result;
9454 PyObject * obj0 = 0 ;
9455 char *kwnames[] = {
9456 (char *) "self", NULL
9457 };
9458
9459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9461 if (SWIG_arg_fail(1)) SWIG_fail;
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (arg1)->FindNext();
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 {
9470 #if wxUSE_UNICODE
9471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9472 #else
9473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9474 #endif
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject * wxZipFSHandler_swigregister(PyObject *, PyObject *args) {
9483 PyObject *obj;
9484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9485 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9486 Py_INCREF(obj);
9487 return Py_BuildValue((char *)"");
9488 }
9489 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxString *arg1 = 0 ;
9492 wxImage *arg2 = 0 ;
9493 long arg3 ;
9494 bool temp1 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 PyObject * obj2 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "filename",(char *) "image",(char *) "type", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9503 {
9504 arg1 = wxString_in_helper(obj0);
9505 if (arg1 == NULL) SWIG_fail;
9506 temp1 = true;
9507 }
9508 {
9509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(2)) SWIG_fail;
9511 if (arg2 == NULL) {
9512 SWIG_null_ref("wxImage");
9513 }
9514 if (SWIG_arg_fail(2)) SWIG_fail;
9515 }
9516 {
9517 arg3 = (long)(SWIG_As_long(obj2));
9518 if (SWIG_arg_fail(3)) SWIG_fail;
9519 }
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 Py_INCREF(Py_None); resultobj = Py_None;
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return resultobj;
9533 fail:
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return NULL;
9539 }
9540
9541
9542 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxString *arg1 = 0 ;
9545 wxBitmap *arg2 = 0 ;
9546 long arg3 ;
9547 bool temp1 = false ;
9548 PyObject * obj0 = 0 ;
9549 PyObject * obj1 = 0 ;
9550 PyObject * obj2 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 {
9562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9563 if (SWIG_arg_fail(2)) SWIG_fail;
9564 if (arg2 == NULL) {
9565 SWIG_null_ref("wxBitmap");
9566 }
9567 if (SWIG_arg_fail(2)) SWIG_fail;
9568 }
9569 {
9570 arg3 = (long)(SWIG_As_long(obj2));
9571 if (SWIG_arg_fail(3)) SWIG_fail;
9572 }
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9576
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 Py_INCREF(Py_None); resultobj = Py_None;
9581 {
9582 if (temp1)
9583 delete arg1;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj;
9597 wxString *arg1 = 0 ;
9598 PyObject *arg2 = (PyObject *) 0 ;
9599 bool temp1 = false ;
9600 PyObject * obj0 = 0 ;
9601 PyObject * obj1 = 0 ;
9602 char *kwnames[] = {
9603 (char *) "filename",(char *) "data", NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9607 {
9608 arg1 = wxString_in_helper(obj0);
9609 if (arg1 == NULL) SWIG_fail;
9610 temp1 = true;
9611 }
9612 arg2 = obj1;
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_new_wxMemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxMemoryFSHandler *result;
9638 char *kwnames[] = {
9639 NULL
9640 };
9641
9642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxMemoryFSHandler",kwnames)) goto fail;
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_wxMemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxString *arg1 = 0 ;
9660 bool temp1 = false ;
9661 PyObject * obj0 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "filename", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9667 {
9668 arg1 = wxString_in_helper(obj0);
9669 if (arg1 == NULL) SWIG_fail;
9670 temp1 = true;
9671 }
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9675
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 Py_INCREF(Py_None); resultobj = Py_None;
9680 {
9681 if (temp1)
9682 delete arg1;
9683 }
9684 return resultobj;
9685 fail:
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return NULL;
9691 }
9692
9693
9694 static PyObject *_wrap_wxMemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj;
9696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9697 wxString *arg2 = 0 ;
9698 bool result;
9699 bool temp2 = false ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 char *kwnames[] = {
9703 (char *) "self",(char *) "location", NULL
9704 };
9705
9706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9708 if (SWIG_arg_fail(1)) SWIG_fail;
9709 {
9710 arg2 = wxString_in_helper(obj1);
9711 if (arg2 == NULL) SWIG_fail;
9712 temp2 = true;
9713 }
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9723 }
9724 {
9725 if (temp2)
9726 delete arg2;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_wxMemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9741 wxFileSystem *arg2 = 0 ;
9742 wxString *arg3 = 0 ;
9743 wxFSFile *result;
9744 bool temp3 = false ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 PyObject * obj2 = 0 ;
9748 char *kwnames[] = {
9749 (char *) "self",(char *) "fs",(char *) "location", NULL
9750 };
9751
9752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9754 if (SWIG_arg_fail(1)) SWIG_fail;
9755 {
9756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(2)) SWIG_fail;
9758 if (arg2 == NULL) {
9759 SWIG_null_ref("wxFileSystem");
9760 }
9761 if (SWIG_arg_fail(2)) SWIG_fail;
9762 }
9763 {
9764 arg3 = wxString_in_helper(obj2);
9765 if (arg3 == NULL) SWIG_fail;
9766 temp3 = true;
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = wxPyMake_wxObject(result, 1);
9777 }
9778 {
9779 if (temp3)
9780 delete arg3;
9781 }
9782 return resultobj;
9783 fail:
9784 {
9785 if (temp3)
9786 delete arg3;
9787 }
9788 return NULL;
9789 }
9790
9791
9792 static PyObject *_wrap_wxMemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9793 PyObject *resultobj;
9794 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9795 wxString *arg2 = 0 ;
9796 int arg3 = (int) 0 ;
9797 wxString result;
9798 bool temp2 = false ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9801 PyObject * obj2 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self",(char *) "spec",(char *) "flags", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxMemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 arg2 = wxString_in_helper(obj1);
9811 if (arg2 == NULL) SWIG_fail;
9812 temp2 = true;
9813 }
9814 if (obj2) {
9815 {
9816 arg3 = (int)(SWIG_As_int(obj2));
9817 if (SWIG_arg_fail(3)) SWIG_fail;
9818 }
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 {
9828 #if wxUSE_UNICODE
9829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9830 #else
9831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9832 #endif
9833 }
9834 {
9835 if (temp2)
9836 delete arg2;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject *_wrap_wxMemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj;
9850 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9851 wxString result;
9852 PyObject * obj0 = 0 ;
9853 char *kwnames[] = {
9854 (char *) "self", NULL
9855 };
9856
9857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9859 if (SWIG_arg_fail(1)) SWIG_fail;
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (arg1)->FindNext();
9863
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject * wxMemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9881 PyObject *obj;
9882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9883 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9884 Py_INCREF(obj);
9885 return Py_BuildValue((char *)"");
9886 }
9887 static PyObject *_wrap_wxImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj;
9889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9890 wxString result;
9891 PyObject * obj0 = 0 ;
9892 char *kwnames[] = {
9893 (char *) "self", NULL
9894 };
9895
9896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImageHandler_GetName",kwnames,&obj0)) goto fail;
9897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9898 if (SWIG_arg_fail(1)) SWIG_fail;
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (arg1)->GetName();
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 {
9907 #if wxUSE_UNICODE
9908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9909 #else
9910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9911 #endif
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_wxImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 wxString result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (arg1)->GetExtension();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 #if wxUSE_UNICODE
9940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9941 #else
9942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9943 #endif
9944 }
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_wxImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9954 long result;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImageHandler_GetType",kwnames,&obj0)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (long)(arg1)->GetType();
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 {
9971 resultobj = SWIG_From_long((long)(result));
9972 }
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 static PyObject *_wrap_wxImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj;
9981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9982 wxString result;
9983 PyObject * obj0 = 0 ;
9984 char *kwnames[] = {
9985 (char *) "self", NULL
9986 };
9987
9988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9990 if (SWIG_arg_fail(1)) SWIG_fail;
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetMimeType();
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 {
9999 #if wxUSE_UNICODE
10000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10001 #else
10002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10003 #endif
10004 }
10005 return resultobj;
10006 fail:
10007 return NULL;
10008 }
10009
10010
10011 static PyObject *_wrap_wxImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10014 wxString *arg2 = 0 ;
10015 bool result;
10016 bool temp2 = false ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 char *kwnames[] = {
10020 (char *) "self",(char *) "name", NULL
10021 };
10022
10023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10025 if (SWIG_arg_fail(1)) SWIG_fail;
10026 {
10027 arg2 = wxString_in_helper(obj1);
10028 if (arg2 == NULL) SWIG_fail;
10029 temp2 = true;
10030 }
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10034
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10040 }
10041 {
10042 if (temp2)
10043 delete arg2;
10044 }
10045 return resultobj;
10046 fail:
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_wxImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10058 wxString *arg2 = 0 ;
10059 bool temp2 = false ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char *kwnames[] = {
10063 (char *) "self",(char *) "name", NULL
10064 };
10065
10066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10068 if (SWIG_arg_fail(1)) SWIG_fail;
10069 {
10070 arg2 = wxString_in_helper(obj1);
10071 if (arg2 == NULL) SWIG_fail;
10072 temp2 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->SetName((wxString const &)*arg2);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 Py_INCREF(Py_None); resultobj = Py_None;
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_wxImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 bool temp2 = false ;
10101 PyObject * obj0 = 0 ;
10102 PyObject * obj1 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "self",(char *) "extension", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10109 if (SWIG_arg_fail(1)) SWIG_fail;
10110 {
10111 arg2 = wxString_in_helper(obj1);
10112 if (arg2 == NULL) SWIG_fail;
10113 temp2 = true;
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->SetExtension((wxString const &)*arg2);
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 {
10124 if (temp2)
10125 delete arg2;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_wxImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj;
10139 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10140 long arg2 ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "type", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10149 if (SWIG_arg_fail(1)) SWIG_fail;
10150 {
10151 arg2 = (long)(SWIG_As_long(obj1));
10152 if (SWIG_arg_fail(2)) SWIG_fail;
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 (arg1)->SetType(arg2);
10157
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 Py_INCREF(Py_None); resultobj = Py_None;
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 static PyObject *_wrap_wxImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj;
10170 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10171 wxString *arg2 = 0 ;
10172 bool temp2 = false ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self",(char *) "mimetype", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 arg2 = wxString_in_helper(obj1);
10184 if (arg2 == NULL) SWIG_fail;
10185 temp2 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 (arg1)->SetMimeType((wxString const &)*arg2);
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 Py_INCREF(Py_None); resultobj = Py_None;
10195 {
10196 if (temp2)
10197 delete arg2;
10198 }
10199 return resultobj;
10200 fail:
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return NULL;
10206 }
10207
10208
10209 static PyObject * wxImageHandler_swigregister(PyObject *, PyObject *args) {
10210 PyObject *obj;
10211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10212 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10213 Py_INCREF(obj);
10214 return Py_BuildValue((char *)"");
10215 }
10216 static PyObject *_wrap_new_wxImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj;
10218 wxImageHistogram *result;
10219 char *kwnames[] = {
10220 NULL
10221 };
10222
10223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxImageHistogram",kwnames)) goto fail;
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (wxImageHistogram *)new wxImageHistogram();
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 static PyObject *_wrap_wxImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj;
10240 unsigned char arg1 ;
10241 unsigned char arg2 ;
10242 unsigned char arg3 ;
10243 unsigned long result;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "r",(char *) "g",(char *) "b", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10252 {
10253 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 }
10256 {
10257 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10258 if (SWIG_arg_fail(2)) SWIG_fail;
10259 }
10260 {
10261 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10262 if (SWIG_arg_fail(3)) SWIG_fail;
10263 }
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10267
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 {
10272 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10273 }
10274 return resultobj;
10275 fail:
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_wxImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10283 unsigned char *arg2 = (unsigned char *) 0 ;
10284 unsigned char *arg3 = (unsigned char *) 0 ;
10285 unsigned char *arg4 = (unsigned char *) 0 ;
10286 unsigned char arg5 = (unsigned char) 1 ;
10287 unsigned char arg6 = (unsigned char) 0 ;
10288 unsigned char arg7 = (unsigned char) 0 ;
10289 bool result;
10290 unsigned char temp2 ;
10291 int res2 = 0 ;
10292 unsigned char temp3 ;
10293 int res3 = 0 ;
10294 unsigned char temp4 ;
10295 int res4 = 0 ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 PyObject * obj2 = 0 ;
10299 PyObject * obj3 = 0 ;
10300 char *kwnames[] = {
10301 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10302 };
10303
10304 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10305 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10306 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:wxImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 if (obj1) {
10311 {
10312 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10313 if (SWIG_arg_fail(5)) SWIG_fail;
10314 }
10315 }
10316 if (obj2) {
10317 {
10318 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10319 if (SWIG_arg_fail(6)) SWIG_fail;
10320 }
10321 }
10322 if (obj3) {
10323 {
10324 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10325 if (SWIG_arg_fail(7)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10337 }
10338 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10339 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10340 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10341 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10342 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10343 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_wxImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10353 unsigned long arg2 ;
10354 unsigned long result;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "self",(char *) "key", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 {
10365 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10366 if (SWIG_arg_fail(2)) SWIG_fail;
10367 }
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10371
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10377 }
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_wxImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj;
10386 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10387 unsigned char arg2 ;
10388 unsigned char arg3 ;
10389 unsigned char arg4 ;
10390 unsigned long result;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 PyObject * obj2 = 0 ;
10394 PyObject * obj3 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 {
10403 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10404 if (SWIG_arg_fail(2)) SWIG_fail;
10405 }
10406 {
10407 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10408 if (SWIG_arg_fail(3)) SWIG_fail;
10409 }
10410 {
10411 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10412 if (SWIG_arg_fail(4)) SWIG_fail;
10413 }
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10423 }
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_wxImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10433 wxColour *arg2 = 0 ;
10434 unsigned long result;
10435 wxColour temp2 ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10438 char *kwnames[] = {
10439 (char *) "self",(char *) "colour", NULL
10440 };
10441
10442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10444 if (SWIG_arg_fail(1)) SWIG_fail;
10445 {
10446 arg2 = &temp2;
10447 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 {
10457 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10458 }
10459 return resultobj;
10460 fail:
10461 return NULL;
10462 }
10463
10464
10465 static PyObject * wxImageHistogram_swigregister(PyObject *, PyObject *args) {
10466 PyObject *obj;
10467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10468 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10469 Py_INCREF(obj);
10470 return Py_BuildValue((char *)"");
10471 }
10472 static PyObject *_wrap_new_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 wxString *arg1 = 0 ;
10475 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10476 int arg3 = (int) -1 ;
10477 wxImage *result;
10478 bool temp1 = false ;
10479 PyObject * obj0 = 0 ;
10480 PyObject * obj1 = 0 ;
10481 PyObject * obj2 = 0 ;
10482 char *kwnames[] = {
10483 (char *) "name",(char *) "type",(char *) "index", NULL
10484 };
10485
10486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10487 {
10488 arg1 = wxString_in_helper(obj0);
10489 if (arg1 == NULL) SWIG_fail;
10490 temp1 = true;
10491 }
10492 if (obj1) {
10493 {
10494 arg2 = (long)(SWIG_As_long(obj1));
10495 if (SWIG_arg_fail(2)) SWIG_fail;
10496 }
10497 }
10498 if (obj2) {
10499 {
10500 arg3 = (int)(SWIG_As_int(obj2));
10501 if (SWIG_arg_fail(3)) SWIG_fail;
10502 }
10503 }
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10512 {
10513 if (temp1)
10514 delete arg1;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 return NULL;
10523 }
10524
10525
10526 static PyObject *_wrap_delete_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
10527 PyObject *resultobj;
10528 wxImage *arg1 = (wxImage *) 0 ;
10529 PyObject * obj0 = 0 ;
10530 char *kwnames[] = {
10531 (char *) "self", NULL
10532 };
10533
10534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxImage",kwnames,&obj0)) goto fail;
10535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 delete arg1;
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 Py_INCREF(Py_None); resultobj = Py_None;
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxString *arg1 = 0 ;
10554 wxString *arg2 = 0 ;
10555 int arg3 = (int) -1 ;
10556 wxImage *result;
10557 bool temp1 = false ;
10558 bool temp2 = false ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561 PyObject * obj2 = 0 ;
10562 char *kwnames[] = {
10563 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10564 };
10565
10566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10567 {
10568 arg1 = wxString_in_helper(obj0);
10569 if (arg1 == NULL) SWIG_fail;
10570 temp1 = true;
10571 }
10572 {
10573 arg2 = wxString_in_helper(obj1);
10574 if (arg2 == NULL) SWIG_fail;
10575 temp2 = true;
10576 }
10577 if (obj2) {
10578 {
10579 arg3 = (int)(SWIG_As_int(obj2));
10580 if (SWIG_arg_fail(3)) SWIG_fail;
10581 }
10582 }
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10586
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj;
10615 wxInputStream *arg1 = 0 ;
10616 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10617 int arg3 = (int) -1 ;
10618 wxImage *result;
10619 wxPyInputStream *temp1 ;
10620 bool created1 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 PyObject * obj2 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "stream",(char *) "type",(char *) "index", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10629 {
10630 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10631 arg1 = temp1->m_wxis;
10632 created1 = false;
10633 } else {
10634 PyErr_Clear(); // clear the failure of the wxPyConvert above
10635 arg1 = wxPyCBInputStream_create(obj0, false);
10636 if (arg1 == NULL) {
10637 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10638 SWIG_fail;
10639 }
10640 created1 = true;
10641 }
10642 }
10643 if (obj1) {
10644 {
10645 arg2 = (long)(SWIG_As_long(obj1));
10646 if (SWIG_arg_fail(2)) SWIG_fail;
10647 }
10648 }
10649 if (obj2) {
10650 {
10651 arg3 = (int)(SWIG_As_int(obj2));
10652 if (SWIG_arg_fail(3)) SWIG_fail;
10653 }
10654 }
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10658
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10663 {
10664 if (created1) delete arg1;
10665 }
10666 return resultobj;
10667 fail:
10668 {
10669 if (created1) delete arg1;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj;
10677 wxInputStream *arg1 = 0 ;
10678 wxString *arg2 = 0 ;
10679 int arg3 = (int) -1 ;
10680 wxImage *result;
10681 wxPyInputStream *temp1 ;
10682 bool created1 ;
10683 bool temp2 = false ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 PyObject * obj2 = 0 ;
10687 char *kwnames[] = {
10688 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10689 };
10690
10691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10692 {
10693 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10694 arg1 = temp1->m_wxis;
10695 created1 = false;
10696 } else {
10697 PyErr_Clear(); // clear the failure of the wxPyConvert above
10698 arg1 = wxPyCBInputStream_create(obj0, false);
10699 if (arg1 == NULL) {
10700 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10701 SWIG_fail;
10702 }
10703 created1 = true;
10704 }
10705 }
10706 {
10707 arg2 = wxString_in_helper(obj1);
10708 if (arg2 == NULL) SWIG_fail;
10709 temp2 = true;
10710 }
10711 if (obj2) {
10712 {
10713 arg3 = (int)(SWIG_As_int(obj2));
10714 if (SWIG_arg_fail(3)) SWIG_fail;
10715 }
10716 }
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10725 {
10726 if (created1) delete arg1;
10727 }
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return resultobj;
10733 fail:
10734 {
10735 if (created1) delete arg1;
10736 }
10737 {
10738 if (temp2)
10739 delete arg2;
10740 }
10741 return NULL;
10742 }
10743
10744
10745 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 int arg1 = (int) 0 ;
10748 int arg2 = (int) 0 ;
10749 bool arg3 = (bool) true ;
10750 wxImage *result;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 PyObject * obj2 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "width",(char *) "height",(char *) "clear", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10759 if (obj0) {
10760 {
10761 arg1 = (int)(SWIG_As_int(obj0));
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 }
10764 }
10765 if (obj1) {
10766 {
10767 arg2 = (int)(SWIG_As_int(obj1));
10768 if (SWIG_arg_fail(2)) SWIG_fail;
10769 }
10770 }
10771 if (obj2) {
10772 {
10773 arg3 = (bool)(SWIG_As_bool(obj2));
10774 if (SWIG_arg_fail(3)) SWIG_fail;
10775 }
10776 }
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj;
10793 wxBitmap *arg1 = 0 ;
10794 wxImage *result;
10795 PyObject * obj0 = 0 ;
10796 char *kwnames[] = {
10797 (char *) "bitmap", NULL
10798 };
10799
10800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10801 {
10802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10803 if (SWIG_arg_fail(1)) SWIG_fail;
10804 if (arg1 == NULL) {
10805 SWIG_null_ref("wxBitmap");
10806 }
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 }
10809 {
10810 if (!wxPyCheckForApp()) SWIG_fail;
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 int arg1 ;
10827 int arg2 ;
10828 buffer arg3 ;
10829 int arg4 ;
10830 wxImage *result;
10831 PyObject * obj0 = 0 ;
10832 PyObject * obj1 = 0 ;
10833 PyObject * obj2 = 0 ;
10834 char *kwnames[] = {
10835 (char *) "width",(char *) "height",(char *) "data", NULL
10836 };
10837
10838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10839 {
10840 arg1 = (int)(SWIG_As_int(obj0));
10841 if (SWIG_arg_fail(1)) SWIG_fail;
10842 }
10843 {
10844 arg2 = (int)(SWIG_As_int(obj1));
10845 if (SWIG_arg_fail(2)) SWIG_fail;
10846 }
10847 {
10848 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10853
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 int arg1 ;
10867 int arg2 ;
10868 buffer arg3 ;
10869 int arg4 ;
10870 buffer arg5 ;
10871 int arg6 ;
10872 wxImage *result;
10873 PyObject * obj0 = 0 ;
10874 PyObject * obj1 = 0 ;
10875 PyObject * obj2 = 0 ;
10876 PyObject * obj3 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10882 {
10883 arg1 = (int)(SWIG_As_int(obj0));
10884 if (SWIG_arg_fail(1)) SWIG_fail;
10885 }
10886 {
10887 arg2 = (int)(SWIG_As_int(obj1));
10888 if (SWIG_arg_fail(2)) SWIG_fail;
10889 }
10890 {
10891 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10892 }
10893 {
10894 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_wxImage_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxImage *arg1 = (wxImage *) 0 ;
10913 int arg2 ;
10914 int arg3 ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 PyObject * obj2 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self",(char *) "width",(char *) "height", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 arg2 = (int)(SWIG_As_int(obj1));
10927 if (SWIG_arg_fail(2)) SWIG_fail;
10928 }
10929 {
10930 arg3 = (int)(SWIG_As_int(obj2));
10931 if (SWIG_arg_fail(3)) SWIG_fail;
10932 }
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 (arg1)->Create(arg2,arg3);
10936
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 Py_INCREF(Py_None); resultobj = Py_None;
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 static PyObject *_wrap_wxImage_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj;
10949 wxImage *arg1 = (wxImage *) 0 ;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_Destroy",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->Destroy();
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject *_wrap_wxImage_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj;
10974 wxImage *arg1 = (wxImage *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 SwigValueWrapper<wxImage > result;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "width",(char *) "height", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (arg1)->Scale(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 wxImage * resultptr;
11005 resultptr = new wxImage((wxImage &)(result));
11006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_wxImage_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxImage *arg1 = (wxImage *) 0 ;
11017 int arg2 ;
11018 int arg3 ;
11019 SwigValueWrapper<wxImage > result;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 arg2 = (int)(SWIG_As_int(obj1));
11032 if (SWIG_arg_fail(2)) SWIG_fail;
11033 }
11034 {
11035 arg3 = (int)(SWIG_As_int(obj2));
11036 if (SWIG_arg_fail(3)) SWIG_fail;
11037 }
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 wxImage * resultptr;
11047 resultptr = new wxImage((wxImage &)(result));
11048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_wxImage_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxImage *arg1 = (wxImage *) 0 ;
11059 int arg2 ;
11060 int arg3 ;
11061 wxImage *result;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 PyObject * obj2 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self",(char *) "width",(char *) "height", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 arg2 = (int)(SWIG_As_int(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 {
11077 arg3 = (int)(SWIG_As_int(obj2));
11078 if (SWIG_arg_fail(3)) SWIG_fail;
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 {
11083 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11084 result = (wxImage *) &_result_ref;
11085 }
11086
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 static PyObject *_wrap_wxImage_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj;
11099 wxImage *arg1 = (wxImage *) 0 ;
11100 wxSize *arg2 = 0 ;
11101 wxPoint *arg3 = 0 ;
11102 int arg4 = (int) -1 ;
11103 int arg5 = (int) -1 ;
11104 int arg6 = (int) -1 ;
11105 wxImage *result;
11106 wxSize temp2 ;
11107 wxPoint temp3 ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 PyObject * obj2 = 0 ;
11111 PyObject * obj3 = 0 ;
11112 PyObject * obj4 = 0 ;
11113 PyObject * obj5 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:wxImage_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 arg2 = &temp2;
11123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11124 }
11125 {
11126 arg3 = &temp3;
11127 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11128 }
11129 if (obj3) {
11130 {
11131 arg4 = (int)(SWIG_As_int(obj3));
11132 if (SWIG_arg_fail(4)) SWIG_fail;
11133 }
11134 }
11135 if (obj4) {
11136 {
11137 arg5 = (int)(SWIG_As_int(obj4));
11138 if (SWIG_arg_fail(5)) SWIG_fail;
11139 }
11140 }
11141 if (obj5) {
11142 {
11143 arg6 = (int)(SWIG_As_int(obj5));
11144 if (SWIG_arg_fail(6)) SWIG_fail;
11145 }
11146 }
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 {
11150 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11151 result = (wxImage *) &_result_ref;
11152 }
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_wxImage_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxImage *arg1 = (wxImage *) 0 ;
11167 int arg2 ;
11168 int arg3 ;
11169 unsigned char arg4 ;
11170 unsigned char arg5 ;
11171 unsigned char arg6 ;
11172 PyObject * obj0 = 0 ;
11173 PyObject * obj1 = 0 ;
11174 PyObject * obj2 = 0 ;
11175 PyObject * obj3 = 0 ;
11176 PyObject * obj4 = 0 ;
11177 PyObject * obj5 = 0 ;
11178 char *kwnames[] = {
11179 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11180 };
11181
11182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:wxImage_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11184 if (SWIG_arg_fail(1)) SWIG_fail;
11185 {
11186 arg2 = (int)(SWIG_As_int(obj1));
11187 if (SWIG_arg_fail(2)) SWIG_fail;
11188 }
11189 {
11190 arg3 = (int)(SWIG_As_int(obj2));
11191 if (SWIG_arg_fail(3)) SWIG_fail;
11192 }
11193 {
11194 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11195 if (SWIG_arg_fail(4)) SWIG_fail;
11196 }
11197 {
11198 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11199 if (SWIG_arg_fail(5)) SWIG_fail;
11200 }
11201 {
11202 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11203 if (SWIG_arg_fail(6)) SWIG_fail;
11204 }
11205 {
11206 PyThreadState* __tstate = wxPyBeginAllowThreads();
11207 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11208
11209 wxPyEndAllowThreads(__tstate);
11210 if (PyErr_Occurred()) SWIG_fail;
11211 }
11212 Py_INCREF(Py_None); resultobj = Py_None;
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 static PyObject *_wrap_wxImage_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11220 PyObject *resultobj;
11221 wxImage *arg1 = (wxImage *) 0 ;
11222 wxRect *arg2 = 0 ;
11223 unsigned char arg3 ;
11224 unsigned char arg4 ;
11225 unsigned char arg5 ;
11226 wxRect temp2 ;
11227 PyObject * obj0 = 0 ;
11228 PyObject * obj1 = 0 ;
11229 PyObject * obj2 = 0 ;
11230 PyObject * obj3 = 0 ;
11231 PyObject * obj4 = 0 ;
11232 char *kwnames[] = {
11233 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11234 };
11235
11236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:wxImage_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11238 if (SWIG_arg_fail(1)) SWIG_fail;
11239 {
11240 arg2 = &temp2;
11241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11242 }
11243 {
11244 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11245 if (SWIG_arg_fail(3)) SWIG_fail;
11246 }
11247 {
11248 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11249 if (SWIG_arg_fail(4)) SWIG_fail;
11250 }
11251 {
11252 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11253 if (SWIG_arg_fail(5)) SWIG_fail;
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 Py_INCREF(Py_None); resultobj = Py_None;
11263 return resultobj;
11264 fail:
11265 return NULL;
11266 }
11267
11268
11269 static PyObject *_wrap_wxImage_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11270 PyObject *resultobj;
11271 wxImage *arg1 = (wxImage *) 0 ;
11272 int arg2 ;
11273 int arg3 ;
11274 unsigned char result;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 char *kwnames[] = {
11279 (char *) "self",(char *) "x",(char *) "y", NULL
11280 };
11281
11282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11284 if (SWIG_arg_fail(1)) SWIG_fail;
11285 {
11286 arg2 = (int)(SWIG_As_int(obj1));
11287 if (SWIG_arg_fail(2)) SWIG_fail;
11288 }
11289 {
11290 arg3 = (int)(SWIG_As_int(obj2));
11291 if (SWIG_arg_fail(3)) SWIG_fail;
11292 }
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_wxImage_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 int arg2 ;
11313 int arg3 ;
11314 unsigned char result;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 PyObject * obj2 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self",(char *) "x",(char *) "y", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 {
11326 arg2 = (int)(SWIG_As_int(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 {
11330 arg3 = (int)(SWIG_As_int(obj2));
11331 if (SWIG_arg_fail(3)) SWIG_fail;
11332 }
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11336
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 {
11341 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_wxImage_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxImage *arg1 = (wxImage *) 0 ;
11352 int arg2 ;
11353 int arg3 ;
11354 unsigned char result;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 PyObject * obj2 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "x",(char *) "y", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (int)(SWIG_As_int(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 {
11370 arg3 = (int)(SWIG_As_int(obj2));
11371 if (SWIG_arg_fail(3)) SWIG_fail;
11372 }
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11376
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 {
11381 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11382 }
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 static PyObject *_wrap_wxImage_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11390 PyObject *resultobj;
11391 wxImage *arg1 = (wxImage *) 0 ;
11392 int arg2 ;
11393 int arg3 ;
11394 unsigned char arg4 ;
11395 PyObject * obj0 = 0 ;
11396 PyObject * obj1 = 0 ;
11397 PyObject * obj2 = 0 ;
11398 PyObject * obj3 = 0 ;
11399 char *kwnames[] = {
11400 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11401 };
11402
11403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImage_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11405 if (SWIG_arg_fail(1)) SWIG_fail;
11406 {
11407 arg2 = (int)(SWIG_As_int(obj1));
11408 if (SWIG_arg_fail(2)) SWIG_fail;
11409 }
11410 {
11411 arg3 = (int)(SWIG_As_int(obj2));
11412 if (SWIG_arg_fail(3)) SWIG_fail;
11413 }
11414 {
11415 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11416 if (SWIG_arg_fail(4)) SWIG_fail;
11417 }
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 (arg1)->SetAlpha(arg2,arg3,arg4);
11421
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 Py_INCREF(Py_None); resultobj = Py_None;
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 static PyObject *_wrap_wxImage_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj;
11434 wxImage *arg1 = (wxImage *) 0 ;
11435 int arg2 ;
11436 int arg3 ;
11437 unsigned char result;
11438 PyObject * obj0 = 0 ;
11439 PyObject * obj1 = 0 ;
11440 PyObject * obj2 = 0 ;
11441 char *kwnames[] = {
11442 (char *) "self",(char *) "x",(char *) "y", NULL
11443 };
11444
11445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11447 if (SWIG_arg_fail(1)) SWIG_fail;
11448 {
11449 arg2 = (int)(SWIG_As_int(obj1));
11450 if (SWIG_arg_fail(2)) SWIG_fail;
11451 }
11452 {
11453 arg3 = (int)(SWIG_As_int(obj2));
11454 if (SWIG_arg_fail(3)) SWIG_fail;
11455 }
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11459
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 {
11464 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11465 }
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 static PyObject *_wrap_wxImage_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj;
11474 wxImage *arg1 = (wxImage *) 0 ;
11475 bool result;
11476 PyObject * obj0 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "self", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_HasAlpha",kwnames,&obj0)) goto fail;
11482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11483 if (SWIG_arg_fail(1)) SWIG_fail;
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (bool)(arg1)->HasAlpha();
11487
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11493 }
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 static PyObject *_wrap_wxImage_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj;
11502 wxImage *arg1 = (wxImage *) 0 ;
11503 PyObject * obj0 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "self", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_InitAlpha",kwnames,&obj0)) goto fail;
11509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11510 if (SWIG_arg_fail(1)) SWIG_fail;
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 (arg1)->InitAlpha();
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 Py_INCREF(Py_None); resultobj = Py_None;
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_wxImage_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 wxImage *arg1 = (wxImage *) 0 ;
11528 byte *arg2 = (byte *) 0 ;
11529 byte *arg3 = (byte *) 0 ;
11530 byte *arg4 = (byte *) 0 ;
11531 byte arg5 = (byte) 0 ;
11532 byte arg6 = (byte) 0 ;
11533 byte arg7 = (byte) 0 ;
11534 bool result;
11535 byte temp2 ;
11536 int res2 = 0 ;
11537 byte temp3 ;
11538 int res3 = 0 ;
11539 byte temp4 ;
11540 int res4 = 0 ;
11541 PyObject * obj0 = 0 ;
11542 PyObject * obj1 = 0 ;
11543 PyObject * obj2 = 0 ;
11544 PyObject * obj3 = 0 ;
11545 char *kwnames[] = {
11546 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11547 };
11548
11549 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11550 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11551 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:wxImage_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11554 if (SWIG_arg_fail(1)) SWIG_fail;
11555 if (obj1) {
11556 {
11557 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11558 if (SWIG_arg_fail(5)) SWIG_fail;
11559 }
11560 }
11561 if (obj2) {
11562 {
11563 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11564 if (SWIG_arg_fail(6)) SWIG_fail;
11565 }
11566 }
11567 if (obj3) {
11568 {
11569 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11570 if (SWIG_arg_fail(7)) SWIG_fail;
11571 }
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 {
11581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11582 }
11583 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11584 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11585 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11586 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11587 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11588 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_wxImage_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxImage *arg1 = (wxImage *) 0 ;
11598 byte arg2 = (byte) 128 ;
11599 bool result;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "self",(char *) "threshold", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 if (obj1) {
11610 {
11611 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11612 if (SWIG_arg_fail(2)) SWIG_fail;
11613 }
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 {
11623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11624 }
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_wxImage_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxImage *arg1 = (wxImage *) 0 ;
11634 unsigned char arg2 ;
11635 unsigned char arg3 ;
11636 unsigned char arg4 ;
11637 bool result;
11638 PyObject * obj0 = 0 ;
11639 PyObject * obj1 = 0 ;
11640 PyObject * obj2 = 0 ;
11641 PyObject * obj3 = 0 ;
11642 char *kwnames[] = {
11643 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11644 };
11645
11646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImage_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11648 if (SWIG_arg_fail(1)) SWIG_fail;
11649 {
11650 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11651 if (SWIG_arg_fail(2)) SWIG_fail;
11652 }
11653 {
11654 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11655 if (SWIG_arg_fail(3)) SWIG_fail;
11656 }
11657 {
11658 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11659 if (SWIG_arg_fail(4)) SWIG_fail;
11660 }
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11664
11665 wxPyEndAllowThreads(__tstate);
11666 if (PyErr_Occurred()) SWIG_fail;
11667 }
11668 {
11669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11670 }
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_wxImage_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxImage *arg1 = (wxImage *) 0 ;
11680 wxImage *arg2 = 0 ;
11681 byte arg3 ;
11682 byte arg4 ;
11683 byte arg5 ;
11684 bool result;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 PyObject * obj3 = 0 ;
11689 PyObject * obj4 = 0 ;
11690 char *kwnames[] = {
11691 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11692 };
11693
11694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:wxImage_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 {
11698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(2)) SWIG_fail;
11700 if (arg2 == NULL) {
11701 SWIG_null_ref("wxImage");
11702 }
11703 if (SWIG_arg_fail(2)) SWIG_fail;
11704 }
11705 {
11706 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11707 if (SWIG_arg_fail(3)) SWIG_fail;
11708 }
11709 {
11710 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11711 if (SWIG_arg_fail(4)) SWIG_fail;
11712 }
11713 {
11714 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11715 if (SWIG_arg_fail(5)) SWIG_fail;
11716 }
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11720
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11726 }
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 static PyObject *_wrap_wxImage_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj;
11735 wxString *arg1 = 0 ;
11736 bool result;
11737 bool temp1 = false ;
11738 PyObject * obj0 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "name", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_CanRead",kwnames,&obj0)) goto fail;
11744 {
11745 arg1 = wxString_in_helper(obj0);
11746 if (arg1 == NULL) SWIG_fail;
11747 temp1 = true;
11748 }
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11752
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 {
11757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11758 }
11759 {
11760 if (temp1)
11761 delete arg1;
11762 }
11763 return resultobj;
11764 fail:
11765 {
11766 if (temp1)
11767 delete arg1;
11768 }
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_wxImage_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxString *arg1 = 0 ;
11776 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11777 int result;
11778 bool temp1 = false ;
11779 PyObject * obj0 = 0 ;
11780 PyObject * obj1 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "name",(char *) "type", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11786 {
11787 arg1 = wxString_in_helper(obj0);
11788 if (arg1 == NULL) SWIG_fail;
11789 temp1 = true;
11790 }
11791 if (obj1) {
11792 {
11793 arg2 = (long)(SWIG_As_long(obj1));
11794 if (SWIG_arg_fail(2)) SWIG_fail;
11795 }
11796 }
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11800
11801 wxPyEndAllowThreads(__tstate);
11802 if (PyErr_Occurred()) SWIG_fail;
11803 }
11804 {
11805 resultobj = SWIG_From_int((int)(result));
11806 }
11807 {
11808 if (temp1)
11809 delete arg1;
11810 }
11811 return resultobj;
11812 fail:
11813 {
11814 if (temp1)
11815 delete arg1;
11816 }
11817 return NULL;
11818 }
11819
11820
11821 static PyObject *_wrap_wxImage_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11822 PyObject *resultobj;
11823 wxImage *arg1 = (wxImage *) 0 ;
11824 wxString *arg2 = 0 ;
11825 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11826 int arg4 = (int) -1 ;
11827 bool result;
11828 bool temp2 = false ;
11829 PyObject * obj0 = 0 ;
11830 PyObject * obj1 = 0 ;
11831 PyObject * obj2 = 0 ;
11832 PyObject * obj3 = 0 ;
11833 char *kwnames[] = {
11834 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11835 };
11836
11837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxImage_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11839 if (SWIG_arg_fail(1)) SWIG_fail;
11840 {
11841 arg2 = wxString_in_helper(obj1);
11842 if (arg2 == NULL) SWIG_fail;
11843 temp2 = true;
11844 }
11845 if (obj2) {
11846 {
11847 arg3 = (long)(SWIG_As_long(obj2));
11848 if (SWIG_arg_fail(3)) SWIG_fail;
11849 }
11850 }
11851 if (obj3) {
11852 {
11853 arg4 = (int)(SWIG_As_int(obj3));
11854 if (SWIG_arg_fail(4)) SWIG_fail;
11855 }
11856 }
11857 {
11858 PyThreadState* __tstate = wxPyBeginAllowThreads();
11859 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11860
11861 wxPyEndAllowThreads(__tstate);
11862 if (PyErr_Occurred()) SWIG_fail;
11863 }
11864 {
11865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11866 }
11867 {
11868 if (temp2)
11869 delete arg2;
11870 }
11871 return resultobj;
11872 fail:
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return NULL;
11878 }
11879
11880
11881 static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11882 PyObject *resultobj;
11883 wxImage *arg1 = (wxImage *) 0 ;
11884 wxString *arg2 = 0 ;
11885 wxString *arg3 = 0 ;
11886 int arg4 = (int) -1 ;
11887 bool result;
11888 bool temp2 = false ;
11889 bool temp3 = false ;
11890 PyObject * obj0 = 0 ;
11891 PyObject * obj1 = 0 ;
11892 PyObject * obj2 = 0 ;
11893 PyObject * obj3 = 0 ;
11894 char *kwnames[] = {
11895 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11896 };
11897
11898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxImage_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11900 if (SWIG_arg_fail(1)) SWIG_fail;
11901 {
11902 arg2 = wxString_in_helper(obj1);
11903 if (arg2 == NULL) SWIG_fail;
11904 temp2 = true;
11905 }
11906 {
11907 arg3 = wxString_in_helper(obj2);
11908 if (arg3 == NULL) SWIG_fail;
11909 temp3 = true;
11910 }
11911 if (obj3) {
11912 {
11913 arg4 = (int)(SWIG_As_int(obj3));
11914 if (SWIG_arg_fail(4)) SWIG_fail;
11915 }
11916 }
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11920
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 {
11925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11926 }
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 {
11932 if (temp3)
11933 delete arg3;
11934 }
11935 return resultobj;
11936 fail:
11937 {
11938 if (temp2)
11939 delete arg2;
11940 }
11941 {
11942 if (temp3)
11943 delete arg3;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 static PyObject *_wrap_wxImage_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj;
11951 wxImage *arg1 = (wxImage *) 0 ;
11952 wxString *arg2 = 0 ;
11953 int arg3 ;
11954 bool result;
11955 bool temp2 = false ;
11956 PyObject * obj0 = 0 ;
11957 PyObject * obj1 = 0 ;
11958 PyObject * obj2 = 0 ;
11959 char *kwnames[] = {
11960 (char *) "self",(char *) "name",(char *) "type", NULL
11961 };
11962
11963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11965 if (SWIG_arg_fail(1)) SWIG_fail;
11966 {
11967 arg2 = wxString_in_helper(obj1);
11968 if (arg2 == NULL) SWIG_fail;
11969 temp2 = true;
11970 }
11971 {
11972 arg3 = (int)(SWIG_As_int(obj2));
11973 if (SWIG_arg_fail(3)) SWIG_fail;
11974 }
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11984 }
11985 {
11986 if (temp2)
11987 delete arg2;
11988 }
11989 return resultobj;
11990 fail:
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj;
12001 wxImage *arg1 = (wxImage *) 0 ;
12002 wxString *arg2 = 0 ;
12003 wxString *arg3 = 0 ;
12004 bool result;
12005 bool temp2 = false ;
12006 bool temp3 = false ;
12007 PyObject * obj0 = 0 ;
12008 PyObject * obj1 = 0 ;
12009 PyObject * obj2 = 0 ;
12010 char *kwnames[] = {
12011 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12012 };
12013
12014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12016 if (SWIG_arg_fail(1)) SWIG_fail;
12017 {
12018 arg2 = wxString_in_helper(obj1);
12019 if (arg2 == NULL) SWIG_fail;
12020 temp2 = true;
12021 }
12022 {
12023 arg3 = wxString_in_helper(obj2);
12024 if (arg3 == NULL) SWIG_fail;
12025 temp3 = true;
12026 }
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12030
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 {
12035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12036 }
12037 {
12038 if (temp2)
12039 delete arg2;
12040 }
12041 {
12042 if (temp3)
12043 delete arg3;
12044 }
12045 return resultobj;
12046 fail:
12047 {
12048 if (temp2)
12049 delete arg2;
12050 }
12051 {
12052 if (temp3)
12053 delete arg3;
12054 }
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_wxImage_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxInputStream *arg1 = 0 ;
12062 bool result;
12063 wxPyInputStream *temp1 ;
12064 bool created1 ;
12065 PyObject * obj0 = 0 ;
12066 char *kwnames[] = {
12067 (char *) "stream", NULL
12068 };
12069
12070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_CanReadStream",kwnames,&obj0)) goto fail;
12071 {
12072 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12073 arg1 = temp1->m_wxis;
12074 created1 = false;
12075 } else {
12076 PyErr_Clear(); // clear the failure of the wxPyConvert above
12077 arg1 = wxPyCBInputStream_create(obj0, false);
12078 if (arg1 == NULL) {
12079 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12080 SWIG_fail;
12081 }
12082 created1 = true;
12083 }
12084 }
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = (bool)wxImage::CanRead(*arg1);
12088
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 {
12093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12094 }
12095 {
12096 if (created1) delete arg1;
12097 }
12098 return resultobj;
12099 fail:
12100 {
12101 if (created1) delete arg1;
12102 }
12103 return NULL;
12104 }
12105
12106
12107 static PyObject *_wrap_wxImage_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj;
12109 wxImage *arg1 = (wxImage *) 0 ;
12110 wxInputStream *arg2 = 0 ;
12111 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12112 int arg4 = (int) -1 ;
12113 bool result;
12114 wxPyInputStream *temp2 ;
12115 bool created2 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 PyObject * obj2 = 0 ;
12119 PyObject * obj3 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxImage_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12126 if (SWIG_arg_fail(1)) SWIG_fail;
12127 {
12128 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12129 arg2 = temp2->m_wxis;
12130 created2 = false;
12131 } else {
12132 PyErr_Clear(); // clear the failure of the wxPyConvert above
12133 arg2 = wxPyCBInputStream_create(obj1, false);
12134 if (arg2 == NULL) {
12135 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12136 SWIG_fail;
12137 }
12138 created2 = true;
12139 }
12140 }
12141 if (obj2) {
12142 {
12143 arg3 = (long)(SWIG_As_long(obj2));
12144 if (SWIG_arg_fail(3)) SWIG_fail;
12145 }
12146 }
12147 if (obj3) {
12148 {
12149 arg4 = (int)(SWIG_As_int(obj3));
12150 if (SWIG_arg_fail(4)) SWIG_fail;
12151 }
12152 }
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 {
12161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12162 }
12163 {
12164 if (created2) delete arg2;
12165 }
12166 return resultobj;
12167 fail:
12168 {
12169 if (created2) delete arg2;
12170 }
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_wxImage_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxImage *arg1 = (wxImage *) 0 ;
12178 wxInputStream *arg2 = 0 ;
12179 wxString *arg3 = 0 ;
12180 int arg4 = (int) -1 ;
12181 bool result;
12182 wxPyInputStream *temp2 ;
12183 bool created2 ;
12184 bool temp3 = false ;
12185 PyObject * obj0 = 0 ;
12186 PyObject * obj1 = 0 ;
12187 PyObject * obj2 = 0 ;
12188 PyObject * obj3 = 0 ;
12189 char *kwnames[] = {
12190 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12191 };
12192
12193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxImage_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12195 if (SWIG_arg_fail(1)) SWIG_fail;
12196 {
12197 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12198 arg2 = temp2->m_wxis;
12199 created2 = false;
12200 } else {
12201 PyErr_Clear(); // clear the failure of the wxPyConvert above
12202 arg2 = wxPyCBInputStream_create(obj1, false);
12203 if (arg2 == NULL) {
12204 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12205 SWIG_fail;
12206 }
12207 created2 = true;
12208 }
12209 }
12210 {
12211 arg3 = wxString_in_helper(obj2);
12212 if (arg3 == NULL) SWIG_fail;
12213 temp3 = true;
12214 }
12215 if (obj3) {
12216 {
12217 arg4 = (int)(SWIG_As_int(obj3));
12218 if (SWIG_arg_fail(4)) SWIG_fail;
12219 }
12220 }
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12230 }
12231 {
12232 if (created2) delete arg2;
12233 }
12234 {
12235 if (temp3)
12236 delete arg3;
12237 }
12238 return resultobj;
12239 fail:
12240 {
12241 if (created2) delete arg2;
12242 }
12243 {
12244 if (temp3)
12245 delete arg3;
12246 }
12247 return NULL;
12248 }
12249
12250
12251 static PyObject *_wrap_wxImage_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj;
12253 wxImage *arg1 = (wxImage *) 0 ;
12254 bool result;
12255 PyObject * obj0 = 0 ;
12256 char *kwnames[] = {
12257 (char *) "self", NULL
12258 };
12259
12260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_Ok",kwnames,&obj0)) goto fail;
12261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12262 if (SWIG_arg_fail(1)) SWIG_fail;
12263 {
12264 PyThreadState* __tstate = wxPyBeginAllowThreads();
12265 result = (bool)(arg1)->Ok();
12266
12267 wxPyEndAllowThreads(__tstate);
12268 if (PyErr_Occurred()) SWIG_fail;
12269 }
12270 {
12271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12272 }
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 static PyObject *_wrap_wxImage_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj;
12281 wxImage *arg1 = (wxImage *) 0 ;
12282 int result;
12283 PyObject * obj0 = 0 ;
12284 char *kwnames[] = {
12285 (char *) "self", NULL
12286 };
12287
12288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetWidth",kwnames,&obj0)) goto fail;
12289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12290 if (SWIG_arg_fail(1)) SWIG_fail;
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 result = (int)(arg1)->GetWidth();
12294
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 {
12299 resultobj = SWIG_From_int((int)(result));
12300 }
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 static PyObject *_wrap_wxImage_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12308 PyObject *resultobj;
12309 wxImage *arg1 = (wxImage *) 0 ;
12310 int result;
12311 PyObject * obj0 = 0 ;
12312 char *kwnames[] = {
12313 (char *) "self", NULL
12314 };
12315
12316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetHeight",kwnames,&obj0)) goto fail;
12317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12318 if (SWIG_arg_fail(1)) SWIG_fail;
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (int)(arg1)->GetHeight();
12322
12323 wxPyEndAllowThreads(__tstate);
12324 if (PyErr_Occurred()) SWIG_fail;
12325 }
12326 {
12327 resultobj = SWIG_From_int((int)(result));
12328 }
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 static PyObject *_wrap_wxImage_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj;
12337 wxImage *arg1 = (wxImage *) 0 ;
12338 wxSize result;
12339 PyObject * obj0 = 0 ;
12340 char *kwnames[] = {
12341 (char *) "self", NULL
12342 };
12343
12344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetSize",kwnames,&obj0)) goto fail;
12345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12346 if (SWIG_arg_fail(1)) SWIG_fail;
12347 {
12348 PyThreadState* __tstate = wxPyBeginAllowThreads();
12349 result = wxImage_GetSize(arg1);
12350
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 {
12355 wxSize * resultptr;
12356 resultptr = new wxSize((wxSize &)(result));
12357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12358 }
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 static PyObject *_wrap_wxImage_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj;
12367 wxImage *arg1 = (wxImage *) 0 ;
12368 wxRect *arg2 = 0 ;
12369 SwigValueWrapper<wxImage > result;
12370 wxRect temp2 ;
12371 PyObject * obj0 = 0 ;
12372 PyObject * obj1 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self",(char *) "rect", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 arg2 = &temp2;
12382 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12383 }
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12387
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 {
12392 wxImage * resultptr;
12393 resultptr = new wxImage((wxImage &)(result));
12394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12395 }
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_wxImage_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj;
12404 wxImage *arg1 = (wxImage *) 0 ;
12405 wxSize *arg2 = 0 ;
12406 wxPoint *arg3 = 0 ;
12407 int arg4 = (int) -1 ;
12408 int arg5 = (int) -1 ;
12409 int arg6 = (int) -1 ;
12410 SwigValueWrapper<wxImage > result;
12411 wxSize temp2 ;
12412 wxPoint temp3 ;
12413 PyObject * obj0 = 0 ;
12414 PyObject * obj1 = 0 ;
12415 PyObject * obj2 = 0 ;
12416 PyObject * obj3 = 0 ;
12417 PyObject * obj4 = 0 ;
12418 PyObject * obj5 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:wxImage_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 arg2 = &temp2;
12428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12429 }
12430 {
12431 arg3 = &temp3;
12432 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12433 }
12434 if (obj3) {
12435 {
12436 arg4 = (int)(SWIG_As_int(obj3));
12437 if (SWIG_arg_fail(4)) SWIG_fail;
12438 }
12439 }
12440 if (obj4) {
12441 {
12442 arg5 = (int)(SWIG_As_int(obj4));
12443 if (SWIG_arg_fail(5)) SWIG_fail;
12444 }
12445 }
12446 if (obj5) {
12447 {
12448 arg6 = (int)(SWIG_As_int(obj5));
12449 if (SWIG_arg_fail(6)) SWIG_fail;
12450 }
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 wxImage * resultptr;
12461 resultptr = new wxImage((wxImage &)(result));
12462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_wxImage_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxImage *arg1 = (wxImage *) 0 ;
12473 SwigValueWrapper<wxImage > result;
12474 PyObject * obj0 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_Copy",kwnames,&obj0)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (arg1)->Copy();
12485
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 {
12490 wxImage * resultptr;
12491 resultptr = new wxImage((wxImage &)(result));
12492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12493 }
12494 return resultobj;
12495 fail:
12496 return NULL;
12497 }
12498
12499
12500 static PyObject *_wrap_wxImage_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj;
12502 wxImage *arg1 = (wxImage *) 0 ;
12503 wxImage *arg2 = 0 ;
12504 int arg3 ;
12505 int arg4 ;
12506 PyObject * obj0 = 0 ;
12507 PyObject * obj1 = 0 ;
12508 PyObject * obj2 = 0 ;
12509 PyObject * obj3 = 0 ;
12510 char *kwnames[] = {
12511 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12512 };
12513
12514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImage_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12516 if (SWIG_arg_fail(1)) SWIG_fail;
12517 {
12518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12519 if (SWIG_arg_fail(2)) SWIG_fail;
12520 if (arg2 == NULL) {
12521 SWIG_null_ref("wxImage");
12522 }
12523 if (SWIG_arg_fail(2)) SWIG_fail;
12524 }
12525 {
12526 arg3 = (int)(SWIG_As_int(obj2));
12527 if (SWIG_arg_fail(3)) SWIG_fail;
12528 }
12529 {
12530 arg4 = (int)(SWIG_As_int(obj3));
12531 if (SWIG_arg_fail(4)) SWIG_fail;
12532 }
12533 {
12534 PyThreadState* __tstate = wxPyBeginAllowThreads();
12535 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12536
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 Py_INCREF(Py_None); resultobj = Py_None;
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_wxImage_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12548 PyObject *resultobj;
12549 wxImage *arg1 = (wxImage *) 0 ;
12550 PyObject *result;
12551 PyObject * obj0 = 0 ;
12552 char *kwnames[] = {
12553 (char *) "self", NULL
12554 };
12555
12556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetData",kwnames,&obj0)) goto fail;
12557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12558 if (SWIG_arg_fail(1)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (PyObject *)wxImage_GetData(arg1);
12562
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 resultobj = result;
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_wxImage_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxImage *arg1 = (wxImage *) 0 ;
12576 buffer arg2 ;
12577 int arg3 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 char *kwnames[] = {
12581 (char *) "self",(char *) "data", NULL
12582 };
12583
12584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_SetData",kwnames,&obj0,&obj1)) goto fail;
12585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12586 if (SWIG_arg_fail(1)) SWIG_fail;
12587 {
12588 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12589 }
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 wxImage_SetData(arg1,arg2,arg3);
12593
12594 wxPyEndAllowThreads(__tstate);
12595 if (PyErr_Occurred()) SWIG_fail;
12596 }
12597 Py_INCREF(Py_None); resultobj = Py_None;
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 static PyObject *_wrap_wxImage_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12605 PyObject *resultobj;
12606 wxImage *arg1 = (wxImage *) 0 ;
12607 PyObject *result;
12608 PyObject * obj0 = 0 ;
12609 char *kwnames[] = {
12610 (char *) "self", NULL
12611 };
12612
12613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetDataBuffer",kwnames,&obj0)) goto fail;
12614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12615 if (SWIG_arg_fail(1)) SWIG_fail;
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12619
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = result;
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 static PyObject *_wrap_wxImage_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj;
12632 wxImage *arg1 = (wxImage *) 0 ;
12633 buffer arg2 ;
12634 int arg3 ;
12635 PyObject * obj0 = 0 ;
12636 PyObject * obj1 = 0 ;
12637 char *kwnames[] = {
12638 (char *) "self",(char *) "data", NULL
12639 };
12640
12641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12643 if (SWIG_arg_fail(1)) SWIG_fail;
12644 {
12645 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12646 }
12647 {
12648 PyThreadState* __tstate = wxPyBeginAllowThreads();
12649 wxImage_SetDataBuffer(arg1,arg2,arg3);
12650
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 Py_INCREF(Py_None); resultobj = Py_None;
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 static PyObject *_wrap_wxImage_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12662 PyObject *resultobj;
12663 wxImage *arg1 = (wxImage *) 0 ;
12664 PyObject *result;
12665 PyObject * obj0 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self", NULL
12668 };
12669
12670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetAlphaData",kwnames,&obj0)) goto fail;
12671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12672 if (SWIG_arg_fail(1)) SWIG_fail;
12673 {
12674 PyThreadState* __tstate = wxPyBeginAllowThreads();
12675 result = (PyObject *)wxImage_GetAlphaData(arg1);
12676
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 resultobj = result;
12681 return resultobj;
12682 fail:
12683 return NULL;
12684 }
12685
12686
12687 static PyObject *_wrap_wxImage_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12688 PyObject *resultobj;
12689 wxImage *arg1 = (wxImage *) 0 ;
12690 buffer arg2 ;
12691 int arg3 ;
12692 PyObject * obj0 = 0 ;
12693 PyObject * obj1 = 0 ;
12694 char *kwnames[] = {
12695 (char *) "self",(char *) "alpha", NULL
12696 };
12697
12698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12700 if (SWIG_arg_fail(1)) SWIG_fail;
12701 {
12702 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12703 }
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 wxImage_SetAlphaData(arg1,arg2,arg3);
12707
12708 wxPyEndAllowThreads(__tstate);
12709 if (PyErr_Occurred()) SWIG_fail;
12710 }
12711 Py_INCREF(Py_None); resultobj = Py_None;
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 static PyObject *_wrap_wxImage_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12719 PyObject *resultobj;
12720 wxImage *arg1 = (wxImage *) 0 ;
12721 PyObject *result;
12722 PyObject * obj0 = 0 ;
12723 char *kwnames[] = {
12724 (char *) "self", NULL
12725 };
12726
12727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(1)) SWIG_fail;
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12733
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 resultobj = result;
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 static PyObject *_wrap_wxImage_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12745 PyObject *resultobj;
12746 wxImage *arg1 = (wxImage *) 0 ;
12747 buffer arg2 ;
12748 int arg3 ;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 char *kwnames[] = {
12752 (char *) "self",(char *) "alpha", NULL
12753 };
12754
12755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12757 if (SWIG_arg_fail(1)) SWIG_fail;
12758 {
12759 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12760 }
12761 {
12762 PyThreadState* __tstate = wxPyBeginAllowThreads();
12763 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12764
12765 wxPyEndAllowThreads(__tstate);
12766 if (PyErr_Occurred()) SWIG_fail;
12767 }
12768 Py_INCREF(Py_None); resultobj = Py_None;
12769 return resultobj;
12770 fail:
12771 return NULL;
12772 }
12773
12774
12775 static PyObject *_wrap_wxImage_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12776 PyObject *resultobj;
12777 wxImage *arg1 = (wxImage *) 0 ;
12778 unsigned char arg2 ;
12779 unsigned char arg3 ;
12780 unsigned char arg4 ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 PyObject * obj2 = 0 ;
12784 PyObject * obj3 = 0 ;
12785 char *kwnames[] = {
12786 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12787 };
12788
12789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImage_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12791 if (SWIG_arg_fail(1)) SWIG_fail;
12792 {
12793 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12794 if (SWIG_arg_fail(2)) SWIG_fail;
12795 }
12796 {
12797 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12798 if (SWIG_arg_fail(3)) SWIG_fail;
12799 }
12800 {
12801 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12802 if (SWIG_arg_fail(4)) SWIG_fail;
12803 }
12804 {
12805 PyThreadState* __tstate = wxPyBeginAllowThreads();
12806 (arg1)->SetMaskColour(arg2,arg3,arg4);
12807
12808 wxPyEndAllowThreads(__tstate);
12809 if (PyErr_Occurred()) SWIG_fail;
12810 }
12811 Py_INCREF(Py_None); resultobj = Py_None;
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 static PyObject *_wrap_wxImage_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12819 PyObject *resultobj;
12820 wxImage *arg1 = (wxImage *) 0 ;
12821 unsigned char *arg2 = (unsigned char *) 0 ;
12822 unsigned char *arg3 = (unsigned char *) 0 ;
12823 unsigned char *arg4 = (unsigned char *) 0 ;
12824 unsigned char temp2 ;
12825 int res2 = 0 ;
12826 unsigned char temp3 ;
12827 int res3 = 0 ;
12828 unsigned char temp4 ;
12829 int res4 = 0 ;
12830 PyObject * obj0 = 0 ;
12831 char *kwnames[] = {
12832 (char *) "self", NULL
12833 };
12834
12835 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12836 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12837 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12844
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 Py_INCREF(Py_None); resultobj = Py_None;
12849 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12850 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12851 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12852 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12853 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12854 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_wxImage_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxImage *arg1 = (wxImage *) 0 ;
12864 unsigned char result;
12865 PyObject * obj0 = 0 ;
12866 char *kwnames[] = {
12867 (char *) "self", NULL
12868 };
12869
12870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetMaskRed",kwnames,&obj0)) goto fail;
12871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12872 if (SWIG_arg_fail(1)) SWIG_fail;
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (unsigned char)(arg1)->GetMaskRed();
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 {
12881 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12882 }
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12890 PyObject *resultobj;
12891 wxImage *arg1 = (wxImage *) 0 ;
12892 unsigned char result;
12893 PyObject * obj0 = 0 ;
12894 char *kwnames[] = {
12895 (char *) "self", NULL
12896 };
12897
12898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetMaskGreen",kwnames,&obj0)) goto fail;
12899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12900 if (SWIG_arg_fail(1)) SWIG_fail;
12901 {
12902 PyThreadState* __tstate = wxPyBeginAllowThreads();
12903 result = (unsigned char)(arg1)->GetMaskGreen();
12904
12905 wxPyEndAllowThreads(__tstate);
12906 if (PyErr_Occurred()) SWIG_fail;
12907 }
12908 {
12909 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12910 }
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxImage *arg1 = (wxImage *) 0 ;
12920 unsigned char result;
12921 PyObject * obj0 = 0 ;
12922 char *kwnames[] = {
12923 (char *) "self", NULL
12924 };
12925
12926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_GetMaskBlue",kwnames,&obj0)) goto fail;
12927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12928 if (SWIG_arg_fail(1)) SWIG_fail;
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 result = (unsigned char)(arg1)->GetMaskBlue();
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 {
12937 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12938 }
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 static PyObject *_wrap_wxImage_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj;
12947 wxImage *arg1 = (wxImage *) 0 ;
12948 bool arg2 = (bool) true ;
12949 PyObject * obj0 = 0 ;
12950 PyObject * obj1 = 0 ;
12951 char *kwnames[] = {
12952 (char *) "self",(char *) "mask", NULL
12953 };
12954
12955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_SetMask",kwnames,&obj0,&obj1)) goto fail;
12956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12957 if (SWIG_arg_fail(1)) SWIG_fail;
12958 if (obj1) {
12959 {
12960 arg2 = (bool)(SWIG_As_bool(obj1));
12961 if (SWIG_arg_fail(2)) SWIG_fail;
12962 }
12963 }
12964 {
12965 PyThreadState* __tstate = wxPyBeginAllowThreads();
12966 (arg1)->SetMask(arg2);
12967
12968 wxPyEndAllowThreads(__tstate);
12969 if (PyErr_Occurred()) SWIG_fail;
12970 }
12971 Py_INCREF(Py_None); resultobj = Py_None;
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 static PyObject *_wrap_wxImage_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj;
12980 wxImage *arg1 = (wxImage *) 0 ;
12981 bool result;
12982 PyObject * obj0 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_HasMask",kwnames,&obj0)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (bool)(arg1)->HasMask();
12993
12994 wxPyEndAllowThreads(__tstate);
12995 if (PyErr_Occurred()) SWIG_fail;
12996 }
12997 {
12998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_wxImage_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxImage *arg1 = (wxImage *) 0 ;
13009 double arg2 ;
13010 wxPoint *arg3 = 0 ;
13011 bool arg4 = (bool) true ;
13012 wxPoint *arg5 = (wxPoint *) NULL ;
13013 SwigValueWrapper<wxImage > result;
13014 wxPoint temp3 ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 PyObject * obj2 = 0 ;
13018 PyObject * obj3 = 0 ;
13019 PyObject * obj4 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:wxImage_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 arg2 = (double)(SWIG_As_double(obj1));
13029 if (SWIG_arg_fail(2)) SWIG_fail;
13030 }
13031 {
13032 arg3 = &temp3;
13033 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13034 }
13035 if (obj3) {
13036 {
13037 arg4 = (bool)(SWIG_As_bool(obj3));
13038 if (SWIG_arg_fail(4)) SWIG_fail;
13039 }
13040 }
13041 if (obj4) {
13042 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(5)) SWIG_fail;
13044 }
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13048
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 {
13053 wxImage * resultptr;
13054 resultptr = new wxImage((wxImage &)(result));
13055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13056 }
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 static PyObject *_wrap_wxImage_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj;
13065 wxImage *arg1 = (wxImage *) 0 ;
13066 bool arg2 = (bool) true ;
13067 SwigValueWrapper<wxImage > result;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 char *kwnames[] = {
13071 (char *) "self",(char *) "clockwise", NULL
13072 };
13073
13074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13076 if (SWIG_arg_fail(1)) SWIG_fail;
13077 if (obj1) {
13078 {
13079 arg2 = (bool)(SWIG_As_bool(obj1));
13080 if (SWIG_arg_fail(2)) SWIG_fail;
13081 }
13082 }
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = (arg1)->Rotate90(arg2);
13086
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 {
13091 wxImage * resultptr;
13092 resultptr = new wxImage((wxImage &)(result));
13093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13094 }
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_wxImage_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxImage *arg1 = (wxImage *) 0 ;
13104 bool arg2 = (bool) true ;
13105 SwigValueWrapper<wxImage > result;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 char *kwnames[] = {
13109 (char *) "self",(char *) "horizontally", NULL
13110 };
13111
13112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_Mirror",kwnames,&obj0,&obj1)) goto fail;
13113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13114 if (SWIG_arg_fail(1)) SWIG_fail;
13115 if (obj1) {
13116 {
13117 arg2 = (bool)(SWIG_As_bool(obj1));
13118 if (SWIG_arg_fail(2)) SWIG_fail;
13119 }
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (arg1)->Mirror(arg2);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 wxImage * resultptr;
13130 resultptr = new wxImage((wxImage &)(result));
13131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_wxImage_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxImage *arg1 = (wxImage *) 0 ;
13142 unsigned char arg2 ;
13143 unsigned char arg3 ;
13144 unsigned char arg4 ;
13145 unsigned char arg5 ;
13146 unsigned char arg6 ;
13147 unsigned char arg7 ;
13148 PyObject * obj0 = 0 ;
13149 PyObject * obj1 = 0 ;
13150 PyObject * obj2 = 0 ;
13151 PyObject * obj3 = 0 ;
13152 PyObject * obj4 = 0 ;
13153 PyObject * obj5 = 0 ;
13154 PyObject * obj6 = 0 ;
13155 char *kwnames[] = {
13156 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13157 };
13158
13159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:wxImage_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13161 if (SWIG_arg_fail(1)) SWIG_fail;
13162 {
13163 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13164 if (SWIG_arg_fail(2)) SWIG_fail;
13165 }
13166 {
13167 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13168 if (SWIG_arg_fail(3)) SWIG_fail;
13169 }
13170 {
13171 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13172 if (SWIG_arg_fail(4)) SWIG_fail;
13173 }
13174 {
13175 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13176 if (SWIG_arg_fail(5)) SWIG_fail;
13177 }
13178 {
13179 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13180 if (SWIG_arg_fail(6)) SWIG_fail;
13181 }
13182 {
13183 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13184 if (SWIG_arg_fail(7)) SWIG_fail;
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13189
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 Py_INCREF(Py_None); resultobj = Py_None;
13194 return resultobj;
13195 fail:
13196 return NULL;
13197 }
13198
13199
13200 static PyObject *_wrap_wxImage_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13201 PyObject *resultobj;
13202 wxImage *arg1 = (wxImage *) 0 ;
13203 unsigned char arg2 ;
13204 unsigned char arg3 ;
13205 unsigned char arg4 ;
13206 SwigValueWrapper<wxImage > result;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 PyObject * obj2 = 0 ;
13210 PyObject * obj3 = 0 ;
13211 char *kwnames[] = {
13212 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13213 };
13214
13215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImage_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13217 if (SWIG_arg_fail(1)) SWIG_fail;
13218 {
13219 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13220 if (SWIG_arg_fail(2)) SWIG_fail;
13221 }
13222 {
13223 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13224 if (SWIG_arg_fail(3)) SWIG_fail;
13225 }
13226 {
13227 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13228 if (SWIG_arg_fail(4)) SWIG_fail;
13229 }
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13233
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238 wxImage * resultptr;
13239 resultptr = new wxImage((wxImage &)(result));
13240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13241 }
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_wxImage_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxImage *arg1 = (wxImage *) 0 ;
13251 wxString *arg2 = 0 ;
13252 wxString *arg3 = 0 ;
13253 bool temp2 = false ;
13254 bool temp3 = false ;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 PyObject * obj2 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self",(char *) "name",(char *) "value", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 {
13266 arg2 = wxString_in_helper(obj1);
13267 if (arg2 == NULL) SWIG_fail;
13268 temp2 = true;
13269 }
13270 {
13271 arg3 = wxString_in_helper(obj2);
13272 if (arg3 == NULL) SWIG_fail;
13273 temp3 = true;
13274 }
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13278
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 Py_INCREF(Py_None); resultobj = Py_None;
13283 {
13284 if (temp2)
13285 delete arg2;
13286 }
13287 {
13288 if (temp3)
13289 delete arg3;
13290 }
13291 return resultobj;
13292 fail:
13293 {
13294 if (temp2)
13295 delete arg2;
13296 }
13297 {
13298 if (temp3)
13299 delete arg3;
13300 }
13301 return NULL;
13302 }
13303
13304
13305 static PyObject *_wrap_wxImage_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13306 PyObject *resultobj;
13307 wxImage *arg1 = (wxImage *) 0 ;
13308 wxString *arg2 = 0 ;
13309 int arg3 ;
13310 bool temp2 = false ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self",(char *) "name",(char *) "value", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxImage_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 {
13322 arg2 = wxString_in_helper(obj1);
13323 if (arg2 == NULL) SWIG_fail;
13324 temp2 = true;
13325 }
13326 {
13327 arg3 = (int)(SWIG_As_int(obj2));
13328 if (SWIG_arg_fail(3)) SWIG_fail;
13329 }
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 (arg1)->SetOption((wxString const &)*arg2,arg3);
13333
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 Py_INCREF(Py_None); resultobj = Py_None;
13338 {
13339 if (temp2)
13340 delete arg2;
13341 }
13342 return resultobj;
13343 fail:
13344 {
13345 if (temp2)
13346 delete arg2;
13347 }
13348 return NULL;
13349 }
13350
13351
13352 static PyObject *_wrap_wxImage_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13353 PyObject *resultobj;
13354 wxImage *arg1 = (wxImage *) 0 ;
13355 wxString *arg2 = 0 ;
13356 wxString result;
13357 bool temp2 = false ;
13358 PyObject * obj0 = 0 ;
13359 PyObject * obj1 = 0 ;
13360 char *kwnames[] = {
13361 (char *) "self",(char *) "name", NULL
13362 };
13363
13364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_GetOption",kwnames,&obj0,&obj1)) goto fail;
13365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13366 if (SWIG_arg_fail(1)) SWIG_fail;
13367 {
13368 arg2 = wxString_in_helper(obj1);
13369 if (arg2 == NULL) SWIG_fail;
13370 temp2 = true;
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13375
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 {
13380 #if wxUSE_UNICODE
13381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13382 #else
13383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13384 #endif
13385 }
13386 {
13387 if (temp2)
13388 delete arg2;
13389 }
13390 return resultobj;
13391 fail:
13392 {
13393 if (temp2)
13394 delete arg2;
13395 }
13396 return NULL;
13397 }
13398
13399
13400 static PyObject *_wrap_wxImage_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj;
13402 wxImage *arg1 = (wxImage *) 0 ;
13403 wxString *arg2 = 0 ;
13404 int result;
13405 bool temp2 = false ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 char *kwnames[] = {
13409 (char *) "self",(char *) "name", NULL
13410 };
13411
13412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13414 if (SWIG_arg_fail(1)) SWIG_fail;
13415 {
13416 arg2 = wxString_in_helper(obj1);
13417 if (arg2 == NULL) SWIG_fail;
13418 temp2 = true;
13419 }
13420 {
13421 PyThreadState* __tstate = wxPyBeginAllowThreads();
13422 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13423
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 {
13428 resultobj = SWIG_From_int((int)(result));
13429 }
13430 {
13431 if (temp2)
13432 delete arg2;
13433 }
13434 return resultobj;
13435 fail:
13436 {
13437 if (temp2)
13438 delete arg2;
13439 }
13440 return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_wxImage_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj;
13446 wxImage *arg1 = (wxImage *) 0 ;
13447 wxString *arg2 = 0 ;
13448 bool result;
13449 bool temp2 = false ;
13450 PyObject * obj0 = 0 ;
13451 PyObject * obj1 = 0 ;
13452 char *kwnames[] = {
13453 (char *) "self",(char *) "name", NULL
13454 };
13455
13456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_HasOption",kwnames,&obj0,&obj1)) goto fail;
13457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13458 if (SWIG_arg_fail(1)) SWIG_fail;
13459 {
13460 arg2 = wxString_in_helper(obj1);
13461 if (arg2 == NULL) SWIG_fail;
13462 temp2 = true;
13463 }
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13467
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 {
13472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13473 }
13474 {
13475 if (temp2)
13476 delete arg2;
13477 }
13478 return resultobj;
13479 fail:
13480 {
13481 if (temp2)
13482 delete arg2;
13483 }
13484 return NULL;
13485 }
13486
13487
13488 static PyObject *_wrap_wxImage_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13489 PyObject *resultobj;
13490 wxImage *arg1 = (wxImage *) 0 ;
13491 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13492 unsigned long result;
13493 PyObject * obj0 = 0 ;
13494 PyObject * obj1 = 0 ;
13495 char *kwnames[] = {
13496 (char *) "self",(char *) "stopafter", NULL
13497 };
13498
13499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_CountColours",kwnames,&obj0,&obj1)) goto fail;
13500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13501 if (SWIG_arg_fail(1)) SWIG_fail;
13502 if (obj1) {
13503 {
13504 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13505 if (SWIG_arg_fail(2)) SWIG_fail;
13506 }
13507 }
13508 {
13509 PyThreadState* __tstate = wxPyBeginAllowThreads();
13510 result = (unsigned long)(arg1)->CountColours(arg2);
13511
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 {
13516 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13517 }
13518 return resultobj;
13519 fail:
13520 return NULL;
13521 }
13522
13523
13524 static PyObject *_wrap_wxImage_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13525 PyObject *resultobj;
13526 wxImage *arg1 = (wxImage *) 0 ;
13527 wxImageHistogram *arg2 = 0 ;
13528 unsigned long result;
13529 PyObject * obj0 = 0 ;
13530 PyObject * obj1 = 0 ;
13531 char *kwnames[] = {
13532 (char *) "self",(char *) "h", NULL
13533 };
13534
13535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxImage_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13537 if (SWIG_arg_fail(1)) SWIG_fail;
13538 {
13539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13540 if (SWIG_arg_fail(2)) SWIG_fail;
13541 if (arg2 == NULL) {
13542 SWIG_null_ref("wxImageHistogram");
13543 }
13544 if (SWIG_arg_fail(2)) SWIG_fail;
13545 }
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13555 }
13556 return resultobj;
13557 fail:
13558 return NULL;
13559 }
13560
13561
13562 static PyObject *_wrap_wxImage_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj;
13564 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13565 PyObject * obj0 = 0 ;
13566 char *kwnames[] = {
13567 (char *) "handler", NULL
13568 };
13569
13570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_AddHandler",kwnames,&obj0)) goto fail;
13571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13572 if (SWIG_arg_fail(1)) SWIG_fail;
13573 {
13574 PyThreadState* __tstate = wxPyBeginAllowThreads();
13575 wxImage::AddHandler(arg1);
13576
13577 wxPyEndAllowThreads(__tstate);
13578 if (PyErr_Occurred()) SWIG_fail;
13579 }
13580 Py_INCREF(Py_None); resultobj = Py_None;
13581 return resultobj;
13582 fail:
13583 return NULL;
13584 }
13585
13586
13587 static PyObject *_wrap_wxImage_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13588 PyObject *resultobj;
13589 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13590 PyObject * obj0 = 0 ;
13591 char *kwnames[] = {
13592 (char *) "handler", NULL
13593 };
13594
13595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_InsertHandler",kwnames,&obj0)) goto fail;
13596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13597 if (SWIG_arg_fail(1)) SWIG_fail;
13598 {
13599 PyThreadState* __tstate = wxPyBeginAllowThreads();
13600 wxImage::InsertHandler(arg1);
13601
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 Py_INCREF(Py_None); resultobj = Py_None;
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 static PyObject *_wrap_wxImage_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj;
13614 wxString *arg1 = 0 ;
13615 bool result;
13616 bool temp1 = false ;
13617 PyObject * obj0 = 0 ;
13618 char *kwnames[] = {
13619 (char *) "name", NULL
13620 };
13621
13622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxImage_RemoveHandler",kwnames,&obj0)) goto fail;
13623 {
13624 arg1 = wxString_in_helper(obj0);
13625 if (arg1 == NULL) SWIG_fail;
13626 temp1 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 {
13636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13637 }
13638 {
13639 if (temp1)
13640 delete arg1;
13641 }
13642 return resultobj;
13643 fail:
13644 {
13645 if (temp1)
13646 delete arg1;
13647 }
13648 return NULL;
13649 }
13650
13651
13652 static PyObject *_wrap_wxImage_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj;
13654 wxString result;
13655 char *kwnames[] = {
13656 NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxImage_GetImageExtWildcard",kwnames)) goto fail;
13660 {
13661 PyThreadState* __tstate = wxPyBeginAllowThreads();
13662 result = wxImage::GetImageExtWildcard();
13663
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 {
13668 #if wxUSE_UNICODE
13669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13670 #else
13671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13672 #endif
13673 }
13674 return resultobj;
13675 fail:
13676 return NULL;
13677 }
13678
13679
13680 static PyObject *_wrap_wxImage_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13681 PyObject *resultobj;
13682 wxImage *arg1 = (wxImage *) 0 ;
13683 int arg2 = (int) -1 ;
13684 wxBitmap result;
13685 PyObject * obj0 = 0 ;
13686 PyObject * obj1 = 0 ;
13687 char *kwnames[] = {
13688 (char *) "self",(char *) "depth", NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxImage_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13693 if (SWIG_arg_fail(1)) SWIG_fail;
13694 if (obj1) {
13695 {
13696 arg2 = (int)(SWIG_As_int(obj1));
13697 if (SWIG_arg_fail(2)) SWIG_fail;
13698 }
13699 }
13700 {
13701 if (!wxPyCheckForApp()) SWIG_fail;
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 result = wxImage_ConvertToBitmap(arg1,arg2);
13704
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 {
13709 wxBitmap * resultptr;
13710 resultptr = new wxBitmap((wxBitmap &)(result));
13711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13712 }
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 static PyObject *_wrap_wxImage_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj;
13721 wxImage *arg1 = (wxImage *) 0 ;
13722 unsigned char arg2 ;
13723 unsigned char arg3 ;
13724 unsigned char arg4 ;
13725 wxBitmap result;
13726 PyObject * obj0 = 0 ;
13727 PyObject * obj1 = 0 ;
13728 PyObject * obj2 = 0 ;
13729 PyObject * obj3 = 0 ;
13730 char *kwnames[] = {
13731 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13732 };
13733
13734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxImage_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13736 if (SWIG_arg_fail(1)) SWIG_fail;
13737 {
13738 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13739 if (SWIG_arg_fail(2)) SWIG_fail;
13740 }
13741 {
13742 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13743 if (SWIG_arg_fail(3)) SWIG_fail;
13744 }
13745 {
13746 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13747 if (SWIG_arg_fail(4)) SWIG_fail;
13748 }
13749 {
13750 if (!wxPyCheckForApp()) SWIG_fail;
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 {
13758 wxBitmap * resultptr;
13759 resultptr = new wxBitmap((wxBitmap &)(result));
13760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13761 }
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject * wxImage_swigregister(PyObject *, PyObject *args) {
13769 PyObject *obj;
13770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13771 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13772 Py_INCREF(obj);
13773 return Py_BuildValue((char *)"");
13774 }
13775 static int _wrap_wxNullImage_set(PyObject *) {
13776 PyErr_SetString(PyExc_TypeError,"Variable wxNullImage is read-only.");
13777 return 1;
13778 }
13779
13780
13781 static PyObject *_wrap_wxNullImage_get(void) {
13782 PyObject *pyobj;
13783
13784 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13785 return pyobj;
13786 }
13787
13788
13789 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13790 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13791 return 1;
13792 }
13793
13794
13795 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13796 PyObject *pyobj;
13797
13798 {
13799 #if wxUSE_UNICODE
13800 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13801 #else
13802 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13803 #endif
13804 }
13805 return pyobj;
13806 }
13807
13808
13809 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13810 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13811 return 1;
13812 }
13813
13814
13815 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13816 PyObject *pyobj;
13817
13818 {
13819 #if wxUSE_UNICODE
13820 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13821 #else
13822 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13823 #endif
13824 }
13825 return pyobj;
13826 }
13827
13828
13829 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13830 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13831 return 1;
13832 }
13833
13834
13835 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13836 PyObject *pyobj;
13837
13838 {
13839 #if wxUSE_UNICODE
13840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13841 #else
13842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13843 #endif
13844 }
13845 return pyobj;
13846 }
13847
13848
13849 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13850 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13851 return 1;
13852 }
13853
13854
13855 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13856 PyObject *pyobj;
13857
13858 {
13859 #if wxUSE_UNICODE
13860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13861 #else
13862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13863 #endif
13864 }
13865 return pyobj;
13866 }
13867
13868
13869 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13870 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13871 return 1;
13872 }
13873
13874
13875 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13876 PyObject *pyobj;
13877
13878 {
13879 #if wxUSE_UNICODE
13880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13881 #else
13882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13883 #endif
13884 }
13885 return pyobj;
13886 }
13887
13888
13889 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13890 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13891 return 1;
13892 }
13893
13894
13895 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13896 PyObject *pyobj;
13897
13898 {
13899 #if wxUSE_UNICODE
13900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13901 #else
13902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13903 #endif
13904 }
13905 return pyobj;
13906 }
13907
13908
13909 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13910 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13911 return 1;
13912 }
13913
13914
13915 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13916 PyObject *pyobj;
13917
13918 {
13919 #if wxUSE_UNICODE
13920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13921 #else
13922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13923 #endif
13924 }
13925 return pyobj;
13926 }
13927
13928
13929 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13930 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13931 return 1;
13932 }
13933
13934
13935 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13936 PyObject *pyobj;
13937
13938 {
13939 #if wxUSE_UNICODE
13940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13941 #else
13942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13943 #endif
13944 }
13945 return pyobj;
13946 }
13947
13948
13949 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13950 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13951 return 1;
13952 }
13953
13954
13955 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13956 PyObject *pyobj;
13957
13958 {
13959 #if wxUSE_UNICODE
13960 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13961 #else
13962 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13963 #endif
13964 }
13965 return pyobj;
13966 }
13967
13968
13969 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13970 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13971 return 1;
13972 }
13973
13974
13975 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13976 PyObject *pyobj;
13977
13978 {
13979 #if wxUSE_UNICODE
13980 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13981 #else
13982 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13983 #endif
13984 }
13985 return pyobj;
13986 }
13987
13988
13989 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13990 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13991 return 1;
13992 }
13993
13994
13995 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13996 PyObject *pyobj;
13997
13998 {
13999 #if wxUSE_UNICODE
14000 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14001 #else
14002 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14003 #endif
14004 }
14005 return pyobj;
14006 }
14007
14008
14009 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14010 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14011 return 1;
14012 }
14013
14014
14015 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14016 PyObject *pyobj;
14017
14018 {
14019 #if wxUSE_UNICODE
14020 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14021 #else
14022 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14023 #endif
14024 }
14025 return pyobj;
14026 }
14027
14028
14029 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14030 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14031 return 1;
14032 }
14033
14034
14035 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14036 PyObject *pyobj;
14037
14038 {
14039 #if wxUSE_UNICODE
14040 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14041 #else
14042 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14043 #endif
14044 }
14045 return pyobj;
14046 }
14047
14048
14049 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14050 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14051 return 1;
14052 }
14053
14054
14055 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14056 PyObject *pyobj;
14057
14058 {
14059 #if wxUSE_UNICODE
14060 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14061 #else
14062 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14063 #endif
14064 }
14065 return pyobj;
14066 }
14067
14068
14069 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14070 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14071 return 1;
14072 }
14073
14074
14075 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14076 PyObject *pyobj;
14077
14078 {
14079 #if wxUSE_UNICODE
14080 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14081 #else
14082 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14083 #endif
14084 }
14085 return pyobj;
14086 }
14087
14088
14089 static PyObject *_wrap_new_wxBMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj;
14091 wxBMPHandler *result;
14092 char *kwnames[] = {
14093 NULL
14094 };
14095
14096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxBMPHandler",kwnames)) goto fail;
14097 {
14098 PyThreadState* __tstate = wxPyBeginAllowThreads();
14099 result = (wxBMPHandler *)new wxBMPHandler();
14100
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14105 return resultobj;
14106 fail:
14107 return NULL;
14108 }
14109
14110
14111 static PyObject * wxBMPHandler_swigregister(PyObject *, PyObject *args) {
14112 PyObject *obj;
14113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14114 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14115 Py_INCREF(obj);
14116 return Py_BuildValue((char *)"");
14117 }
14118 static PyObject *_wrap_new_wxICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj;
14120 wxICOHandler *result;
14121 char *kwnames[] = {
14122 NULL
14123 };
14124
14125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxICOHandler",kwnames)) goto fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (wxICOHandler *)new wxICOHandler();
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject * wxICOHandler_swigregister(PyObject *, PyObject *args) {
14141 PyObject *obj;
14142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14143 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14144 Py_INCREF(obj);
14145 return Py_BuildValue((char *)"");
14146 }
14147 static PyObject *_wrap_new_wxCURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj;
14149 wxCURHandler *result;
14150 char *kwnames[] = {
14151 NULL
14152 };
14153
14154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxCURHandler",kwnames)) goto fail;
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 result = (wxCURHandler *)new wxCURHandler();
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 static PyObject * wxCURHandler_swigregister(PyObject *, PyObject *args) {
14170 PyObject *obj;
14171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14172 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14173 Py_INCREF(obj);
14174 return Py_BuildValue((char *)"");
14175 }
14176 static PyObject *_wrap_new_wxANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxANIHandler *result;
14179 char *kwnames[] = {
14180 NULL
14181 };
14182
14183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxANIHandler",kwnames)) goto fail;
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (wxANIHandler *)new wxANIHandler();
14187
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 static PyObject * wxANIHandler_swigregister(PyObject *, PyObject *args) {
14199 PyObject *obj;
14200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14201 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14202 Py_INCREF(obj);
14203 return Py_BuildValue((char *)"");
14204 }
14205 static PyObject *_wrap_new_wxPNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj;
14207 wxPNGHandler *result;
14208 char *kwnames[] = {
14209 NULL
14210 };
14211
14212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxPNGHandler",kwnames)) goto fail;
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (wxPNGHandler *)new wxPNGHandler();
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject * wxPNGHandler_swigregister(PyObject *, PyObject *args) {
14228 PyObject *obj;
14229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14230 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14231 Py_INCREF(obj);
14232 return Py_BuildValue((char *)"");
14233 }
14234 static PyObject *_wrap_new_wxGIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj;
14236 wxGIFHandler *result;
14237 char *kwnames[] = {
14238 NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxGIFHandler",kwnames)) goto fail;
14242 {
14243 PyThreadState* __tstate = wxPyBeginAllowThreads();
14244 result = (wxGIFHandler *)new wxGIFHandler();
14245
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14250 return resultobj;
14251 fail:
14252 return NULL;
14253 }
14254
14255
14256 static PyObject * wxGIFHandler_swigregister(PyObject *, PyObject *args) {
14257 PyObject *obj;
14258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14259 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14260 Py_INCREF(obj);
14261 return Py_BuildValue((char *)"");
14262 }
14263 static PyObject *_wrap_new_wxPCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj;
14265 wxPCXHandler *result;
14266 char *kwnames[] = {
14267 NULL
14268 };
14269
14270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxPCXHandler",kwnames)) goto fail;
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (wxPCXHandler *)new wxPCXHandler();
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject * wxPCXHandler_swigregister(PyObject *, PyObject *args) {
14286 PyObject *obj;
14287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14288 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14289 Py_INCREF(obj);
14290 return Py_BuildValue((char *)"");
14291 }
14292 static PyObject *_wrap_new_wxJPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj;
14294 wxJPEGHandler *result;
14295 char *kwnames[] = {
14296 NULL
14297 };
14298
14299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxJPEGHandler",kwnames)) goto fail;
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 result = (wxJPEGHandler *)new wxJPEGHandler();
14303
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 static PyObject * wxJPEGHandler_swigregister(PyObject *, PyObject *args) {
14315 PyObject *obj;
14316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14317 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14318 Py_INCREF(obj);
14319 return Py_BuildValue((char *)"");
14320 }
14321 static PyObject *_wrap_new_wxPNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxPNMHandler *result;
14324 char *kwnames[] = {
14325 NULL
14326 };
14327
14328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxPNMHandler",kwnames)) goto fail;
14329 {
14330 PyThreadState* __tstate = wxPyBeginAllowThreads();
14331 result = (wxPNMHandler *)new wxPNMHandler();
14332
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14337 return resultobj;
14338 fail:
14339 return NULL;
14340 }
14341
14342
14343 static PyObject * wxPNMHandler_swigregister(PyObject *, PyObject *args) {
14344 PyObject *obj;
14345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14346 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14347 Py_INCREF(obj);
14348 return Py_BuildValue((char *)"");
14349 }
14350 static PyObject *_wrap_new_wxXPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxXPMHandler *result;
14353 char *kwnames[] = {
14354 NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxXPMHandler",kwnames)) goto fail;
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (wxXPMHandler *)new wxXPMHandler();
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject * wxXPMHandler_swigregister(PyObject *, PyObject *args) {
14373 PyObject *obj;
14374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14375 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14376 Py_INCREF(obj);
14377 return Py_BuildValue((char *)"");
14378 }
14379 static PyObject *_wrap_new_wxTIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj;
14381 wxTIFFHandler *result;
14382 char *kwnames[] = {
14383 NULL
14384 };
14385
14386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxTIFFHandler",kwnames)) goto fail;
14387 {
14388 PyThreadState* __tstate = wxPyBeginAllowThreads();
14389 result = (wxTIFFHandler *)new wxTIFFHandler();
14390
14391 wxPyEndAllowThreads(__tstate);
14392 if (PyErr_Occurred()) SWIG_fail;
14393 }
14394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14395 return resultobj;
14396 fail:
14397 return NULL;
14398 }
14399
14400
14401 static PyObject * wxTIFFHandler_swigregister(PyObject *, PyObject *args) {
14402 PyObject *obj;
14403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14404 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14405 Py_INCREF(obj);
14406 return Py_BuildValue((char *)"");
14407 }
14408 static PyObject *_wrap_wxQuantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj;
14410 wxImage *arg1 = 0 ;
14411 wxImage *arg2 = 0 ;
14412 int arg3 = (int) 236 ;
14413 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14414 bool result;
14415 PyObject * obj0 = 0 ;
14416 PyObject * obj1 = 0 ;
14417 PyObject * obj2 = 0 ;
14418 PyObject * obj3 = 0 ;
14419 char *kwnames[] = {
14420 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxQuantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14424 {
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 if (arg1 == NULL) {
14428 SWIG_null_ref("wxImage");
14429 }
14430 if (SWIG_arg_fail(1)) SWIG_fail;
14431 }
14432 {
14433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14434 if (SWIG_arg_fail(2)) SWIG_fail;
14435 if (arg2 == NULL) {
14436 SWIG_null_ref("wxImage");
14437 }
14438 if (SWIG_arg_fail(2)) SWIG_fail;
14439 }
14440 if (obj2) {
14441 {
14442 arg3 = (int)(SWIG_As_int(obj2));
14443 if (SWIG_arg_fail(3)) SWIG_fail;
14444 }
14445 }
14446 if (obj3) {
14447 {
14448 arg4 = (int)(SWIG_As_int(obj3));
14449 if (SWIG_arg_fail(4)) SWIG_fail;
14450 }
14451 }
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14455
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 {
14460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14461 }
14462 return resultobj;
14463 fail:
14464 return NULL;
14465 }
14466
14467
14468 static PyObject * wxQuantize_swigregister(PyObject *, PyObject *args) {
14469 PyObject *obj;
14470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14471 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14472 Py_INCREF(obj);
14473 return Py_BuildValue((char *)"");
14474 }
14475 static PyObject *_wrap_new_wxEvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj;
14477 wxEvtHandler *result;
14478 char *kwnames[] = {
14479 NULL
14480 };
14481
14482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxEvtHandler",kwnames)) goto fail;
14483 {
14484 PyThreadState* __tstate = wxPyBeginAllowThreads();
14485 result = (wxEvtHandler *)new wxEvtHandler();
14486
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 static PyObject *_wrap_wxEvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj;
14499 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14500 wxEvtHandler *result;
14501 PyObject * obj0 = 0 ;
14502 char *kwnames[] = {
14503 (char *) "self", NULL
14504 };
14505
14506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14508 if (SWIG_arg_fail(1)) SWIG_fail;
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14512
14513 wxPyEndAllowThreads(__tstate);
14514 if (PyErr_Occurred()) SWIG_fail;
14515 }
14516 {
14517 resultobj = wxPyMake_wxObject(result, 0);
14518 }
14519 return resultobj;
14520 fail:
14521 return NULL;
14522 }
14523
14524
14525 static PyObject *_wrap_wxEvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14526 PyObject *resultobj;
14527 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14528 wxEvtHandler *result;
14529 PyObject * obj0 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 {
14545 resultobj = wxPyMake_wxObject(result, 0);
14546 }
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_wxEvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14556 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14557 PyObject * obj0 = 0 ;
14558 PyObject * obj1 = 0 ;
14559 char *kwnames[] = {
14560 (char *) "self",(char *) "handler", NULL
14561 };
14562
14563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14565 if (SWIG_arg_fail(1)) SWIG_fail;
14566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14567 if (SWIG_arg_fail(2)) SWIG_fail;
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 (arg1)->SetNextHandler(arg2);
14571
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 Py_INCREF(Py_None); resultobj = Py_None;
14576 return resultobj;
14577 fail:
14578 return NULL;
14579 }
14580
14581
14582 static PyObject *_wrap_wxEvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj;
14584 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14586 PyObject * obj0 = 0 ;
14587 PyObject * obj1 = 0 ;
14588 char *kwnames[] = {
14589 (char *) "self",(char *) "handler", NULL
14590 };
14591
14592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14594 if (SWIG_arg_fail(1)) SWIG_fail;
14595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14596 if (SWIG_arg_fail(2)) SWIG_fail;
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 (arg1)->SetPreviousHandler(arg2);
14600
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 Py_INCREF(Py_None); resultobj = Py_None;
14605 return resultobj;
14606 fail:
14607 return NULL;
14608 }
14609
14610
14611 static PyObject *_wrap_wxEvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14612 PyObject *resultobj;
14613 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14614 bool result;
14615 PyObject * obj0 = 0 ;
14616 char *kwnames[] = {
14617 (char *) "self", NULL
14618 };
14619
14620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14622 if (SWIG_arg_fail(1)) SWIG_fail;
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 result = (bool)(arg1)->GetEvtHandlerEnabled();
14626
14627 wxPyEndAllowThreads(__tstate);
14628 if (PyErr_Occurred()) SWIG_fail;
14629 }
14630 {
14631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14632 }
14633 return resultobj;
14634 fail:
14635 return NULL;
14636 }
14637
14638
14639 static PyObject *_wrap_wxEvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14640 PyObject *resultobj;
14641 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14642 bool arg2 ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 char *kwnames[] = {
14646 (char *) "self",(char *) "enabled", NULL
14647 };
14648
14649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14651 if (SWIG_arg_fail(1)) SWIG_fail;
14652 {
14653 arg2 = (bool)(SWIG_As_bool(obj1));
14654 if (SWIG_arg_fail(2)) SWIG_fail;
14655 }
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 (arg1)->SetEvtHandlerEnabled(arg2);
14659
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 Py_INCREF(Py_None); resultobj = Py_None;
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 static PyObject *_wrap_wxEvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj;
14672 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14673 wxEvent *arg2 = 0 ;
14674 bool result;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14677 char *kwnames[] = {
14678 (char *) "self",(char *) "event", NULL
14679 };
14680
14681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(1)) SWIG_fail;
14684 {
14685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14686 if (SWIG_arg_fail(2)) SWIG_fail;
14687 if (arg2 == NULL) {
14688 SWIG_null_ref("wxEvent");
14689 }
14690 if (SWIG_arg_fail(2)) SWIG_fail;
14691 }
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (bool)(arg1)->ProcessEvent(*arg2);
14695
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 {
14700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14701 }
14702 return resultobj;
14703 fail:
14704 return NULL;
14705 }
14706
14707
14708 static PyObject *_wrap_wxEvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14709 PyObject *resultobj;
14710 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14711 wxEvent *arg2 = 0 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 char *kwnames[] = {
14715 (char *) "self",(char *) "event", NULL
14716 };
14717
14718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14720 if (SWIG_arg_fail(1)) SWIG_fail;
14721 {
14722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14723 if (SWIG_arg_fail(2)) SWIG_fail;
14724 if (arg2 == NULL) {
14725 SWIG_null_ref("wxEvent");
14726 }
14727 if (SWIG_arg_fail(2)) SWIG_fail;
14728 }
14729 {
14730 PyThreadState* __tstate = wxPyBeginAllowThreads();
14731 (arg1)->AddPendingEvent(*arg2);
14732
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 Py_INCREF(Py_None); resultobj = Py_None;
14737 return resultobj;
14738 fail:
14739 return NULL;
14740 }
14741
14742
14743 static PyObject *_wrap_wxEvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14744 PyObject *resultobj;
14745 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14746 PyObject * obj0 = 0 ;
14747 char *kwnames[] = {
14748 (char *) "self", NULL
14749 };
14750
14751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14753 if (SWIG_arg_fail(1)) SWIG_fail;
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 (arg1)->ProcessPendingEvents();
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 Py_INCREF(Py_None); resultobj = Py_None;
14762 return resultobj;
14763 fail:
14764 return NULL;
14765 }
14766
14767
14768 static PyObject *_wrap_wxEvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14769 PyObject *resultobj;
14770 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14771 int arg2 ;
14772 int arg3 ;
14773 int arg4 ;
14774 PyObject *arg5 = (PyObject *) 0 ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 PyObject * obj2 = 0 ;
14778 PyObject * obj3 = 0 ;
14779 PyObject * obj4 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:wxEvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 {
14788 arg2 = (int)(SWIG_As_int(obj1));
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 }
14791 {
14792 arg3 = (int)(SWIG_As_int(obj2));
14793 if (SWIG_arg_fail(3)) SWIG_fail;
14794 }
14795 {
14796 arg4 = (int)(SWIG_As_int(obj3));
14797 if (SWIG_arg_fail(4)) SWIG_fail;
14798 }
14799 arg5 = obj4;
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14803
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 Py_INCREF(Py_None); resultobj = Py_None;
14808 return resultobj;
14809 fail:
14810 return NULL;
14811 }
14812
14813
14814 static PyObject *_wrap_wxEvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14815 PyObject *resultobj;
14816 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14817 int arg2 ;
14818 int arg3 = (int) -1 ;
14819 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14820 bool result;
14821 PyObject * obj0 = 0 ;
14822 PyObject * obj1 = 0 ;
14823 PyObject * obj2 = 0 ;
14824 PyObject * obj3 = 0 ;
14825 char *kwnames[] = {
14826 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14827 };
14828
14829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxEvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14831 if (SWIG_arg_fail(1)) SWIG_fail;
14832 {
14833 arg2 = (int)(SWIG_As_int(obj1));
14834 if (SWIG_arg_fail(2)) SWIG_fail;
14835 }
14836 if (obj2) {
14837 {
14838 arg3 = (int)(SWIG_As_int(obj2));
14839 if (SWIG_arg_fail(3)) SWIG_fail;
14840 }
14841 }
14842 if (obj3) {
14843 {
14844 arg4 = (wxEventType)(SWIG_As_int(obj3));
14845 if (SWIG_arg_fail(4)) SWIG_fail;
14846 }
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14851
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 {
14856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14857 }
14858 return resultobj;
14859 fail:
14860 return NULL;
14861 }
14862
14863
14864 static PyObject *_wrap_wxEvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14865 PyObject *resultobj;
14866 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14867 PyObject *arg2 = (PyObject *) 0 ;
14868 bool arg3 = (bool) true ;
14869 PyObject * obj0 = 0 ;
14870 PyObject * obj1 = 0 ;
14871 PyObject * obj2 = 0 ;
14872 char *kwnames[] = {
14873 (char *) "self",(char *) "_self",(char *) "incref", NULL
14874 };
14875
14876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxEvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14878 if (SWIG_arg_fail(1)) SWIG_fail;
14879 arg2 = obj1;
14880 if (obj2) {
14881 {
14882 arg3 = (bool)(SWIG_As_bool(obj2));
14883 if (SWIG_arg_fail(3)) SWIG_fail;
14884 }
14885 }
14886 {
14887 PyThreadState* __tstate = wxPyBeginAllowThreads();
14888 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14889
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 Py_INCREF(Py_None); resultobj = Py_None;
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 static PyObject * wxEvtHandler_swigregister(PyObject *, PyObject *args) {
14901 PyObject *obj;
14902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14903 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14904 Py_INCREF(obj);
14905 return Py_BuildValue((char *)"");
14906 }
14907 static PyObject *_wrap_wxNewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj;
14909 wxEventType result;
14910 char *kwnames[] = {
14911 NULL
14912 };
14913
14914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxNewEventType",kwnames)) goto fail;
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (wxEventType)wxNewEventType();
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 resultobj = SWIG_From_int((int)(result));
14924 }
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 static PyObject *_wrap_delete_wxEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj;
14933 wxEvent *arg1 = (wxEvent *) 0 ;
14934 PyObject * obj0 = 0 ;
14935 char *kwnames[] = {
14936 (char *) "self", NULL
14937 };
14938
14939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxEvent",kwnames,&obj0)) goto fail;
14940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14941 if (SWIG_arg_fail(1)) SWIG_fail;
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 delete arg1;
14945
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 Py_INCREF(Py_None); resultobj = Py_None;
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_wxEvent_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxEvent *arg1 = (wxEvent *) 0 ;
14959 wxEventType arg2 ;
14960 PyObject * obj0 = 0 ;
14961 PyObject * obj1 = 0 ;
14962 char *kwnames[] = {
14963 (char *) "self",(char *) "typ", NULL
14964 };
14965
14966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvent_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14968 if (SWIG_arg_fail(1)) SWIG_fail;
14969 {
14970 arg2 = (wxEventType)(SWIG_As_int(obj1));
14971 if (SWIG_arg_fail(2)) SWIG_fail;
14972 }
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 (arg1)->SetEventType(arg2);
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 Py_INCREF(Py_None); resultobj = Py_None;
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 static PyObject *_wrap_wxEvent_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxEvent *arg1 = (wxEvent *) 0 ;
14990 wxEventType result;
14991 PyObject * obj0 = 0 ;
14992 char *kwnames[] = {
14993 (char *) "self", NULL
14994 };
14995
14996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_GetEventType",kwnames,&obj0)) goto fail;
14997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14998 if (SWIG_arg_fail(1)) SWIG_fail;
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15002
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 {
15007 resultobj = SWIG_From_int((int)(result));
15008 }
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 static PyObject *_wrap_wxEvent_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15016 PyObject *resultobj;
15017 wxEvent *arg1 = (wxEvent *) 0 ;
15018 wxObject *result;
15019 PyObject * obj0 = 0 ;
15020 char *kwnames[] = {
15021 (char *) "self", NULL
15022 };
15023
15024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_GetEventObject",kwnames,&obj0)) goto fail;
15025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15026 if (SWIG_arg_fail(1)) SWIG_fail;
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15030
15031 wxPyEndAllowThreads(__tstate);
15032 if (PyErr_Occurred()) SWIG_fail;
15033 }
15034 {
15035 resultobj = wxPyMake_wxObject(result, 0);
15036 }
15037 return resultobj;
15038 fail:
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_wxEvent_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxEvent *arg1 = (wxEvent *) 0 ;
15046 wxObject *arg2 = (wxObject *) 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 char *kwnames[] = {
15050 (char *) "self",(char *) "obj", NULL
15051 };
15052
15053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvent_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15055 if (SWIG_arg_fail(1)) SWIG_fail;
15056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15057 if (SWIG_arg_fail(2)) SWIG_fail;
15058 {
15059 PyThreadState* __tstate = wxPyBeginAllowThreads();
15060 (arg1)->SetEventObject(arg2);
15061
15062 wxPyEndAllowThreads(__tstate);
15063 if (PyErr_Occurred()) SWIG_fail;
15064 }
15065 Py_INCREF(Py_None); resultobj = Py_None;
15066 return resultobj;
15067 fail:
15068 return NULL;
15069 }
15070
15071
15072 static PyObject *_wrap_wxEvent_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15073 PyObject *resultobj;
15074 wxEvent *arg1 = (wxEvent *) 0 ;
15075 long result;
15076 PyObject * obj0 = 0 ;
15077 char *kwnames[] = {
15078 (char *) "self", NULL
15079 };
15080
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_GetTimestamp",kwnames,&obj0)) goto fail;
15082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15083 if (SWIG_arg_fail(1)) SWIG_fail;
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15087
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 {
15092 resultobj = SWIG_From_long((long)(result));
15093 }
15094 return resultobj;
15095 fail:
15096 return NULL;
15097 }
15098
15099
15100 static PyObject *_wrap_wxEvent_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15101 PyObject *resultobj;
15102 wxEvent *arg1 = (wxEvent *) 0 ;
15103 long arg2 = (long) 0 ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 char *kwnames[] = {
15107 (char *) "self",(char *) "ts", NULL
15108 };
15109
15110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxEvent_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15112 if (SWIG_arg_fail(1)) SWIG_fail;
15113 if (obj1) {
15114 {
15115 arg2 = (long)(SWIG_As_long(obj1));
15116 if (SWIG_arg_fail(2)) SWIG_fail;
15117 }
15118 }
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 (arg1)->SetTimestamp(arg2);
15122
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 Py_INCREF(Py_None); resultobj = Py_None;
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 static PyObject *_wrap_wxEvent_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj;
15135 wxEvent *arg1 = (wxEvent *) 0 ;
15136 int result;
15137 PyObject * obj0 = 0 ;
15138 char *kwnames[] = {
15139 (char *) "self", NULL
15140 };
15141
15142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_GetId",kwnames,&obj0)) goto fail;
15143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15144 if (SWIG_arg_fail(1)) SWIG_fail;
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 result = (int)((wxEvent const *)arg1)->GetId();
15148
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 {
15153 resultobj = SWIG_From_int((int)(result));
15154 }
15155 return resultobj;
15156 fail:
15157 return NULL;
15158 }
15159
15160
15161 static PyObject *_wrap_wxEvent_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj;
15163 wxEvent *arg1 = (wxEvent *) 0 ;
15164 int arg2 ;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char *kwnames[] = {
15168 (char *) "self",(char *) "Id", NULL
15169 };
15170
15171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvent_SetId",kwnames,&obj0,&obj1)) goto fail;
15172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15173 if (SWIG_arg_fail(1)) SWIG_fail;
15174 {
15175 arg2 = (int)(SWIG_As_int(obj1));
15176 if (SWIG_arg_fail(2)) SWIG_fail;
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 (arg1)->SetId(arg2);
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 Py_INCREF(Py_None); resultobj = Py_None;
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 static PyObject *_wrap_wxEvent_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj;
15194 wxEvent *arg1 = (wxEvent *) 0 ;
15195 bool result;
15196 PyObject * obj0 = 0 ;
15197 char *kwnames[] = {
15198 (char *) "self", NULL
15199 };
15200
15201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_IsCommandEvent",kwnames,&obj0)) goto fail;
15202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15203 if (SWIG_arg_fail(1)) SWIG_fail;
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15207
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 {
15212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15213 }
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 static PyObject *_wrap_wxEvent_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj;
15222 wxEvent *arg1 = (wxEvent *) 0 ;
15223 bool arg2 = (bool) true ;
15224 PyObject * obj0 = 0 ;
15225 PyObject * obj1 = 0 ;
15226 char *kwnames[] = {
15227 (char *) "self",(char *) "skip", NULL
15228 };
15229
15230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxEvent_Skip",kwnames,&obj0,&obj1)) goto fail;
15231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15232 if (SWIG_arg_fail(1)) SWIG_fail;
15233 if (obj1) {
15234 {
15235 arg2 = (bool)(SWIG_As_bool(obj1));
15236 if (SWIG_arg_fail(2)) SWIG_fail;
15237 }
15238 }
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 (arg1)->Skip(arg2);
15242
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 Py_INCREF(Py_None); resultobj = Py_None;
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 static PyObject *_wrap_wxEvent_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15254 PyObject *resultobj;
15255 wxEvent *arg1 = (wxEvent *) 0 ;
15256 bool result;
15257 PyObject * obj0 = 0 ;
15258 char *kwnames[] = {
15259 (char *) "self", NULL
15260 };
15261
15262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_GetSkipped",kwnames,&obj0)) goto fail;
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 {
15273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15274 }
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 static PyObject *_wrap_wxEvent_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15282 PyObject *resultobj;
15283 wxEvent *arg1 = (wxEvent *) 0 ;
15284 bool result;
15285 PyObject * obj0 = 0 ;
15286 char *kwnames[] = {
15287 (char *) "self", NULL
15288 };
15289
15290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_ShouldPropagate",kwnames,&obj0)) goto fail;
15291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15292 if (SWIG_arg_fail(1)) SWIG_fail;
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15296
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 {
15301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15302 }
15303 return resultobj;
15304 fail:
15305 return NULL;
15306 }
15307
15308
15309 static PyObject *_wrap_wxEvent_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15310 PyObject *resultobj;
15311 wxEvent *arg1 = (wxEvent *) 0 ;
15312 int result;
15313 PyObject * obj0 = 0 ;
15314 char *kwnames[] = {
15315 (char *) "self", NULL
15316 };
15317
15318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_StopPropagation",kwnames,&obj0)) goto fail;
15319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15320 if (SWIG_arg_fail(1)) SWIG_fail;
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 result = (int)(arg1)->StopPropagation();
15324
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 {
15329 resultobj = SWIG_From_int((int)(result));
15330 }
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 static PyObject *_wrap_wxEvent_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15338 PyObject *resultobj;
15339 wxEvent *arg1 = (wxEvent *) 0 ;
15340 int arg2 ;
15341 PyObject * obj0 = 0 ;
15342 PyObject * obj1 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self",(char *) "propagationLevel", NULL
15345 };
15346
15347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxEvent_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15349 if (SWIG_arg_fail(1)) SWIG_fail;
15350 {
15351 arg2 = (int)(SWIG_As_int(obj1));
15352 if (SWIG_arg_fail(2)) SWIG_fail;
15353 }
15354 {
15355 PyThreadState* __tstate = wxPyBeginAllowThreads();
15356 (arg1)->ResumePropagation(arg2);
15357
15358 wxPyEndAllowThreads(__tstate);
15359 if (PyErr_Occurred()) SWIG_fail;
15360 }
15361 Py_INCREF(Py_None); resultobj = Py_None;
15362 return resultobj;
15363 fail:
15364 return NULL;
15365 }
15366
15367
15368 static PyObject *_wrap_wxEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15369 PyObject *resultobj;
15370 wxEvent *arg1 = (wxEvent *) 0 ;
15371 wxEvent *result;
15372 PyObject * obj0 = 0 ;
15373 char *kwnames[] = {
15374 (char *) "self", NULL
15375 };
15376
15377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEvent_Clone",kwnames,&obj0)) goto fail;
15378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15379 if (SWIG_arg_fail(1)) SWIG_fail;
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (wxEvent *)(arg1)->Clone();
15383
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 static PyObject * wxEvent_swigregister(PyObject *, PyObject *args) {
15395 PyObject *obj;
15396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15397 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15398 Py_INCREF(obj);
15399 return Py_BuildValue((char *)"");
15400 }
15401 static PyObject *_wrap_new_wxPropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj;
15403 wxEvent *arg1 = 0 ;
15404 wxPropagationDisabler *result;
15405 PyObject * obj0 = 0 ;
15406 char *kwnames[] = {
15407 (char *) "event", NULL
15408 };
15409
15410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_wxPropagationDisabler",kwnames,&obj0)) goto fail;
15411 {
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 if (arg1 == NULL) {
15415 SWIG_null_ref("wxEvent");
15416 }
15417 if (SWIG_arg_fail(1)) SWIG_fail;
15418 }
15419 {
15420 PyThreadState* __tstate = wxPyBeginAllowThreads();
15421 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15422
15423 wxPyEndAllowThreads(__tstate);
15424 if (PyErr_Occurred()) SWIG_fail;
15425 }
15426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15427 return resultobj;
15428 fail:
15429 return NULL;
15430 }
15431
15432
15433 static PyObject *_wrap_delete_wxPropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj;
15435 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15436 PyObject * obj0 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxPropagationDisabler",kwnames,&obj0)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 PyThreadState* __tstate = wxPyBeginAllowThreads();
15446 delete arg1;
15447
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 Py_INCREF(Py_None); resultobj = Py_None;
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 static PyObject * wxPropagationDisabler_swigregister(PyObject *, PyObject *args) {
15459 PyObject *obj;
15460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15461 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15462 Py_INCREF(obj);
15463 return Py_BuildValue((char *)"");
15464 }
15465 static PyObject *_wrap_new_wxPropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj;
15467 wxEvent *arg1 = 0 ;
15468 wxPropagateOnce *result;
15469 PyObject * obj0 = 0 ;
15470 char *kwnames[] = {
15471 (char *) "event", NULL
15472 };
15473
15474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_wxPropagateOnce",kwnames,&obj0)) goto fail;
15475 {
15476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15477 if (SWIG_arg_fail(1)) SWIG_fail;
15478 if (arg1 == NULL) {
15479 SWIG_null_ref("wxEvent");
15480 }
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 }
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15491 return resultobj;
15492 fail:
15493 return NULL;
15494 }
15495
15496
15497 static PyObject *_wrap_delete_wxPropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15498 PyObject *resultobj;
15499 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15500 PyObject * obj0 = 0 ;
15501 char *kwnames[] = {
15502 (char *) "self", NULL
15503 };
15504
15505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxPropagateOnce",kwnames,&obj0)) goto fail;
15506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15507 if (SWIG_arg_fail(1)) SWIG_fail;
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 delete arg1;
15511
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 Py_INCREF(Py_None); resultobj = Py_None;
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 static PyObject * wxPropagateOnce_swigregister(PyObject *, PyObject *args) {
15523 PyObject *obj;
15524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15525 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15526 Py_INCREF(obj);
15527 return Py_BuildValue((char *)"");
15528 }
15529 static PyObject *_wrap_new_wxCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15530 PyObject *resultobj;
15531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15532 int arg2 = (int) 0 ;
15533 wxCommandEvent *result;
15534 PyObject * obj0 = 0 ;
15535 PyObject * obj1 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "commandType",(char *) "winid", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxCommandEvent",kwnames,&obj0,&obj1)) goto fail;
15541 if (obj0) {
15542 {
15543 arg1 = (wxEventType)(SWIG_As_int(obj0));
15544 if (SWIG_arg_fail(1)) SWIG_fail;
15545 }
15546 }
15547 if (obj1) {
15548 {
15549 arg2 = (int)(SWIG_As_int(obj1));
15550 if (SWIG_arg_fail(2)) SWIG_fail;
15551 }
15552 }
15553 {
15554 PyThreadState* __tstate = wxPyBeginAllowThreads();
15555 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15556
15557 wxPyEndAllowThreads(__tstate);
15558 if (PyErr_Occurred()) SWIG_fail;
15559 }
15560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 static PyObject *_wrap_wxCommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj;
15569 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15570 int result;
15571 PyObject * obj0 = 0 ;
15572 char *kwnames[] = {
15573 (char *) "self", NULL
15574 };
15575
15576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15578 if (SWIG_arg_fail(1)) SWIG_fail;
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15582
15583 wxPyEndAllowThreads(__tstate);
15584 if (PyErr_Occurred()) SWIG_fail;
15585 }
15586 {
15587 resultobj = SWIG_From_int((int)(result));
15588 }
15589 return resultobj;
15590 fail:
15591 return NULL;
15592 }
15593
15594
15595 static PyObject *_wrap_wxCommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15596 PyObject *resultobj;
15597 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15598 wxString *arg2 = 0 ;
15599 bool temp2 = false ;
15600 PyObject * obj0 = 0 ;
15601 PyObject * obj1 = 0 ;
15602 char *kwnames[] = {
15603 (char *) "self",(char *) "s", NULL
15604 };
15605
15606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxCommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15608 if (SWIG_arg_fail(1)) SWIG_fail;
15609 {
15610 arg2 = wxString_in_helper(obj1);
15611 if (arg2 == NULL) SWIG_fail;
15612 temp2 = true;
15613 }
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 (arg1)->SetString((wxString const &)*arg2);
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 Py_INCREF(Py_None); resultobj = Py_None;
15622 {
15623 if (temp2)
15624 delete arg2;
15625 }
15626 return resultobj;
15627 fail:
15628 {
15629 if (temp2)
15630 delete arg2;
15631 }
15632 return NULL;
15633 }
15634
15635
15636 static PyObject *_wrap_wxCommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj;
15638 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15639 wxString result;
15640 PyObject * obj0 = 0 ;
15641 char *kwnames[] = {
15642 (char *) "self", NULL
15643 };
15644
15645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_GetString",kwnames,&obj0)) goto fail;
15646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15647 if (SWIG_arg_fail(1)) SWIG_fail;
15648 {
15649 PyThreadState* __tstate = wxPyBeginAllowThreads();
15650 result = ((wxCommandEvent const *)arg1)->GetString();
15651
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 {
15656 #if wxUSE_UNICODE
15657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15658 #else
15659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15660 #endif
15661 }
15662 return resultobj;
15663 fail:
15664 return NULL;
15665 }
15666
15667
15668 static PyObject *_wrap_wxCommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15669 PyObject *resultobj;
15670 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15671 bool result;
15672 PyObject * obj0 = 0 ;
15673 char *kwnames[] = {
15674 (char *) "self", NULL
15675 };
15676
15677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15679 if (SWIG_arg_fail(1)) SWIG_fail;
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15689 }
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 static PyObject *_wrap_wxCommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj;
15698 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15699 bool result;
15700 PyObject * obj0 = 0 ;
15701 char *kwnames[] = {
15702 (char *) "self", NULL
15703 };
15704
15705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15707 if (SWIG_arg_fail(1)) SWIG_fail;
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15711
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 static PyObject *_wrap_wxCommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj;
15726 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15727 long arg2 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 char *kwnames[] = {
15731 (char *) "self",(char *) "extraLong", NULL
15732 };
15733
15734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxCommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15736 if (SWIG_arg_fail(1)) SWIG_fail;
15737 {
15738 arg2 = (long)(SWIG_As_long(obj1));
15739 if (SWIG_arg_fail(2)) SWIG_fail;
15740 }
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 (arg1)->SetExtraLong(arg2);
15744
15745 wxPyEndAllowThreads(__tstate);
15746 if (PyErr_Occurred()) SWIG_fail;
15747 }
15748 Py_INCREF(Py_None); resultobj = Py_None;
15749 return resultobj;
15750 fail:
15751 return NULL;
15752 }
15753
15754
15755 static PyObject *_wrap_wxCommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15756 PyObject *resultobj;
15757 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15758 long result;
15759 PyObject * obj0 = 0 ;
15760 char *kwnames[] = {
15761 (char *) "self", NULL
15762 };
15763
15764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15766 if (SWIG_arg_fail(1)) SWIG_fail;
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15770
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 {
15775 resultobj = SWIG_From_long((long)(result));
15776 }
15777 return resultobj;
15778 fail:
15779 return NULL;
15780 }
15781
15782
15783 static PyObject *_wrap_wxCommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15784 PyObject *resultobj;
15785 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15786 int arg2 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 char *kwnames[] = {
15790 (char *) "self",(char *) "i", NULL
15791 };
15792
15793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxCommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15795 if (SWIG_arg_fail(1)) SWIG_fail;
15796 {
15797 arg2 = (int)(SWIG_As_int(obj1));
15798 if (SWIG_arg_fail(2)) SWIG_fail;
15799 }
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 (arg1)->SetInt(arg2);
15803
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 Py_INCREF(Py_None); resultobj = Py_None;
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 static PyObject *_wrap_wxCommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj;
15816 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15817 long result;
15818 PyObject * obj0 = 0 ;
15819 char *kwnames[] = {
15820 (char *) "self", NULL
15821 };
15822
15823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_GetInt",kwnames,&obj0)) goto fail;
15824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15825 if (SWIG_arg_fail(1)) SWIG_fail;
15826 {
15827 PyThreadState* __tstate = wxPyBeginAllowThreads();
15828 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15829
15830 wxPyEndAllowThreads(__tstate);
15831 if (PyErr_Occurred()) SWIG_fail;
15832 }
15833 {
15834 resultobj = SWIG_From_long((long)(result));
15835 }
15836 return resultobj;
15837 fail:
15838 return NULL;
15839 }
15840
15841
15842 static PyObject *_wrap_wxCommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15843 PyObject *resultobj;
15844 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15845 wxEvent *result;
15846 PyObject * obj0 = 0 ;
15847 char *kwnames[] = {
15848 (char *) "self", NULL
15849 };
15850
15851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCommandEvent_Clone",kwnames,&obj0)) goto fail;
15852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15853 if (SWIG_arg_fail(1)) SWIG_fail;
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15857
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15862 return resultobj;
15863 fail:
15864 return NULL;
15865 }
15866
15867
15868 static PyObject * wxCommandEvent_swigregister(PyObject *, PyObject *args) {
15869 PyObject *obj;
15870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15871 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15872 Py_INCREF(obj);
15873 return Py_BuildValue((char *)"");
15874 }
15875 static PyObject *_wrap_new_wxNotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj;
15877 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15878 int arg2 = (int) 0 ;
15879 wxNotifyEvent *result;
15880 PyObject * obj0 = 0 ;
15881 PyObject * obj1 = 0 ;
15882 char *kwnames[] = {
15883 (char *) "commandType",(char *) "winid", NULL
15884 };
15885
15886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxNotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15887 if (obj0) {
15888 {
15889 arg1 = (wxEventType)(SWIG_As_int(obj0));
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 }
15892 }
15893 if (obj1) {
15894 {
15895 arg2 = (int)(SWIG_As_int(obj1));
15896 if (SWIG_arg_fail(2)) SWIG_fail;
15897 }
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_wxNotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15916 PyObject * obj0 = 0 ;
15917 char *kwnames[] = {
15918 (char *) "self", NULL
15919 };
15920
15921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNotifyEvent_Veto",kwnames,&obj0)) goto fail;
15922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15923 if (SWIG_arg_fail(1)) SWIG_fail;
15924 {
15925 PyThreadState* __tstate = wxPyBeginAllowThreads();
15926 (arg1)->Veto();
15927
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 Py_INCREF(Py_None); resultobj = Py_None;
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 static PyObject *_wrap_wxNotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj;
15940 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15941 PyObject * obj0 = 0 ;
15942 char *kwnames[] = {
15943 (char *) "self", NULL
15944 };
15945
15946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNotifyEvent_Allow",kwnames,&obj0)) goto fail;
15947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15948 if (SWIG_arg_fail(1)) SWIG_fail;
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 (arg1)->Allow();
15952
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 Py_INCREF(Py_None); resultobj = Py_None;
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 static PyObject *_wrap_wxNotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj;
15965 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15966 bool result;
15967 PyObject * obj0 = 0 ;
15968 char *kwnames[] = {
15969 (char *) "self", NULL
15970 };
15971
15972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15974 if (SWIG_arg_fail(1)) SWIG_fail;
15975 {
15976 PyThreadState* __tstate = wxPyBeginAllowThreads();
15977 result = (bool)(arg1)->IsAllowed();
15978
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 {
15983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15984 }
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject * wxNotifyEvent_swigregister(PyObject *, PyObject *args) {
15992 PyObject *obj;
15993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15994 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15995 Py_INCREF(obj);
15996 return Py_BuildValue((char *)"");
15997 }
15998 static PyObject *_wrap_new_wxScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15999 PyObject *resultobj;
16000 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16001 int arg2 = (int) 0 ;
16002 int arg3 = (int) 0 ;
16003 int arg4 = (int) 0 ;
16004 wxScrollEvent *result;
16005 PyObject * obj0 = 0 ;
16006 PyObject * obj1 = 0 ;
16007 PyObject * obj2 = 0 ;
16008 PyObject * obj3 = 0 ;
16009 char *kwnames[] = {
16010 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16011 };
16012
16013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_wxScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16014 if (obj0) {
16015 {
16016 arg1 = (wxEventType)(SWIG_As_int(obj0));
16017 if (SWIG_arg_fail(1)) SWIG_fail;
16018 }
16019 }
16020 if (obj1) {
16021 {
16022 arg2 = (int)(SWIG_As_int(obj1));
16023 if (SWIG_arg_fail(2)) SWIG_fail;
16024 }
16025 }
16026 if (obj2) {
16027 {
16028 arg3 = (int)(SWIG_As_int(obj2));
16029 if (SWIG_arg_fail(3)) SWIG_fail;
16030 }
16031 }
16032 if (obj3) {
16033 {
16034 arg4 = (int)(SWIG_As_int(obj3));
16035 if (SWIG_arg_fail(4)) SWIG_fail;
16036 }
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject *_wrap_wxScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj;
16054 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16055 int result;
16056 PyObject * obj0 = 0 ;
16057 char *kwnames[] = {
16058 (char *) "self", NULL
16059 };
16060
16061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16063 if (SWIG_arg_fail(1)) SWIG_fail;
16064 {
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16067
16068 wxPyEndAllowThreads(__tstate);
16069 if (PyErr_Occurred()) SWIG_fail;
16070 }
16071 {
16072 resultobj = SWIG_From_int((int)(result));
16073 }
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 static PyObject *_wrap_wxScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj;
16082 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16083 int result;
16084 PyObject * obj0 = 0 ;
16085 char *kwnames[] = {
16086 (char *) "self", NULL
16087 };
16088
16089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16091 if (SWIG_arg_fail(1)) SWIG_fail;
16092 {
16093 PyThreadState* __tstate = wxPyBeginAllowThreads();
16094 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16095
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 {
16100 resultobj = SWIG_From_int((int)(result));
16101 }
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 static PyObject *_wrap_wxScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj;
16110 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16111 int arg2 ;
16112 PyObject * obj0 = 0 ;
16113 PyObject * obj1 = 0 ;
16114 char *kwnames[] = {
16115 (char *) "self",(char *) "orient", NULL
16116 };
16117
16118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16120 if (SWIG_arg_fail(1)) SWIG_fail;
16121 {
16122 arg2 = (int)(SWIG_As_int(obj1));
16123 if (SWIG_arg_fail(2)) SWIG_fail;
16124 }
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 (arg1)->SetOrientation(arg2);
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 Py_INCREF(Py_None); resultobj = Py_None;
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 static PyObject *_wrap_wxScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16140 PyObject *resultobj;
16141 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16142 int arg2 ;
16143 PyObject * obj0 = 0 ;
16144 PyObject * obj1 = 0 ;
16145 char *kwnames[] = {
16146 (char *) "self",(char *) "pos", NULL
16147 };
16148
16149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16151 if (SWIG_arg_fail(1)) SWIG_fail;
16152 {
16153 arg2 = (int)(SWIG_As_int(obj1));
16154 if (SWIG_arg_fail(2)) SWIG_fail;
16155 }
16156 {
16157 PyThreadState* __tstate = wxPyBeginAllowThreads();
16158 (arg1)->SetPosition(arg2);
16159
16160 wxPyEndAllowThreads(__tstate);
16161 if (PyErr_Occurred()) SWIG_fail;
16162 }
16163 Py_INCREF(Py_None); resultobj = Py_None;
16164 return resultobj;
16165 fail:
16166 return NULL;
16167 }
16168
16169
16170 static PyObject * wxScrollEvent_swigregister(PyObject *, PyObject *args) {
16171 PyObject *obj;
16172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16173 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16174 Py_INCREF(obj);
16175 return Py_BuildValue((char *)"");
16176 }
16177 static PyObject *_wrap_new_wxScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj;
16179 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16180 int arg2 = (int) 0 ;
16181 int arg3 = (int) 0 ;
16182 wxScrollWinEvent *result;
16183 PyObject * obj0 = 0 ;
16184 PyObject * obj1 = 0 ;
16185 PyObject * obj2 = 0 ;
16186 char *kwnames[] = {
16187 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16188 };
16189
16190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_wxScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16191 if (obj0) {
16192 {
16193 arg1 = (wxEventType)(SWIG_As_int(obj0));
16194 if (SWIG_arg_fail(1)) SWIG_fail;
16195 }
16196 }
16197 if (obj1) {
16198 {
16199 arg2 = (int)(SWIG_As_int(obj1));
16200 if (SWIG_arg_fail(2)) SWIG_fail;
16201 }
16202 }
16203 if (obj2) {
16204 {
16205 arg3 = (int)(SWIG_As_int(obj2));
16206 if (SWIG_arg_fail(3)) SWIG_fail;
16207 }
16208 }
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 static PyObject *_wrap_wxScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj;
16225 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16226 int result;
16227 PyObject * obj0 = 0 ;
16228 char *kwnames[] = {
16229 (char *) "self", NULL
16230 };
16231
16232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16238
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = SWIG_From_int((int)(result));
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 static PyObject *_wrap_wxScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16252 PyObject *resultobj;
16253 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16254 int result;
16255 PyObject * obj0 = 0 ;
16256 char *kwnames[] = {
16257 (char *) "self", NULL
16258 };
16259
16260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16262 if (SWIG_arg_fail(1)) SWIG_fail;
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 {
16271 resultobj = SWIG_From_int((int)(result));
16272 }
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 static PyObject *_wrap_wxScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj;
16281 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16282 int arg2 ;
16283 PyObject * obj0 = 0 ;
16284 PyObject * obj1 = 0 ;
16285 char *kwnames[] = {
16286 (char *) "self",(char *) "orient", NULL
16287 };
16288
16289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16291 if (SWIG_arg_fail(1)) SWIG_fail;
16292 {
16293 arg2 = (int)(SWIG_As_int(obj1));
16294 if (SWIG_arg_fail(2)) SWIG_fail;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 (arg1)->SetOrientation(arg2);
16299
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 Py_INCREF(Py_None); resultobj = Py_None;
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 static PyObject *_wrap_wxScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj;
16312 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16313 int arg2 ;
16314 PyObject * obj0 = 0 ;
16315 PyObject * obj1 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self",(char *) "pos", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 arg2 = (int)(SWIG_As_int(obj1));
16325 if (SWIG_arg_fail(2)) SWIG_fail;
16326 }
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 (arg1)->SetPosition(arg2);
16330
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 Py_INCREF(Py_None); resultobj = Py_None;
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject * wxScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16342 PyObject *obj;
16343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16344 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16345 Py_INCREF(obj);
16346 return Py_BuildValue((char *)"");
16347 }
16348 static PyObject *_wrap_new_wxMouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj;
16350 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16351 wxMouseEvent *result;
16352 PyObject * obj0 = 0 ;
16353 char *kwnames[] = {
16354 (char *) "mouseType", NULL
16355 };
16356
16357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxMouseEvent",kwnames,&obj0)) goto fail;
16358 if (obj0) {
16359 {
16360 arg1 = (wxEventType)(SWIG_As_int(obj0));
16361 if (SWIG_arg_fail(1)) SWIG_fail;
16362 }
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16367
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 {
16372 resultobj = wxPyMake_wxObject(result, 1);
16373 }
16374 return resultobj;
16375 fail:
16376 return NULL;
16377 }
16378
16379
16380 static PyObject *_wrap_wxMouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16381 PyObject *resultobj;
16382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16383 bool result;
16384 PyObject * obj0 = 0 ;
16385 char *kwnames[] = {
16386 (char *) "self", NULL
16387 };
16388
16389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_IsButton",kwnames,&obj0)) goto fail;
16390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16391 if (SWIG_arg_fail(1)) SWIG_fail;
16392 {
16393 PyThreadState* __tstate = wxPyBeginAllowThreads();
16394 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16395
16396 wxPyEndAllowThreads(__tstate);
16397 if (PyErr_Occurred()) SWIG_fail;
16398 }
16399 {
16400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16401 }
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 static PyObject *_wrap_wxMouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj;
16410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16411 int arg2 = (int) wxMOUSE_BTN_ANY ;
16412 bool result;
16413 PyObject * obj0 = 0 ;
16414 PyObject * obj1 = 0 ;
16415 char *kwnames[] = {
16416 (char *) "self",(char *) "but", NULL
16417 };
16418
16419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16421 if (SWIG_arg_fail(1)) SWIG_fail;
16422 if (obj1) {
16423 {
16424 arg2 = (int)(SWIG_As_int(obj1));
16425 if (SWIG_arg_fail(2)) SWIG_fail;
16426 }
16427 }
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16431
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 {
16436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16437 }
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 static PyObject *_wrap_wxMouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj;
16446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16447 int arg2 = (int) wxMOUSE_BTN_ANY ;
16448 bool result;
16449 PyObject * obj0 = 0 ;
16450 PyObject * obj1 = 0 ;
16451 char *kwnames[] = {
16452 (char *) "self",(char *) "but", NULL
16453 };
16454
16455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16457 if (SWIG_arg_fail(1)) SWIG_fail;
16458 if (obj1) {
16459 {
16460 arg2 = (int)(SWIG_As_int(obj1));
16461 if (SWIG_arg_fail(2)) SWIG_fail;
16462 }
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16467
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 {
16472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16473 }
16474 return resultobj;
16475 fail:
16476 return NULL;
16477 }
16478
16479
16480 static PyObject *_wrap_wxMouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16481 PyObject *resultobj;
16482 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16483 int arg2 = (int) wxMOUSE_BTN_ANY ;
16484 bool result;
16485 PyObject * obj0 = 0 ;
16486 PyObject * obj1 = 0 ;
16487 char *kwnames[] = {
16488 (char *) "self",(char *) "but", NULL
16489 };
16490
16491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16493 if (SWIG_arg_fail(1)) SWIG_fail;
16494 if (obj1) {
16495 {
16496 arg2 = (int)(SWIG_As_int(obj1));
16497 if (SWIG_arg_fail(2)) SWIG_fail;
16498 }
16499 }
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16503
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 {
16508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16509 }
16510 return resultobj;
16511 fail:
16512 return NULL;
16513 }
16514
16515
16516 static PyObject *_wrap_wxMouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj;
16518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16519 int arg2 ;
16520 bool result;
16521 PyObject * obj0 = 0 ;
16522 PyObject * obj1 = 0 ;
16523 char *kwnames[] = {
16524 (char *) "self",(char *) "but", NULL
16525 };
16526
16527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16529 if (SWIG_arg_fail(1)) SWIG_fail;
16530 {
16531 arg2 = (int)(SWIG_As_int(obj1));
16532 if (SWIG_arg_fail(2)) SWIG_fail;
16533 }
16534 {
16535 PyThreadState* __tstate = wxPyBeginAllowThreads();
16536 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16537
16538 wxPyEndAllowThreads(__tstate);
16539 if (PyErr_Occurred()) SWIG_fail;
16540 }
16541 {
16542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16543 }
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 static PyObject *_wrap_wxMouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16551 PyObject *resultobj;
16552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16553 int arg2 ;
16554 bool result;
16555 PyObject * obj0 = 0 ;
16556 PyObject * obj1 = 0 ;
16557 char *kwnames[] = {
16558 (char *) "self",(char *) "but", NULL
16559 };
16560
16561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16563 if (SWIG_arg_fail(1)) SWIG_fail;
16564 {
16565 arg2 = (int)(SWIG_As_int(obj1));
16566 if (SWIG_arg_fail(2)) SWIG_fail;
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16571
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 {
16576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16577 }
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 static PyObject *_wrap_wxMouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj;
16586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16587 int result;
16588 PyObject * obj0 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetButton",kwnames,&obj0)) goto fail;
16594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16595 if (SWIG_arg_fail(1)) SWIG_fail;
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16599
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 {
16604 resultobj = SWIG_From_int((int)(result));
16605 }
16606 return resultobj;
16607 fail:
16608 return NULL;
16609 }
16610
16611
16612 static PyObject *_wrap_wxMouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16613 PyObject *resultobj;
16614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16615 bool result;
16616 PyObject * obj0 = 0 ;
16617 char *kwnames[] = {
16618 (char *) "self", NULL
16619 };
16620
16621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16623 if (SWIG_arg_fail(1)) SWIG_fail;
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16627
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 {
16632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16633 }
16634 return resultobj;
16635 fail:
16636 return NULL;
16637 }
16638
16639
16640 static PyObject *_wrap_wxMouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16641 PyObject *resultobj;
16642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16643 bool result;
16644 PyObject * obj0 = 0 ;
16645 char *kwnames[] = {
16646 (char *) "self", NULL
16647 };
16648
16649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16651 if (SWIG_arg_fail(1)) SWIG_fail;
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16655
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 {
16660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16661 }
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_wxMouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16671 bool result;
16672 PyObject * obj0 = 0 ;
16673 char *kwnames[] = {
16674 (char *) "self", NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_AltDown",kwnames,&obj0)) goto fail;
16678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16679 if (SWIG_arg_fail(1)) SWIG_fail;
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16683
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 {
16688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16689 }
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject *_wrap_wxMouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj;
16698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16699 bool result;
16700 PyObject * obj0 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "self", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 {
16716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_wxMouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16727 bool result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_wxMouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16755 bool result;
16756 PyObject * obj0 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16763 if (SWIG_arg_fail(1)) SWIG_fail;
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16773 }
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_wxMouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj;
16782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16783 bool result;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 {
16800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16801 }
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 static PyObject *_wrap_wxMouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj;
16810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16811 bool result;
16812 PyObject * obj0 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self", NULL
16815 };
16816
16817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_RightDown",kwnames,&obj0)) goto fail;
16818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16823
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_wxMouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16839 bool result;
16840 PyObject * obj0 = 0 ;
16841 char *kwnames[] = {
16842 (char *) "self", NULL
16843 };
16844
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 {
16856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16857 }
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_wxMouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16867 bool result;
16868 PyObject * obj0 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16879
16880 wxPyEndAllowThreads(__tstate);
16881 if (PyErr_Occurred()) SWIG_fail;
16882 }
16883 {
16884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16885 }
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 static PyObject *_wrap_wxMouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj;
16894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16895 bool result;
16896 PyObject * obj0 = 0 ;
16897 char *kwnames[] = {
16898 (char *) "self", NULL
16899 };
16900
16901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_RightUp",kwnames,&obj0)) goto fail;
16902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16903 if (SWIG_arg_fail(1)) SWIG_fail;
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16913 }
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_wxMouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16923 bool result;
16924 PyObject * obj0 = 0 ;
16925 char *kwnames[] = {
16926 (char *) "self", NULL
16927 };
16928
16929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16931 if (SWIG_arg_fail(1)) SWIG_fail;
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16935
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 static PyObject *_wrap_wxMouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj;
16950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16951 bool result;
16952 PyObject * obj0 = 0 ;
16953 char *kwnames[] = {
16954 (char *) "self", NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16959 if (SWIG_arg_fail(1)) SWIG_fail;
16960 {
16961 PyThreadState* __tstate = wxPyBeginAllowThreads();
16962 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16963
16964 wxPyEndAllowThreads(__tstate);
16965 if (PyErr_Occurred()) SWIG_fail;
16966 }
16967 {
16968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16969 }
16970 return resultobj;
16971 fail:
16972 return NULL;
16973 }
16974
16975
16976 static PyObject *_wrap_wxMouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16977 PyObject *resultobj;
16978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16979 bool result;
16980 PyObject * obj0 = 0 ;
16981 char *kwnames[] = {
16982 (char *) "self", NULL
16983 };
16984
16985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16987 if (SWIG_arg_fail(1)) SWIG_fail;
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16991
16992 wxPyEndAllowThreads(__tstate);
16993 if (PyErr_Occurred()) SWIG_fail;
16994 }
16995 {
16996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16997 }
16998 return resultobj;
16999 fail:
17000 return NULL;
17001 }
17002
17003
17004 static PyObject *_wrap_wxMouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17005 PyObject *resultobj;
17006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17007 bool result;
17008 PyObject * obj0 = 0 ;
17009 char *kwnames[] = {
17010 (char *) "self", NULL
17011 };
17012
17013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17015 if (SWIG_arg_fail(1)) SWIG_fail;
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 result = (bool)(arg1)->LeftIsDown();
17019
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 {
17024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17025 }
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_wxMouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17035 bool result;
17036 PyObject * obj0 = 0 ;
17037 char *kwnames[] = {
17038 (char *) "self", NULL
17039 };
17040
17041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17043 if (SWIG_arg_fail(1)) SWIG_fail;
17044 {
17045 PyThreadState* __tstate = wxPyBeginAllowThreads();
17046 result = (bool)(arg1)->MiddleIsDown();
17047
17048 wxPyEndAllowThreads(__tstate);
17049 if (PyErr_Occurred()) SWIG_fail;
17050 }
17051 {
17052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17053 }
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 static PyObject *_wrap_wxMouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj;
17062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17063 bool result;
17064 PyObject * obj0 = 0 ;
17065 char *kwnames[] = {
17066 (char *) "self", NULL
17067 };
17068
17069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17071 if (SWIG_arg_fail(1)) SWIG_fail;
17072 {
17073 PyThreadState* __tstate = wxPyBeginAllowThreads();
17074 result = (bool)(arg1)->RightIsDown();
17075
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 {
17080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17081 }
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 static PyObject *_wrap_wxMouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj;
17090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17091 bool result;
17092 PyObject * obj0 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self", NULL
17095 };
17096
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_Dragging",kwnames,&obj0)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 {
17101 PyThreadState* __tstate = wxPyBeginAllowThreads();
17102 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17103
17104 wxPyEndAllowThreads(__tstate);
17105 if (PyErr_Occurred()) SWIG_fail;
17106 }
17107 {
17108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17109 }
17110 return resultobj;
17111 fail:
17112 return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_wxMouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj;
17118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17119 bool result;
17120 PyObject * obj0 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_Moving",kwnames,&obj0)) goto fail;
17126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17127 if (SWIG_arg_fail(1)) SWIG_fail;
17128 {
17129 PyThreadState* __tstate = wxPyBeginAllowThreads();
17130 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17137 }
17138 return resultobj;
17139 fail:
17140 return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_wxMouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17145 PyObject *resultobj;
17146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17147 bool result;
17148 PyObject * obj0 = 0 ;
17149 char *kwnames[] = {
17150 (char *) "self", NULL
17151 };
17152
17153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_Entering",kwnames,&obj0)) goto fail;
17154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17155 if (SWIG_arg_fail(1)) SWIG_fail;
17156 {
17157 PyThreadState* __tstate = wxPyBeginAllowThreads();
17158 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17159
17160 wxPyEndAllowThreads(__tstate);
17161 if (PyErr_Occurred()) SWIG_fail;
17162 }
17163 {
17164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17165 }
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_wxMouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17175 bool result;
17176 PyObject * obj0 = 0 ;
17177 char *kwnames[] = {
17178 (char *) "self", NULL
17179 };
17180
17181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_Leaving",kwnames,&obj0)) goto fail;
17182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17183 if (SWIG_arg_fail(1)) SWIG_fail;
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17187
17188 wxPyEndAllowThreads(__tstate);
17189 if (PyErr_Occurred()) SWIG_fail;
17190 }
17191 {
17192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17193 }
17194 return resultobj;
17195 fail:
17196 return NULL;
17197 }
17198
17199
17200 static PyObject *_wrap_wxMouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17201 PyObject *resultobj;
17202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17203 wxPoint result;
17204 PyObject * obj0 = 0 ;
17205 char *kwnames[] = {
17206 (char *) "self", NULL
17207 };
17208
17209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17211 if (SWIG_arg_fail(1)) SWIG_fail;
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (arg1)->GetPosition();
17215
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 {
17220 wxPoint * resultptr;
17221 resultptr = new wxPoint((wxPoint &)(result));
17222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17223 }
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject *_wrap_wxMouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17231 PyObject *resultobj;
17232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17233 long *arg2 = (long *) 0 ;
17234 long *arg3 = (long *) 0 ;
17235 long temp2 ;
17236 int res2 = 0 ;
17237 long temp3 ;
17238 int res3 = 0 ;
17239 PyObject * obj0 = 0 ;
17240 char *kwnames[] = {
17241 (char *) "self", NULL
17242 };
17243
17244 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17245 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17248 if (SWIG_arg_fail(1)) SWIG_fail;
17249 {
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 (arg1)->GetPosition(arg2,arg3);
17252
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 Py_INCREF(Py_None); resultobj = Py_None;
17257 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17258 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17259 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17260 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 static PyObject *_wrap_wxMouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj;
17269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17270 wxDC *arg2 = 0 ;
17271 wxPoint result;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 char *kwnames[] = {
17275 (char *) "self",(char *) "dc", NULL
17276 };
17277
17278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17280 if (SWIG_arg_fail(1)) SWIG_fail;
17281 {
17282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17283 if (SWIG_arg_fail(2)) SWIG_fail;
17284 if (arg2 == NULL) {
17285 SWIG_null_ref("wxDC");
17286 }
17287 if (SWIG_arg_fail(2)) SWIG_fail;
17288 }
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17292
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 {
17297 wxPoint * resultptr;
17298 resultptr = new wxPoint((wxPoint &)(result));
17299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17300 }
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_wxMouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17310 int result;
17311 PyObject * obj0 = 0 ;
17312 char *kwnames[] = {
17313 (char *) "self", NULL
17314 };
17315
17316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetX",kwnames,&obj0)) goto fail;
17317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17318 if (SWIG_arg_fail(1)) SWIG_fail;
17319 {
17320 PyThreadState* __tstate = wxPyBeginAllowThreads();
17321 result = (int)((wxMouseEvent const *)arg1)->GetX();
17322
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 {
17327 resultobj = SWIG_From_int((int)(result));
17328 }
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_wxMouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17338 int result;
17339 PyObject * obj0 = 0 ;
17340 char *kwnames[] = {
17341 (char *) "self", NULL
17342 };
17343
17344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetY",kwnames,&obj0)) goto fail;
17345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(1)) SWIG_fail;
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (int)((wxMouseEvent const *)arg1)->GetY();
17350
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 {
17355 resultobj = SWIG_From_int((int)(result));
17356 }
17357 return resultobj;
17358 fail:
17359 return NULL;
17360 }
17361
17362
17363 static PyObject *_wrap_wxMouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17364 PyObject *resultobj;
17365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17366 int result;
17367 PyObject * obj0 = 0 ;
17368 char *kwnames[] = {
17369 (char *) "self", NULL
17370 };
17371
17372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17374 if (SWIG_arg_fail(1)) SWIG_fail;
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17378
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 {
17383 resultobj = SWIG_From_int((int)(result));
17384 }
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 static PyObject *_wrap_wxMouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj;
17393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17394 int result;
17395 PyObject * obj0 = 0 ;
17396 char *kwnames[] = {
17397 (char *) "self", NULL
17398 };
17399
17400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17406
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = SWIG_From_int((int)(result));
17412 }
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 static PyObject *_wrap_wxMouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj;
17421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17422 int result;
17423 PyObject * obj0 = 0 ;
17424 char *kwnames[] = {
17425 (char *) "self", NULL
17426 };
17427
17428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17430 if (SWIG_arg_fail(1)) SWIG_fail;
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17434
17435 wxPyEndAllowThreads(__tstate);
17436 if (PyErr_Occurred()) SWIG_fail;
17437 }
17438 {
17439 resultobj = SWIG_From_int((int)(result));
17440 }
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 static PyObject *_wrap_wxMouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17448 PyObject *resultobj;
17449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17450 bool result;
17451 PyObject * obj0 = 0 ;
17452 char *kwnames[] = {
17453 (char *) "self", NULL
17454 };
17455
17456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17458 if (SWIG_arg_fail(1)) SWIG_fail;
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17462
17463 wxPyEndAllowThreads(__tstate);
17464 if (PyErr_Occurred()) SWIG_fail;
17465 }
17466 {
17467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17468 }
17469 return resultobj;
17470 fail:
17471 return NULL;
17472 }
17473
17474
17475 static PyObject *_wrap_wxMouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17476 PyObject *resultobj;
17477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17478 int arg2 ;
17479 PyObject * obj0 = 0 ;
17480 PyObject * obj1 = 0 ;
17481 char *kwnames[] = {
17482 (char *) "self",(char *) "m_x", NULL
17483 };
17484
17485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17487 if (SWIG_arg_fail(1)) SWIG_fail;
17488 {
17489 arg2 = (int)(SWIG_As_int(obj1));
17490 if (SWIG_arg_fail(2)) SWIG_fail;
17491 }
17492 if (arg1) (arg1)->m_x = arg2;
17493
17494 Py_INCREF(Py_None); resultobj = Py_None;
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_wxMouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17504 int result;
17505 PyObject * obj0 = 0 ;
17506 char *kwnames[] = {
17507 (char *) "self", NULL
17508 };
17509
17510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17512 if (SWIG_arg_fail(1)) SWIG_fail;
17513 result = (int) ((arg1)->m_x);
17514
17515 {
17516 resultobj = SWIG_From_int((int)(result));
17517 }
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_wxMouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj;
17526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17527 int arg2 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 char *kwnames[] = {
17531 (char *) "self",(char *) "m_y", NULL
17532 };
17533
17534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17536 if (SWIG_arg_fail(1)) SWIG_fail;
17537 {
17538 arg2 = (int)(SWIG_As_int(obj1));
17539 if (SWIG_arg_fail(2)) SWIG_fail;
17540 }
17541 if (arg1) (arg1)->m_y = arg2;
17542
17543 Py_INCREF(Py_None); resultobj = Py_None;
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_wxMouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17553 int result;
17554 PyObject * obj0 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 result = (int) ((arg1)->m_y);
17563
17564 {
17565 resultobj = SWIG_From_int((int)(result));
17566 }
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 static PyObject *_wrap_wxMouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj;
17575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17576 bool arg2 ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self",(char *) "m_leftDown", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 arg2 = (bool)(SWIG_As_bool(obj1));
17588 if (SWIG_arg_fail(2)) SWIG_fail;
17589 }
17590 if (arg1) (arg1)->m_leftDown = arg2;
17591
17592 Py_INCREF(Py_None); resultobj = Py_None;
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_wxMouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj;
17601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17602 bool result;
17603 PyObject * obj0 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 result = (bool) ((arg1)->m_leftDown);
17612
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 static PyObject *_wrap_wxMouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj;
17624 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17625 bool arg2 ;
17626 PyObject * obj0 = 0 ;
17627 PyObject * obj1 = 0 ;
17628 char *kwnames[] = {
17629 (char *) "self",(char *) "m_middleDown", NULL
17630 };
17631
17632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17634 if (SWIG_arg_fail(1)) SWIG_fail;
17635 {
17636 arg2 = (bool)(SWIG_As_bool(obj1));
17637 if (SWIG_arg_fail(2)) SWIG_fail;
17638 }
17639 if (arg1) (arg1)->m_middleDown = arg2;
17640
17641 Py_INCREF(Py_None); resultobj = Py_None;
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject *_wrap_wxMouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17649 PyObject *resultobj;
17650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17651 bool result;
17652 PyObject * obj0 = 0 ;
17653 char *kwnames[] = {
17654 (char *) "self", NULL
17655 };
17656
17657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17659 if (SWIG_arg_fail(1)) SWIG_fail;
17660 result = (bool) ((arg1)->m_middleDown);
17661
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 static PyObject *_wrap_wxMouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj;
17673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17674 bool arg2 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "m_rightDown", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 arg2 = (bool)(SWIG_As_bool(obj1));
17686 if (SWIG_arg_fail(2)) SWIG_fail;
17687 }
17688 if (arg1) (arg1)->m_rightDown = arg2;
17689
17690 Py_INCREF(Py_None); resultobj = Py_None;
17691 return resultobj;
17692 fail:
17693 return NULL;
17694 }
17695
17696
17697 static PyObject *_wrap_wxMouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj;
17699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17700 bool result;
17701 PyObject * obj0 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 result = (bool) ((arg1)->m_rightDown);
17710
17711 {
17712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_wxMouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17723 bool arg2 ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "self",(char *) "m_controlDown", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17732 if (SWIG_arg_fail(1)) SWIG_fail;
17733 {
17734 arg2 = (bool)(SWIG_As_bool(obj1));
17735 if (SWIG_arg_fail(2)) SWIG_fail;
17736 }
17737 if (arg1) (arg1)->m_controlDown = arg2;
17738
17739 Py_INCREF(Py_None); resultobj = Py_None;
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_wxMouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17749 bool result;
17750 PyObject * obj0 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 result = (bool) ((arg1)->m_controlDown);
17759
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_wxMouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17772 bool arg2 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self",(char *) "m_shiftDown", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 {
17783 arg2 = (bool)(SWIG_As_bool(obj1));
17784 if (SWIG_arg_fail(2)) SWIG_fail;
17785 }
17786 if (arg1) (arg1)->m_shiftDown = arg2;
17787
17788 Py_INCREF(Py_None); resultobj = Py_None;
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_wxMouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj;
17797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17798 bool result;
17799 PyObject * obj0 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "self", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17806 if (SWIG_arg_fail(1)) SWIG_fail;
17807 result = (bool) ((arg1)->m_shiftDown);
17808
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 static PyObject *_wrap_wxMouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17821 bool arg2 ;
17822 PyObject * obj0 = 0 ;
17823 PyObject * obj1 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "m_altDown", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 {
17832 arg2 = (bool)(SWIG_As_bool(obj1));
17833 if (SWIG_arg_fail(2)) SWIG_fail;
17834 }
17835 if (arg1) (arg1)->m_altDown = arg2;
17836
17837 Py_INCREF(Py_None); resultobj = Py_None;
17838 return resultobj;
17839 fail:
17840 return NULL;
17841 }
17842
17843
17844 static PyObject *_wrap_wxMouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17845 PyObject *resultobj;
17846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17847 bool result;
17848 PyObject * obj0 = 0 ;
17849 char *kwnames[] = {
17850 (char *) "self", NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17855 if (SWIG_arg_fail(1)) SWIG_fail;
17856 result = (bool) ((arg1)->m_altDown);
17857
17858 {
17859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17860 }
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 static PyObject *_wrap_wxMouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17868 PyObject *resultobj;
17869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17870 bool arg2 ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "self",(char *) "m_metaDown", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(1)) SWIG_fail;
17880 {
17881 arg2 = (bool)(SWIG_As_bool(obj1));
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 }
17884 if (arg1) (arg1)->m_metaDown = arg2;
17885
17886 Py_INCREF(Py_None); resultobj = Py_None;
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_wxMouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17896 bool result;
17897 PyObject * obj0 = 0 ;
17898 char *kwnames[] = {
17899 (char *) "self", NULL
17900 };
17901
17902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17904 if (SWIG_arg_fail(1)) SWIG_fail;
17905 result = (bool) ((arg1)->m_metaDown);
17906
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_wxMouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj;
17918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17919 int arg2 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char *kwnames[] = {
17923 (char *) "self",(char *) "m_wheelRotation", NULL
17924 };
17925
17926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17928 if (SWIG_arg_fail(1)) SWIG_fail;
17929 {
17930 arg2 = (int)(SWIG_As_int(obj1));
17931 if (SWIG_arg_fail(2)) SWIG_fail;
17932 }
17933 if (arg1) (arg1)->m_wheelRotation = arg2;
17934
17935 Py_INCREF(Py_None); resultobj = Py_None;
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 static PyObject *_wrap_wxMouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17943 PyObject *resultobj;
17944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17945 int result;
17946 PyObject * obj0 = 0 ;
17947 char *kwnames[] = {
17948 (char *) "self", NULL
17949 };
17950
17951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(1)) SWIG_fail;
17954 result = (int) ((arg1)->m_wheelRotation);
17955
17956 {
17957 resultobj = SWIG_From_int((int)(result));
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_wxMouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17968 int arg2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "self",(char *) "m_wheelDelta", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17977 if (SWIG_arg_fail(1)) SWIG_fail;
17978 {
17979 arg2 = (int)(SWIG_As_int(obj1));
17980 if (SWIG_arg_fail(2)) SWIG_fail;
17981 }
17982 if (arg1) (arg1)->m_wheelDelta = arg2;
17983
17984 Py_INCREF(Py_None); resultobj = Py_None;
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_wxMouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj;
17993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17994 int result;
17995 PyObject * obj0 = 0 ;
17996 char *kwnames[] = {
17997 (char *) "self", NULL
17998 };
17999
18000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18002 if (SWIG_arg_fail(1)) SWIG_fail;
18003 result = (int) ((arg1)->m_wheelDelta);
18004
18005 {
18006 resultobj = SWIG_From_int((int)(result));
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 static PyObject *_wrap_wxMouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj;
18016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18017 int arg2 ;
18018 PyObject * obj0 = 0 ;
18019 PyObject * obj1 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self",(char *) "m_linesPerAction", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 arg2 = (int)(SWIG_As_int(obj1));
18029 if (SWIG_arg_fail(2)) SWIG_fail;
18030 }
18031 if (arg1) (arg1)->m_linesPerAction = arg2;
18032
18033 Py_INCREF(Py_None); resultobj = Py_None;
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_wxMouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj;
18042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18043 int result;
18044 PyObject * obj0 = 0 ;
18045 char *kwnames[] = {
18046 (char *) "self", NULL
18047 };
18048
18049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18051 if (SWIG_arg_fail(1)) SWIG_fail;
18052 result = (int) ((arg1)->m_linesPerAction);
18053
18054 {
18055 resultobj = SWIG_From_int((int)(result));
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject * wxMouseEvent_swigregister(PyObject *, PyObject *args) {
18064 PyObject *obj;
18065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18066 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18067 Py_INCREF(obj);
18068 return Py_BuildValue((char *)"");
18069 }
18070 static PyObject *_wrap_new_wxSetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj;
18072 int arg1 = (int) 0 ;
18073 int arg2 = (int) 0 ;
18074 wxSetCursorEvent *result;
18075 PyObject * obj0 = 0 ;
18076 PyObject * obj1 = 0 ;
18077 char *kwnames[] = {
18078 (char *) "x",(char *) "y", NULL
18079 };
18080
18081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxSetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18082 if (obj0) {
18083 {
18084 arg1 = (int)(SWIG_As_int(obj0));
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 }
18087 }
18088 if (obj1) {
18089 {
18090 arg2 = (int)(SWIG_As_int(obj1));
18091 if (SWIG_arg_fail(2)) SWIG_fail;
18092 }
18093 }
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18097
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 static PyObject *_wrap_wxSetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj;
18110 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18111 int result;
18112 PyObject * obj0 = 0 ;
18113 char *kwnames[] = {
18114 (char *) "self", NULL
18115 };
18116
18117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18119 if (SWIG_arg_fail(1)) SWIG_fail;
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18123
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 {
18128 resultobj = SWIG_From_int((int)(result));
18129 }
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 static PyObject *_wrap_wxSetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj;
18138 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18139 int result;
18140 PyObject * obj0 = 0 ;
18141 char *kwnames[] = {
18142 (char *) "self", NULL
18143 };
18144
18145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18147 if (SWIG_arg_fail(1)) SWIG_fail;
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18151
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 {
18156 resultobj = SWIG_From_int((int)(result));
18157 }
18158 return resultobj;
18159 fail:
18160 return NULL;
18161 }
18162
18163
18164 static PyObject *_wrap_wxSetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18165 PyObject *resultobj;
18166 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18167 wxCursor *arg2 = 0 ;
18168 PyObject * obj0 = 0 ;
18169 PyObject * obj1 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self",(char *) "cursor", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18179 if (SWIG_arg_fail(2)) SWIG_fail;
18180 if (arg2 == NULL) {
18181 SWIG_null_ref("wxCursor");
18182 }
18183 if (SWIG_arg_fail(2)) SWIG_fail;
18184 }
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 (arg1)->SetCursor((wxCursor const &)*arg2);
18188
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 Py_INCREF(Py_None); resultobj = Py_None;
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 static PyObject *_wrap_wxSetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18200 PyObject *resultobj;
18201 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18202 wxCursor *result;
18203 PyObject * obj0 = 0 ;
18204 char *kwnames[] = {
18205 (char *) "self", NULL
18206 };
18207
18208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18210 if (SWIG_arg_fail(1)) SWIG_fail;
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 {
18214 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18215 result = (wxCursor *) &_result_ref;
18216 }
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 wxCursor* resultptr = new wxCursor(*result);
18223 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18224 }
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_wxSetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj;
18233 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18234 bool result;
18235 PyObject * obj0 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18246
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 {
18251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18252 }
18253 return resultobj;
18254 fail:
18255 return NULL;
18256 }
18257
18258
18259 static PyObject * wxSetCursorEvent_swigregister(PyObject *, PyObject *args) {
18260 PyObject *obj;
18261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18262 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18263 Py_INCREF(obj);
18264 return Py_BuildValue((char *)"");
18265 }
18266 static PyObject *_wrap_new_wxKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj;
18268 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18269 wxKeyEvent *result;
18270 PyObject * obj0 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "keyType", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxKeyEvent",kwnames,&obj0)) goto fail;
18276 if (obj0) {
18277 {
18278 arg1 = (wxEventType)(SWIG_As_int(obj0));
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 }
18281 }
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18290 return resultobj;
18291 fail:
18292 return NULL;
18293 }
18294
18295
18296 static PyObject *_wrap_wxKeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18297 PyObject *resultobj;
18298 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18299 bool result;
18300 PyObject * obj0 = 0 ;
18301 char *kwnames[] = {
18302 (char *) "self", NULL
18303 };
18304
18305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18307 if (SWIG_arg_fail(1)) SWIG_fail;
18308 {
18309 PyThreadState* __tstate = wxPyBeginAllowThreads();
18310 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18311
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 {
18316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18317 }
18318 return resultobj;
18319 fail:
18320 return NULL;
18321 }
18322
18323
18324 static PyObject *_wrap_wxKeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj;
18326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18327 bool result;
18328 PyObject * obj0 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "self", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 {
18337 PyThreadState* __tstate = wxPyBeginAllowThreads();
18338 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18339
18340 wxPyEndAllowThreads(__tstate);
18341 if (PyErr_Occurred()) SWIG_fail;
18342 }
18343 {
18344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18345 }
18346 return resultobj;
18347 fail:
18348 return NULL;
18349 }
18350
18351
18352 static PyObject *_wrap_wxKeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18353 PyObject *resultobj;
18354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18355 bool result;
18356 PyObject * obj0 = 0 ;
18357 char *kwnames[] = {
18358 (char *) "self", NULL
18359 };
18360
18361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_AltDown",kwnames,&obj0)) goto fail;
18362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18363 if (SWIG_arg_fail(1)) SWIG_fail;
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18367
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 {
18372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18373 }
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_wxKeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18383 bool result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18395
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 {
18400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18401 }
18402 return resultobj;
18403 fail:
18404 return NULL;
18405 }
18406
18407
18408 static PyObject *_wrap_wxKeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj;
18410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18411 bool result;
18412 PyObject * obj0 = 0 ;
18413 char *kwnames[] = {
18414 (char *) "self", NULL
18415 };
18416
18417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18419 if (SWIG_arg_fail(1)) SWIG_fail;
18420 {
18421 PyThreadState* __tstate = wxPyBeginAllowThreads();
18422 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18423
18424 wxPyEndAllowThreads(__tstate);
18425 if (PyErr_Occurred()) SWIG_fail;
18426 }
18427 {
18428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18429 }
18430 return resultobj;
18431 fail:
18432 return NULL;
18433 }
18434
18435
18436 static PyObject *_wrap_wxKeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18437 PyObject *resultobj;
18438 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18439 bool result;
18440 PyObject * obj0 = 0 ;
18441 char *kwnames[] = {
18442 (char *) "self", NULL
18443 };
18444
18445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18447 if (SWIG_arg_fail(1)) SWIG_fail;
18448 {
18449 PyThreadState* __tstate = wxPyBeginAllowThreads();
18450 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18451
18452 wxPyEndAllowThreads(__tstate);
18453 if (PyErr_Occurred()) SWIG_fail;
18454 }
18455 {
18456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18457 }
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 static PyObject *_wrap_wxKeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18465 PyObject *resultobj;
18466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18467 int result;
18468 PyObject * obj0 = 0 ;
18469 char *kwnames[] = {
18470 (char *) "self", NULL
18471 };
18472
18473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18475 if (SWIG_arg_fail(1)) SWIG_fail;
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18479
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 {
18484 resultobj = SWIG_From_int((int)(result));
18485 }
18486 return resultobj;
18487 fail:
18488 return NULL;
18489 }
18490
18491
18492 static PyObject *_wrap_wxKeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18493 PyObject *resultobj;
18494 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18495 int result;
18496 PyObject * obj0 = 0 ;
18497 char *kwnames[] = {
18498 (char *) "self", NULL
18499 };
18500
18501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18503 if (SWIG_arg_fail(1)) SWIG_fail;
18504 {
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18507
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 {
18512 resultobj = SWIG_From_int((int)(result));
18513 }
18514 return resultobj;
18515 fail:
18516 return NULL;
18517 }
18518
18519
18520 static PyObject *_wrap_wxKeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18521 PyObject *resultobj;
18522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18523 unsigned int result;
18524 PyObject * obj0 = 0 ;
18525 char *kwnames[] = {
18526 (char *) "self", NULL
18527 };
18528
18529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18531 if (SWIG_arg_fail(1)) SWIG_fail;
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18535
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 {
18540 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18541 }
18542 return resultobj;
18543 fail:
18544 return NULL;
18545 }
18546
18547
18548 static PyObject *_wrap_wxKeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18549 PyObject *resultobj;
18550 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18551 unsigned int result;
18552 PyObject * obj0 = 0 ;
18553 char *kwnames[] = {
18554 (char *) "self", NULL
18555 };
18556
18557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18559 if (SWIG_arg_fail(1)) SWIG_fail;
18560 {
18561 PyThreadState* __tstate = wxPyBeginAllowThreads();
18562 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18563
18564 wxPyEndAllowThreads(__tstate);
18565 if (PyErr_Occurred()) SWIG_fail;
18566 }
18567 {
18568 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18569 }
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_wxKeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj;
18578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18579 wxPoint result;
18580 PyObject * obj0 = 0 ;
18581 char *kwnames[] = {
18582 (char *) "self", NULL
18583 };
18584
18585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18587 if (SWIG_arg_fail(1)) SWIG_fail;
18588 {
18589 PyThreadState* __tstate = wxPyBeginAllowThreads();
18590 result = (arg1)->GetPosition();
18591
18592 wxPyEndAllowThreads(__tstate);
18593 if (PyErr_Occurred()) SWIG_fail;
18594 }
18595 {
18596 wxPoint * resultptr;
18597 resultptr = new wxPoint((wxPoint &)(result));
18598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18599 }
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 static PyObject *_wrap_wxKeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj;
18608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18609 long *arg2 = (long *) 0 ;
18610 long *arg3 = (long *) 0 ;
18611 long temp2 ;
18612 int res2 = 0 ;
18613 long temp3 ;
18614 int res3 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 char *kwnames[] = {
18617 (char *) "self", NULL
18618 };
18619
18620 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18621 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18624 if (SWIG_arg_fail(1)) SWIG_fail;
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 (arg1)->GetPosition(arg2,arg3);
18628
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 Py_INCREF(Py_None); resultobj = Py_None;
18633 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18634 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18635 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18636 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 static PyObject *_wrap_wxKeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18644 PyObject *resultobj;
18645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18646 int result;
18647 PyObject * obj0 = 0 ;
18648 char *kwnames[] = {
18649 (char *) "self", NULL
18650 };
18651
18652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetX",kwnames,&obj0)) goto fail;
18653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18654 if (SWIG_arg_fail(1)) SWIG_fail;
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 result = (int)((wxKeyEvent const *)arg1)->GetX();
18658
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 {
18663 resultobj = SWIG_From_int((int)(result));
18664 }
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 static PyObject *_wrap_wxKeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj;
18673 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18674 int result;
18675 PyObject * obj0 = 0 ;
18676 char *kwnames[] = {
18677 (char *) "self", NULL
18678 };
18679
18680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_GetY",kwnames,&obj0)) goto fail;
18681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18682 if (SWIG_arg_fail(1)) SWIG_fail;
18683 {
18684 PyThreadState* __tstate = wxPyBeginAllowThreads();
18685 result = (int)((wxKeyEvent const *)arg1)->GetY();
18686
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 {
18691 resultobj = SWIG_From_int((int)(result));
18692 }
18693 return resultobj;
18694 fail:
18695 return NULL;
18696 }
18697
18698
18699 static PyObject *_wrap_wxKeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18700 PyObject *resultobj;
18701 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18702 int arg2 ;
18703 PyObject * obj0 = 0 ;
18704 PyObject * obj1 = 0 ;
18705 char *kwnames[] = {
18706 (char *) "self",(char *) "m_x", NULL
18707 };
18708
18709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 {
18713 arg2 = (int)(SWIG_As_int(obj1));
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 }
18716 if (arg1) (arg1)->m_x = arg2;
18717
18718 Py_INCREF(Py_None); resultobj = Py_None;
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 static PyObject *_wrap_wxKeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18726 PyObject *resultobj;
18727 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18728 int result;
18729 PyObject * obj0 = 0 ;
18730 char *kwnames[] = {
18731 (char *) "self", NULL
18732 };
18733
18734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18736 if (SWIG_arg_fail(1)) SWIG_fail;
18737 result = (int) ((arg1)->m_x);
18738
18739 {
18740 resultobj = SWIG_From_int((int)(result));
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject *_wrap_wxKeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18751 int arg2 ;
18752 PyObject * obj0 = 0 ;
18753 PyObject * obj1 = 0 ;
18754 char *kwnames[] = {
18755 (char *) "self",(char *) "m_y", NULL
18756 };
18757
18758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 {
18762 arg2 = (int)(SWIG_As_int(obj1));
18763 if (SWIG_arg_fail(2)) SWIG_fail;
18764 }
18765 if (arg1) (arg1)->m_y = arg2;
18766
18767 Py_INCREF(Py_None); resultobj = Py_None;
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_wxKeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18777 int result;
18778 PyObject * obj0 = 0 ;
18779 char *kwnames[] = {
18780 (char *) "self", NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18785 if (SWIG_arg_fail(1)) SWIG_fail;
18786 result = (int) ((arg1)->m_y);
18787
18788 {
18789 resultobj = SWIG_From_int((int)(result));
18790 }
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 static PyObject *_wrap_wxKeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj;
18799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18800 long arg2 ;
18801 PyObject * obj0 = 0 ;
18802 PyObject * obj1 = 0 ;
18803 char *kwnames[] = {
18804 (char *) "self",(char *) "m_keyCode", NULL
18805 };
18806
18807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18809 if (SWIG_arg_fail(1)) SWIG_fail;
18810 {
18811 arg2 = (long)(SWIG_As_long(obj1));
18812 if (SWIG_arg_fail(2)) SWIG_fail;
18813 }
18814 if (arg1) (arg1)->m_keyCode = arg2;
18815
18816 Py_INCREF(Py_None); resultobj = Py_None;
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject *_wrap_wxKeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18826 long result;
18827 PyObject * obj0 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 result = (long) ((arg1)->m_keyCode);
18836
18837 {
18838 resultobj = SWIG_From_long((long)(result));
18839 }
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 static PyObject *_wrap_wxKeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj;
18848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18849 bool arg2 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char *kwnames[] = {
18853 (char *) "self",(char *) "m_controlDown", NULL
18854 };
18855
18856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18858 if (SWIG_arg_fail(1)) SWIG_fail;
18859 {
18860 arg2 = (bool)(SWIG_As_bool(obj1));
18861 if (SWIG_arg_fail(2)) SWIG_fail;
18862 }
18863 if (arg1) (arg1)->m_controlDown = arg2;
18864
18865 Py_INCREF(Py_None); resultobj = Py_None;
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject *_wrap_wxKeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18875 bool result;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 result = (bool) ((arg1)->m_controlDown);
18885
18886 {
18887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_wxKeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18898 bool arg2 ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self",(char *) "m_shiftDown", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 arg2 = (bool)(SWIG_As_bool(obj1));
18910 if (SWIG_arg_fail(2)) SWIG_fail;
18911 }
18912 if (arg1) (arg1)->m_shiftDown = arg2;
18913
18914 Py_INCREF(Py_None); resultobj = Py_None;
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 static PyObject *_wrap_wxKeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj;
18923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18924 bool result;
18925 PyObject * obj0 = 0 ;
18926 char *kwnames[] = {
18927 (char *) "self", NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18932 if (SWIG_arg_fail(1)) SWIG_fail;
18933 result = (bool) ((arg1)->m_shiftDown);
18934
18935 {
18936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18937 }
18938 return resultobj;
18939 fail:
18940 return NULL;
18941 }
18942
18943
18944 static PyObject *_wrap_wxKeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj;
18946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18947 bool arg2 ;
18948 PyObject * obj0 = 0 ;
18949 PyObject * obj1 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "self",(char *) "m_altDown", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18956 if (SWIG_arg_fail(1)) SWIG_fail;
18957 {
18958 arg2 = (bool)(SWIG_As_bool(obj1));
18959 if (SWIG_arg_fail(2)) SWIG_fail;
18960 }
18961 if (arg1) (arg1)->m_altDown = arg2;
18962
18963 Py_INCREF(Py_None); resultobj = Py_None;
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 static PyObject *_wrap_wxKeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj;
18972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18973 bool result;
18974 PyObject * obj0 = 0 ;
18975 char *kwnames[] = {
18976 (char *) "self", NULL
18977 };
18978
18979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 result = (bool) ((arg1)->m_altDown);
18983
18984 {
18985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18986 }
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 static PyObject *_wrap_wxKeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18996 bool arg2 ;
18997 PyObject * obj0 = 0 ;
18998 PyObject * obj1 = 0 ;
18999 char *kwnames[] = {
19000 (char *) "self",(char *) "m_metaDown", NULL
19001 };
19002
19003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19005 if (SWIG_arg_fail(1)) SWIG_fail;
19006 {
19007 arg2 = (bool)(SWIG_As_bool(obj1));
19008 if (SWIG_arg_fail(2)) SWIG_fail;
19009 }
19010 if (arg1) (arg1)->m_metaDown = arg2;
19011
19012 Py_INCREF(Py_None); resultobj = Py_None;
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 static PyObject *_wrap_wxKeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj;
19021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19022 bool result;
19023 PyObject * obj0 = 0 ;
19024 char *kwnames[] = {
19025 (char *) "self", NULL
19026 };
19027
19028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19030 if (SWIG_arg_fail(1)) SWIG_fail;
19031 result = (bool) ((arg1)->m_metaDown);
19032
19033 {
19034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19035 }
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 static PyObject *_wrap_wxKeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj;
19044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19045 bool arg2 ;
19046 PyObject * obj0 = 0 ;
19047 PyObject * obj1 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "self",(char *) "m_scanCode", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 {
19056 arg2 = (bool)(SWIG_As_bool(obj1));
19057 if (SWIG_arg_fail(2)) SWIG_fail;
19058 }
19059 if (arg1) (arg1)->m_scanCode = arg2;
19060
19061 Py_INCREF(Py_None); resultobj = Py_None;
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_wxKeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19071 bool result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "self", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 result = (bool) ((arg1)->m_scanCode);
19081
19082 {
19083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_wxKeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj;
19093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19094 unsigned int arg2 ;
19095 PyObject * obj0 = 0 ;
19096 PyObject * obj1 = 0 ;
19097 char *kwnames[] = {
19098 (char *) "self",(char *) "m_rawCode", NULL
19099 };
19100
19101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19103 if (SWIG_arg_fail(1)) SWIG_fail;
19104 {
19105 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 if (arg1) (arg1)->m_rawCode = arg2;
19109
19110 Py_INCREF(Py_None); resultobj = Py_None;
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_wxKeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19120 unsigned int result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "self", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 result = (unsigned int) ((arg1)->m_rawCode);
19130
19131 {
19132 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19133 }
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 static PyObject *_wrap_wxKeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj;
19142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19143 unsigned int arg2 ;
19144 PyObject * obj0 = 0 ;
19145 PyObject * obj1 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self",(char *) "m_rawFlags", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxKeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19155 if (SWIG_arg_fail(2)) SWIG_fail;
19156 }
19157 if (arg1) (arg1)->m_rawFlags = arg2;
19158
19159 Py_INCREF(Py_None); resultobj = Py_None;
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_wxKeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj;
19168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19169 unsigned int result;
19170 PyObject * obj0 = 0 ;
19171 char *kwnames[] = {
19172 (char *) "self", NULL
19173 };
19174
19175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxKeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19177 if (SWIG_arg_fail(1)) SWIG_fail;
19178 result = (unsigned int) ((arg1)->m_rawFlags);
19179
19180 {
19181 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19182 }
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 static PyObject * wxKeyEvent_swigregister(PyObject *, PyObject *args) {
19190 PyObject *obj;
19191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19192 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19193 Py_INCREF(obj);
19194 return Py_BuildValue((char *)"");
19195 }
19196 static PyObject *_wrap_new_wxSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj;
19198 wxSize const &arg1_defvalue = wxDefaultSize ;
19199 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19200 int arg2 = (int) 0 ;
19201 wxSizeEvent *result;
19202 wxSize temp1 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char *kwnames[] = {
19206 (char *) "sz",(char *) "winid", NULL
19207 };
19208
19209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxSizeEvent",kwnames,&obj0,&obj1)) goto fail;
19210 if (obj0) {
19211 {
19212 arg1 = &temp1;
19213 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19214 }
19215 }
19216 if (obj1) {
19217 {
19218 arg2 = (int)(SWIG_As_int(obj1));
19219 if (SWIG_arg_fail(2)) SWIG_fail;
19220 }
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject *_wrap_wxSizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj;
19238 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19239 wxSize result;
19240 PyObject * obj0 = 0 ;
19241 char *kwnames[] = {
19242 (char *) "self", NULL
19243 };
19244
19245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizeEvent_GetSize",kwnames,&obj0)) goto fail;
19246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = ((wxSizeEvent const *)arg1)->GetSize();
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 wxSize * resultptr;
19257 resultptr = new wxSize((wxSize &)(result));
19258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_wxSizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj;
19268 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19269 wxRect result;
19270 PyObject * obj0 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "self", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizeEvent_GetRect",kwnames,&obj0)) goto fail;
19276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19277 if (SWIG_arg_fail(1)) SWIG_fail;
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = ((wxSizeEvent const *)arg1)->GetRect();
19281
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 wxRect * resultptr;
19287 resultptr = new wxRect((wxRect &)(result));
19288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19289 }
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 static PyObject *_wrap_wxSizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19297 PyObject *resultobj;
19298 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19299 wxRect arg2 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 char *kwnames[] = {
19303 (char *) "self",(char *) "rect", NULL
19304 };
19305
19306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19308 if (SWIG_arg_fail(1)) SWIG_fail;
19309 {
19310 wxRect * argp;
19311 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19312 if (SWIG_arg_fail(2)) SWIG_fail;
19313 if (argp == NULL) {
19314 SWIG_null_ref("wxRect");
19315 }
19316 if (SWIG_arg_fail(2)) SWIG_fail;
19317 arg2 = *argp;
19318 }
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 (arg1)->SetRect(arg2);
19322
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 Py_INCREF(Py_None); resultobj = Py_None;
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_wxSizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj;
19335 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19336 wxSize arg2 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "self",(char *) "size", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 {
19347 wxSize * argp;
19348 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19349 if (SWIG_arg_fail(2)) SWIG_fail;
19350 if (argp == NULL) {
19351 SWIG_null_ref("wxSize");
19352 }
19353 if (SWIG_arg_fail(2)) SWIG_fail;
19354 arg2 = *argp;
19355 }
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 wxSizeEvent_SetSize(arg1,arg2);
19359
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 Py_INCREF(Py_None); resultobj = Py_None;
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_wxSizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj;
19372 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19373 wxSize *arg2 = (wxSize *) 0 ;
19374 PyObject * obj0 = 0 ;
19375 PyObject * obj1 = 0 ;
19376 char *kwnames[] = {
19377 (char *) "self",(char *) "m_size", NULL
19378 };
19379
19380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19382 if (SWIG_arg_fail(1)) SWIG_fail;
19383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19384 if (SWIG_arg_fail(2)) SWIG_fail;
19385 if (arg1) (arg1)->m_size = *arg2;
19386
19387 Py_INCREF(Py_None); resultobj = Py_None;
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 static PyObject *_wrap_wxSizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19397 wxSize *result;
19398 PyObject * obj0 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "self", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19405 if (SWIG_arg_fail(1)) SWIG_fail;
19406 result = (wxSize *)& ((arg1)->m_size);
19407
19408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_wxSizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj;
19417 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19418 wxRect *arg2 = (wxRect *) 0 ;
19419 PyObject * obj0 = 0 ;
19420 PyObject * obj1 = 0 ;
19421 char *kwnames[] = {
19422 (char *) "self",(char *) "m_rect", NULL
19423 };
19424
19425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19427 if (SWIG_arg_fail(1)) SWIG_fail;
19428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19429 if (SWIG_arg_fail(2)) SWIG_fail;
19430 if (arg1) (arg1)->m_rect = *arg2;
19431
19432 Py_INCREF(Py_None); resultobj = Py_None;
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 static PyObject *_wrap_wxSizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj;
19441 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19442 wxRect *result;
19443 PyObject * obj0 = 0 ;
19444 char *kwnames[] = {
19445 (char *) "self", NULL
19446 };
19447
19448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19450 if (SWIG_arg_fail(1)) SWIG_fail;
19451 result = (wxRect *)& ((arg1)->m_rect);
19452
19453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject * wxSizeEvent_swigregister(PyObject *, PyObject *args) {
19461 PyObject *obj;
19462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19463 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19464 Py_INCREF(obj);
19465 return Py_BuildValue((char *)"");
19466 }
19467 static PyObject *_wrap_new_wxMoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19470 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19471 int arg2 = (int) 0 ;
19472 wxMoveEvent *result;
19473 wxPoint temp1 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "pos",(char *) "winid", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxMoveEvent",kwnames,&obj0,&obj1)) goto fail;
19481 if (obj0) {
19482 {
19483 arg1 = &temp1;
19484 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19485 }
19486 }
19487 if (obj1) {
19488 {
19489 arg2 = (int)(SWIG_As_int(obj1));
19490 if (SWIG_arg_fail(2)) SWIG_fail;
19491 }
19492 }
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19496
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 static PyObject *_wrap_wxMoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj;
19509 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19510 wxPoint result;
19511 PyObject * obj0 = 0 ;
19512 char *kwnames[] = {
19513 (char *) "self", NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19518 if (SWIG_arg_fail(1)) SWIG_fail;
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = ((wxMoveEvent const *)arg1)->GetPosition();
19522
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 {
19527 wxPoint * resultptr;
19528 resultptr = new wxPoint((wxPoint &)(result));
19529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19530 }
19531 return resultobj;
19532 fail:
19533 return NULL;
19534 }
19535
19536
19537 static PyObject *_wrap_wxMoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19538 PyObject *resultobj;
19539 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19540 wxRect result;
19541 PyObject * obj0 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "self", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMoveEvent_GetRect",kwnames,&obj0)) goto fail;
19547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19548 if (SWIG_arg_fail(1)) SWIG_fail;
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = ((wxMoveEvent const *)arg1)->GetRect();
19552
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 {
19557 wxRect * resultptr;
19558 resultptr = new wxRect((wxRect &)(result));
19559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19560 }
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 static PyObject *_wrap_wxMoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj;
19569 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19570 wxRect *arg2 = 0 ;
19571 wxRect temp2 ;
19572 PyObject * obj0 = 0 ;
19573 PyObject * obj1 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "self",(char *) "rect", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 {
19582 arg2 = &temp2;
19583 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 (arg1)->SetRect((wxRect const &)*arg2);
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 Py_INCREF(Py_None); resultobj = Py_None;
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_wxMoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19602 wxPoint *arg2 = 0 ;
19603 wxPoint temp2 ;
19604 PyObject * obj0 = 0 ;
19605 PyObject * obj1 = 0 ;
19606 char *kwnames[] = {
19607 (char *) "self",(char *) "pos", NULL
19608 };
19609
19610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19612 if (SWIG_arg_fail(1)) SWIG_fail;
19613 {
19614 arg2 = &temp2;
19615 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19616 }
19617 {
19618 PyThreadState* __tstate = wxPyBeginAllowThreads();
19619 (arg1)->SetPosition((wxPoint const &)*arg2);
19620
19621 wxPyEndAllowThreads(__tstate);
19622 if (PyErr_Occurred()) SWIG_fail;
19623 }
19624 Py_INCREF(Py_None); resultobj = Py_None;
19625 return resultobj;
19626 fail:
19627 return NULL;
19628 }
19629
19630
19631 static PyObject * wxMoveEvent_swigregister(PyObject *, PyObject *args) {
19632 PyObject *obj;
19633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19634 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19635 Py_INCREF(obj);
19636 return Py_BuildValue((char *)"");
19637 }
19638 static PyObject *_wrap_new_wxPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19639 PyObject *resultobj;
19640 int arg1 = (int) 0 ;
19641 wxPaintEvent *result;
19642 PyObject * obj0 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "Id", NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxPaintEvent",kwnames,&obj0)) goto fail;
19648 if (obj0) {
19649 {
19650 arg1 = (int)(SWIG_As_int(obj0));
19651 if (SWIG_arg_fail(1)) SWIG_fail;
19652 }
19653 }
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19657
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19662 return resultobj;
19663 fail:
19664 return NULL;
19665 }
19666
19667
19668 static PyObject * wxPaintEvent_swigregister(PyObject *, PyObject *args) {
19669 PyObject *obj;
19670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19671 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19672 Py_INCREF(obj);
19673 return Py_BuildValue((char *)"");
19674 }
19675 static PyObject *_wrap_new_wxNcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj;
19677 int arg1 = (int) 0 ;
19678 wxNcPaintEvent *result;
19679 PyObject * obj0 = 0 ;
19680 char *kwnames[] = {
19681 (char *) "winid", NULL
19682 };
19683
19684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxNcPaintEvent",kwnames,&obj0)) goto fail;
19685 if (obj0) {
19686 {
19687 arg1 = (int)(SWIG_As_int(obj0));
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 }
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19694
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 static PyObject * wxNcPaintEvent_swigregister(PyObject *, PyObject *args) {
19706 PyObject *obj;
19707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19708 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19709 Py_INCREF(obj);
19710 return Py_BuildValue((char *)"");
19711 }
19712 static PyObject *_wrap_new_wxEraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19713 PyObject *resultobj;
19714 int arg1 = (int) 0 ;
19715 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19716 wxEraseEvent *result;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 char *kwnames[] = {
19720 (char *) "Id",(char *) "dc", NULL
19721 };
19722
19723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxEraseEvent",kwnames,&obj0,&obj1)) goto fail;
19724 if (obj0) {
19725 {
19726 arg1 = (int)(SWIG_As_int(obj0));
19727 if (SWIG_arg_fail(1)) SWIG_fail;
19728 }
19729 }
19730 if (obj1) {
19731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19732 if (SWIG_arg_fail(2)) SWIG_fail;
19733 }
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19737
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19742 return resultobj;
19743 fail:
19744 return NULL;
19745 }
19746
19747
19748 static PyObject *_wrap_wxEraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19749 PyObject *resultobj;
19750 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19751 wxDC *result;
19752 PyObject * obj0 = 0 ;
19753 char *kwnames[] = {
19754 (char *) "self", NULL
19755 };
19756
19757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEraseEvent_GetDC",kwnames,&obj0)) goto fail;
19758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19759 if (SWIG_arg_fail(1)) SWIG_fail;
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19763
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 {
19768 resultobj = wxPyMake_wxObject(result, 0);
19769 }
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 static PyObject * wxEraseEvent_swigregister(PyObject *, PyObject *args) {
19777 PyObject *obj;
19778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19779 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19780 Py_INCREF(obj);
19781 return Py_BuildValue((char *)"");
19782 }
19783 static PyObject *_wrap_new_wxFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19786 int arg2 = (int) 0 ;
19787 wxFocusEvent *result;
19788 PyObject * obj0 = 0 ;
19789 PyObject * obj1 = 0 ;
19790 char *kwnames[] = {
19791 (char *) "type",(char *) "winid", NULL
19792 };
19793
19794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxFocusEvent",kwnames,&obj0,&obj1)) goto fail;
19795 if (obj0) {
19796 {
19797 arg1 = (wxEventType)(SWIG_As_int(obj0));
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 }
19800 }
19801 if (obj1) {
19802 {
19803 arg2 = (int)(SWIG_As_int(obj1));
19804 if (SWIG_arg_fail(2)) SWIG_fail;
19805 }
19806 }
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19810
19811 wxPyEndAllowThreads(__tstate);
19812 if (PyErr_Occurred()) SWIG_fail;
19813 }
19814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 static PyObject *_wrap_wxFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj;
19823 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19824 wxWindow *result;
19825 PyObject * obj0 = 0 ;
19826 char *kwnames[] = {
19827 (char *) "self", NULL
19828 };
19829
19830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19832 if (SWIG_arg_fail(1)) SWIG_fail;
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19836
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = wxPyMake_wxObject(result, 0);
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 static PyObject *_wrap_wxFocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19852 wxWindow *arg2 = (wxWindow *) 0 ;
19853 PyObject * obj0 = 0 ;
19854 PyObject * obj1 = 0 ;
19855 char *kwnames[] = {
19856 (char *) "self",(char *) "win", NULL
19857 };
19858
19859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxFocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19861 if (SWIG_arg_fail(1)) SWIG_fail;
19862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19863 if (SWIG_arg_fail(2)) SWIG_fail;
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 (arg1)->SetWindow(arg2);
19867
19868 wxPyEndAllowThreads(__tstate);
19869 if (PyErr_Occurred()) SWIG_fail;
19870 }
19871 Py_INCREF(Py_None); resultobj = Py_None;
19872 return resultobj;
19873 fail:
19874 return NULL;
19875 }
19876
19877
19878 static PyObject * wxFocusEvent_swigregister(PyObject *, PyObject *args) {
19879 PyObject *obj;
19880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19881 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19882 Py_INCREF(obj);
19883 return Py_BuildValue((char *)"");
19884 }
19885 static PyObject *_wrap_new_wxChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj;
19887 wxWindow *arg1 = (wxWindow *) NULL ;
19888 wxChildFocusEvent *result;
19889 PyObject * obj0 = 0 ;
19890 char *kwnames[] = {
19891 (char *) "win", NULL
19892 };
19893
19894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxChildFocusEvent",kwnames,&obj0)) goto fail;
19895 if (obj0) {
19896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19897 if (SWIG_arg_fail(1)) SWIG_fail;
19898 }
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19902
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19907 return resultobj;
19908 fail:
19909 return NULL;
19910 }
19911
19912
19913 static PyObject *_wrap_wxChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19914 PyObject *resultobj;
19915 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19916 wxWindow *result;
19917 PyObject * obj0 = 0 ;
19918 char *kwnames[] = {
19919 (char *) "self", NULL
19920 };
19921
19922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19924 if (SWIG_arg_fail(1)) SWIG_fail;
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19928
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 {
19933 resultobj = wxPyMake_wxObject(result, 0);
19934 }
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 static PyObject * wxChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19942 PyObject *obj;
19943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19944 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19945 Py_INCREF(obj);
19946 return Py_BuildValue((char *)"");
19947 }
19948 static PyObject *_wrap_new_wxActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19949 PyObject *resultobj;
19950 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19951 bool arg2 = (bool) true ;
19952 int arg3 = (int) 0 ;
19953 wxActivateEvent *result;
19954 PyObject * obj0 = 0 ;
19955 PyObject * obj1 = 0 ;
19956 PyObject * obj2 = 0 ;
19957 char *kwnames[] = {
19958 (char *) "type",(char *) "active",(char *) "Id", NULL
19959 };
19960
19961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_wxActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19962 if (obj0) {
19963 {
19964 arg1 = (wxEventType)(SWIG_As_int(obj0));
19965 if (SWIG_arg_fail(1)) SWIG_fail;
19966 }
19967 }
19968 if (obj1) {
19969 {
19970 arg2 = (bool)(SWIG_As_bool(obj1));
19971 if (SWIG_arg_fail(2)) SWIG_fail;
19972 }
19973 }
19974 if (obj2) {
19975 {
19976 arg3 = (int)(SWIG_As_int(obj2));
19977 if (SWIG_arg_fail(3)) SWIG_fail;
19978 }
19979 }
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19983
19984 wxPyEndAllowThreads(__tstate);
19985 if (PyErr_Occurred()) SWIG_fail;
19986 }
19987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject *_wrap_wxActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj;
19996 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19997 bool result;
19998 PyObject * obj0 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20015 }
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 static PyObject * wxActivateEvent_swigregister(PyObject *, PyObject *args) {
20023 PyObject *obj;
20024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20025 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20026 Py_INCREF(obj);
20027 return Py_BuildValue((char *)"");
20028 }
20029 static PyObject *_wrap_new_wxInitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20030 PyObject *resultobj;
20031 int arg1 = (int) 0 ;
20032 wxInitDialogEvent *result;
20033 PyObject * obj0 = 0 ;
20034 char *kwnames[] = {
20035 (char *) "Id", NULL
20036 };
20037
20038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxInitDialogEvent",kwnames,&obj0)) goto fail;
20039 if (obj0) {
20040 {
20041 arg1 = (int)(SWIG_As_int(obj0));
20042 if (SWIG_arg_fail(1)) SWIG_fail;
20043 }
20044 }
20045 {
20046 PyThreadState* __tstate = wxPyBeginAllowThreads();
20047 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20048
20049 wxPyEndAllowThreads(__tstate);
20050 if (PyErr_Occurred()) SWIG_fail;
20051 }
20052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 static PyObject * wxInitDialogEvent_swigregister(PyObject *, PyObject *args) {
20060 PyObject *obj;
20061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20062 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20063 Py_INCREF(obj);
20064 return Py_BuildValue((char *)"");
20065 }
20066 static PyObject *_wrap_new_wxMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj;
20068 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20069 int arg2 = (int) 0 ;
20070 wxMenu *arg3 = (wxMenu *) NULL ;
20071 wxMenuEvent *result;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 PyObject * obj2 = 0 ;
20075 char *kwnames[] = {
20076 (char *) "type",(char *) "winid",(char *) "menu", NULL
20077 };
20078
20079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_wxMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20080 if (obj0) {
20081 {
20082 arg1 = (wxEventType)(SWIG_As_int(obj0));
20083 if (SWIG_arg_fail(1)) SWIG_fail;
20084 }
20085 }
20086 if (obj1) {
20087 {
20088 arg2 = (int)(SWIG_As_int(obj1));
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 }
20091 }
20092 if (obj2) {
20093 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20094 if (SWIG_arg_fail(3)) SWIG_fail;
20095 }
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20099
20100 wxPyEndAllowThreads(__tstate);
20101 if (PyErr_Occurred()) SWIG_fail;
20102 }
20103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20104 return resultobj;
20105 fail:
20106 return NULL;
20107 }
20108
20109
20110 static PyObject *_wrap_wxMenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20111 PyObject *resultobj;
20112 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20113 int result;
20114 PyObject * obj0 = 0 ;
20115 char *kwnames[] = {
20116 (char *) "self", NULL
20117 };
20118
20119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20121 if (SWIG_arg_fail(1)) SWIG_fail;
20122 {
20123 PyThreadState* __tstate = wxPyBeginAllowThreads();
20124 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20125
20126 wxPyEndAllowThreads(__tstate);
20127 if (PyErr_Occurred()) SWIG_fail;
20128 }
20129 {
20130 resultobj = SWIG_From_int((int)(result));
20131 }
20132 return resultobj;
20133 fail:
20134 return NULL;
20135 }
20136
20137
20138 static PyObject *_wrap_wxMenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20139 PyObject *resultobj;
20140 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20141 bool result;
20142 PyObject * obj0 = 0 ;
20143 char *kwnames[] = {
20144 (char *) "self", NULL
20145 };
20146
20147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 {
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20153
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 {
20158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20159 }
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_wxMenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20169 wxMenu *result;
20170 PyObject * obj0 = 0 ;
20171 char *kwnames[] = {
20172 (char *) "self", NULL
20173 };
20174
20175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20177 if (SWIG_arg_fail(1)) SWIG_fail;
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20181
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 {
20186 resultobj = wxPyMake_wxObject(result, 0);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 static PyObject * wxMenuEvent_swigregister(PyObject *, PyObject *args) {
20195 PyObject *obj;
20196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20197 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20198 Py_INCREF(obj);
20199 return Py_BuildValue((char *)"");
20200 }
20201 static PyObject *_wrap_new_wxCloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20202 PyObject *resultobj;
20203 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20204 int arg2 = (int) 0 ;
20205 wxCloseEvent *result;
20206 PyObject * obj0 = 0 ;
20207 PyObject * obj1 = 0 ;
20208 char *kwnames[] = {
20209 (char *) "type",(char *) "winid", NULL
20210 };
20211
20212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxCloseEvent",kwnames,&obj0,&obj1)) goto fail;
20213 if (obj0) {
20214 {
20215 arg1 = (wxEventType)(SWIG_As_int(obj0));
20216 if (SWIG_arg_fail(1)) SWIG_fail;
20217 }
20218 }
20219 if (obj1) {
20220 {
20221 arg2 = (int)(SWIG_As_int(obj1));
20222 if (SWIG_arg_fail(2)) SWIG_fail;
20223 }
20224 }
20225 {
20226 PyThreadState* __tstate = wxPyBeginAllowThreads();
20227 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_wxCloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20242 bool arg2 ;
20243 PyObject * obj0 = 0 ;
20244 PyObject * obj1 = 0 ;
20245 char *kwnames[] = {
20246 (char *) "self",(char *) "logOff", NULL
20247 };
20248
20249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxCloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20251 if (SWIG_arg_fail(1)) SWIG_fail;
20252 {
20253 arg2 = (bool)(SWIG_As_bool(obj1));
20254 if (SWIG_arg_fail(2)) SWIG_fail;
20255 }
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 (arg1)->SetLoggingOff(arg2);
20259
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 Py_INCREF(Py_None); resultobj = Py_None;
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject *_wrap_wxCloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20271 PyObject *resultobj;
20272 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20273 bool result;
20274 PyObject * obj0 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 {
20290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20291 }
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_wxCloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20301 bool arg2 = (bool) true ;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "self",(char *) "veto", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxCloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20310 if (SWIG_arg_fail(1)) SWIG_fail;
20311 if (obj1) {
20312 {
20313 arg2 = (bool)(SWIG_As_bool(obj1));
20314 if (SWIG_arg_fail(2)) SWIG_fail;
20315 }
20316 }
20317 {
20318 PyThreadState* __tstate = wxPyBeginAllowThreads();
20319 (arg1)->Veto(arg2);
20320
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 Py_INCREF(Py_None); resultobj = Py_None;
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 static PyObject *_wrap_wxCloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20332 PyObject *resultobj;
20333 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20334 bool arg2 ;
20335 PyObject * obj0 = 0 ;
20336 PyObject * obj1 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "self",(char *) "canVeto", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxCloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 {
20345 arg2 = (bool)(SWIG_As_bool(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 (arg1)->SetCanVeto(arg2);
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 Py_INCREF(Py_None); resultobj = Py_None;
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 static PyObject *_wrap_wxCloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj;
20364 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20365 bool result;
20366 PyObject * obj0 = 0 ;
20367 char *kwnames[] = {
20368 (char *) "self", NULL
20369 };
20370
20371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20373 if (SWIG_arg_fail(1)) SWIG_fail;
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20377
20378 wxPyEndAllowThreads(__tstate);
20379 if (PyErr_Occurred()) SWIG_fail;
20380 }
20381 {
20382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20383 }
20384 return resultobj;
20385 fail:
20386 return NULL;
20387 }
20388
20389
20390 static PyObject *_wrap_wxCloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20391 PyObject *resultobj;
20392 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20393 bool result;
20394 PyObject * obj0 = 0 ;
20395 char *kwnames[] = {
20396 (char *) "self", NULL
20397 };
20398
20399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxCloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20401 if (SWIG_arg_fail(1)) SWIG_fail;
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20405
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 {
20410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20411 }
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject * wxCloseEvent_swigregister(PyObject *, PyObject *args) {
20419 PyObject *obj;
20420 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20421 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20422 Py_INCREF(obj);
20423 return Py_BuildValue((char *)"");
20424 }
20425 static PyObject *_wrap_new_wxShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj;
20427 int arg1 = (int) 0 ;
20428 bool arg2 = (bool) false ;
20429 wxShowEvent *result;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "winid",(char *) "show", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxShowEvent",kwnames,&obj0,&obj1)) goto fail;
20437 if (obj0) {
20438 {
20439 arg1 = (int)(SWIG_As_int(obj0));
20440 if (SWIG_arg_fail(1)) SWIG_fail;
20441 }
20442 }
20443 if (obj1) {
20444 {
20445 arg2 = (bool)(SWIG_As_bool(obj1));
20446 if (SWIG_arg_fail(2)) SWIG_fail;
20447 }
20448 }
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20452
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_wxShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20466 bool arg2 ;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "self",(char *) "show", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(1)) SWIG_fail;
20476 {
20477 arg2 = (bool)(SWIG_As_bool(obj1));
20478 if (SWIG_arg_fail(2)) SWIG_fail;
20479 }
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 (arg1)->SetShow(arg2);
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 Py_INCREF(Py_None); resultobj = Py_None;
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_wxShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj;
20496 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20497 bool result;
20498 PyObject * obj0 = 0 ;
20499 char *kwnames[] = {
20500 (char *) "self", NULL
20501 };
20502
20503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxShowEvent_GetShow",kwnames,&obj0)) goto fail;
20504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20505 if (SWIG_arg_fail(1)) SWIG_fail;
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20509
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 {
20514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20515 }
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 static PyObject * wxShowEvent_swigregister(PyObject *, PyObject *args) {
20523 PyObject *obj;
20524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20525 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20526 Py_INCREF(obj);
20527 return Py_BuildValue((char *)"");
20528 }
20529 static PyObject *_wrap_new_wxIconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj;
20531 int arg1 = (int) 0 ;
20532 bool arg2 = (bool) true ;
20533 wxIconizeEvent *result;
20534 PyObject * obj0 = 0 ;
20535 PyObject * obj1 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "id",(char *) "iconized", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxIconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20541 if (obj0) {
20542 {
20543 arg1 = (int)(SWIG_As_int(obj0));
20544 if (SWIG_arg_fail(1)) SWIG_fail;
20545 }
20546 }
20547 if (obj1) {
20548 {
20549 arg2 = (bool)(SWIG_As_bool(obj1));
20550 if (SWIG_arg_fail(2)) SWIG_fail;
20551 }
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20556
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_wxIconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj;
20569 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20570 bool result;
20571 PyObject * obj0 = 0 ;
20572 char *kwnames[] = {
20573 (char *) "self", NULL
20574 };
20575
20576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (bool)(arg1)->Iconized();
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 static PyObject * wxIconizeEvent_swigregister(PyObject *, PyObject *args) {
20596 PyObject *obj;
20597 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20598 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20599 Py_INCREF(obj);
20600 return Py_BuildValue((char *)"");
20601 }
20602 static PyObject *_wrap_new_wxMaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20603 PyObject *resultobj;
20604 int arg1 = (int) 0 ;
20605 wxMaximizeEvent *result;
20606 PyObject * obj0 = 0 ;
20607 char *kwnames[] = {
20608 (char *) "id", NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxMaximizeEvent",kwnames,&obj0)) goto fail;
20612 if (obj0) {
20613 {
20614 arg1 = (int)(SWIG_As_int(obj0));
20615 if (SWIG_arg_fail(1)) SWIG_fail;
20616 }
20617 }
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20621
20622 wxPyEndAllowThreads(__tstate);
20623 if (PyErr_Occurred()) SWIG_fail;
20624 }
20625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 static PyObject * wxMaximizeEvent_swigregister(PyObject *, PyObject *args) {
20633 PyObject *obj;
20634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20635 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20636 Py_INCREF(obj);
20637 return Py_BuildValue((char *)"");
20638 }
20639 static PyObject *_wrap_wxDropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj;
20641 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20642 wxPoint result;
20643 PyObject * obj0 = 0 ;
20644 char *kwnames[] = {
20645 (char *) "self", NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxDropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20650 if (SWIG_arg_fail(1)) SWIG_fail;
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (arg1)->GetPosition();
20654
20655 wxPyEndAllowThreads(__tstate);
20656 if (PyErr_Occurred()) SWIG_fail;
20657 }
20658 {
20659 wxPoint * resultptr;
20660 resultptr = new wxPoint((wxPoint &)(result));
20661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20662 }
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 static PyObject *_wrap_wxDropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj;
20671 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20672 int result;
20673 PyObject * obj0 = 0 ;
20674 char *kwnames[] = {
20675 (char *) "self", NULL
20676 };
20677
20678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxDropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20680 if (SWIG_arg_fail(1)) SWIG_fail;
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (int)(arg1)->GetNumberOfFiles();
20684
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 resultobj = SWIG_From_int((int)(result));
20690 }
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 static PyObject *_wrap_wxDropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20698 PyObject *resultobj;
20699 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20700 PyObject *result;
20701 PyObject * obj0 = 0 ;
20702 char *kwnames[] = {
20703 (char *) "self", NULL
20704 };
20705
20706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxDropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20708 if (SWIG_arg_fail(1)) SWIG_fail;
20709 {
20710 PyThreadState* __tstate = wxPyBeginAllowThreads();
20711 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20712
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 resultobj = result;
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 static PyObject * wxDropFilesEvent_swigregister(PyObject *, PyObject *args) {
20724 PyObject *obj;
20725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20726 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20727 Py_INCREF(obj);
20728 return Py_BuildValue((char *)"");
20729 }
20730 static PyObject *_wrap_new_wxUpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20731 PyObject *resultobj;
20732 int arg1 = (int) 0 ;
20733 wxUpdateUIEvent *result;
20734 PyObject * obj0 = 0 ;
20735 char *kwnames[] = {
20736 (char *) "commandId", NULL
20737 };
20738
20739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxUpdateUIEvent",kwnames,&obj0)) goto fail;
20740 if (obj0) {
20741 {
20742 arg1 = (int)(SWIG_As_int(obj0));
20743 if (SWIG_arg_fail(1)) SWIG_fail;
20744 }
20745 }
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20749
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 static PyObject *_wrap_wxUpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20761 PyObject *resultobj;
20762 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20763 bool result;
20764 PyObject * obj0 = 0 ;
20765 char *kwnames[] = {
20766 (char *) "self", NULL
20767 };
20768
20769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20771 if (SWIG_arg_fail(1)) SWIG_fail;
20772 {
20773 PyThreadState* __tstate = wxPyBeginAllowThreads();
20774 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20775
20776 wxPyEndAllowThreads(__tstate);
20777 if (PyErr_Occurred()) SWIG_fail;
20778 }
20779 {
20780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20781 }
20782 return resultobj;
20783 fail:
20784 return NULL;
20785 }
20786
20787
20788 static PyObject *_wrap_wxUpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20789 PyObject *resultobj;
20790 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20791 bool result;
20792 PyObject * obj0 = 0 ;
20793 char *kwnames[] = {
20794 (char *) "self", NULL
20795 };
20796
20797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20799 if (SWIG_arg_fail(1)) SWIG_fail;
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20803
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 static PyObject *_wrap_wxUpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj;
20818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20819 wxString result;
20820 PyObject * obj0 = 0 ;
20821 char *kwnames[] = {
20822 (char *) "self", NULL
20823 };
20824
20825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20827 if (SWIG_arg_fail(1)) SWIG_fail;
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20831
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 {
20836 #if wxUSE_UNICODE
20837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20838 #else
20839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20840 #endif
20841 }
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 static PyObject *_wrap_wxUpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj;
20850 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20851 bool result;
20852 PyObject * obj0 = 0 ;
20853 char *kwnames[] = {
20854 (char *) "self", NULL
20855 };
20856
20857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20863
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 {
20868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20869 }
20870 return resultobj;
20871 fail:
20872 return NULL;
20873 }
20874
20875
20876 static PyObject *_wrap_wxUpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20877 PyObject *resultobj;
20878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20879 bool result;
20880 PyObject * obj0 = 0 ;
20881 char *kwnames[] = {
20882 (char *) "self", NULL
20883 };
20884
20885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20887 if (SWIG_arg_fail(1)) SWIG_fail;
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20891
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 {
20896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20897 }
20898 return resultobj;
20899 fail:
20900 return NULL;
20901 }
20902
20903
20904 static PyObject *_wrap_wxUpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20905 PyObject *resultobj;
20906 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20907 bool result;
20908 PyObject * obj0 = 0 ;
20909 char *kwnames[] = {
20910 (char *) "self", NULL
20911 };
20912
20913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20915 if (SWIG_arg_fail(1)) SWIG_fail;
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20919
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 {
20924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20925 }
20926 return resultobj;
20927 fail:
20928 return NULL;
20929 }
20930
20931
20932 static PyObject *_wrap_wxUpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20933 PyObject *resultobj;
20934 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20935 bool arg2 ;
20936 PyObject * obj0 = 0 ;
20937 PyObject * obj1 = 0 ;
20938 char *kwnames[] = {
20939 (char *) "self",(char *) "check", NULL
20940 };
20941
20942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxUpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20944 if (SWIG_arg_fail(1)) SWIG_fail;
20945 {
20946 arg2 = (bool)(SWIG_As_bool(obj1));
20947 if (SWIG_arg_fail(2)) SWIG_fail;
20948 }
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 (arg1)->Check(arg2);
20952
20953 wxPyEndAllowThreads(__tstate);
20954 if (PyErr_Occurred()) SWIG_fail;
20955 }
20956 Py_INCREF(Py_None); resultobj = Py_None;
20957 return resultobj;
20958 fail:
20959 return NULL;
20960 }
20961
20962
20963 static PyObject *_wrap_wxUpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20964 PyObject *resultobj;
20965 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20966 bool arg2 ;
20967 PyObject * obj0 = 0 ;
20968 PyObject * obj1 = 0 ;
20969 char *kwnames[] = {
20970 (char *) "self",(char *) "enable", NULL
20971 };
20972
20973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxUpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20975 if (SWIG_arg_fail(1)) SWIG_fail;
20976 {
20977 arg2 = (bool)(SWIG_As_bool(obj1));
20978 if (SWIG_arg_fail(2)) SWIG_fail;
20979 }
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 (arg1)->Enable(arg2);
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 Py_INCREF(Py_None); resultobj = Py_None;
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_wxUpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20997 wxString *arg2 = 0 ;
20998 bool temp2 = false ;
20999 PyObject * obj0 = 0 ;
21000 PyObject * obj1 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self",(char *) "text", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxUpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 arg2 = wxString_in_helper(obj1);
21010 if (arg2 == NULL) SWIG_fail;
21011 temp2 = true;
21012 }
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 (arg1)->SetText((wxString const &)*arg2);
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 Py_INCREF(Py_None); resultobj = Py_None;
21021 {
21022 if (temp2)
21023 delete arg2;
21024 }
21025 return resultobj;
21026 fail:
21027 {
21028 if (temp2)
21029 delete arg2;
21030 }
21031 return NULL;
21032 }
21033
21034
21035 static PyObject *_wrap_wxUpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21036 PyObject *resultobj;
21037 long arg1 ;
21038 PyObject * obj0 = 0 ;
21039 char *kwnames[] = {
21040 (char *) "updateInterval", NULL
21041 };
21042
21043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21044 {
21045 arg1 = (long)(SWIG_As_long(obj0));
21046 if (SWIG_arg_fail(1)) SWIG_fail;
21047 }
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 wxUpdateUIEvent::SetUpdateInterval(arg1);
21051
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 Py_INCREF(Py_None); resultobj = Py_None;
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 static PyObject *_wrap_wxUpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21063 PyObject *resultobj;
21064 long result;
21065 char *kwnames[] = {
21066 NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxUpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21073
21074 wxPyEndAllowThreads(__tstate);
21075 if (PyErr_Occurred()) SWIG_fail;
21076 }
21077 {
21078 resultobj = SWIG_From_long((long)(result));
21079 }
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 static PyObject *_wrap_wxUpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj;
21088 wxWindow *arg1 = (wxWindow *) 0 ;
21089 bool result;
21090 PyObject * obj0 = 0 ;
21091 char *kwnames[] = {
21092 (char *) "win", NULL
21093 };
21094
21095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21097 if (SWIG_arg_fail(1)) SWIG_fail;
21098 {
21099 PyThreadState* __tstate = wxPyBeginAllowThreads();
21100 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21101
21102 wxPyEndAllowThreads(__tstate);
21103 if (PyErr_Occurred()) SWIG_fail;
21104 }
21105 {
21106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21107 }
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 static PyObject *_wrap_wxUpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21115 PyObject *resultobj;
21116 char *kwnames[] = {
21117 NULL
21118 };
21119
21120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxUpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21121 {
21122 PyThreadState* __tstate = wxPyBeginAllowThreads();
21123 wxUpdateUIEvent::ResetUpdateTime();
21124
21125 wxPyEndAllowThreads(__tstate);
21126 if (PyErr_Occurred()) SWIG_fail;
21127 }
21128 Py_INCREF(Py_None); resultobj = Py_None;
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_wxUpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21136 PyObject *resultobj;
21137 wxUpdateUIMode arg1 ;
21138 PyObject * obj0 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "mode", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxUpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21144 {
21145 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21146 if (SWIG_arg_fail(1)) SWIG_fail;
21147 }
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21151
21152 wxPyEndAllowThreads(__tstate);
21153 if (PyErr_Occurred()) SWIG_fail;
21154 }
21155 Py_INCREF(Py_None); resultobj = Py_None;
21156 return resultobj;
21157 fail:
21158 return NULL;
21159 }
21160
21161
21162 static PyObject *_wrap_wxUpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21163 PyObject *resultobj;
21164 wxUpdateUIMode result;
21165 char *kwnames[] = {
21166 NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxUpdateUIEvent_GetMode",kwnames)) goto fail;
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 resultobj = SWIG_From_int((result));
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 static PyObject * wxUpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21185 PyObject *obj;
21186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21187 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21188 Py_INCREF(obj);
21189 return Py_BuildValue((char *)"");
21190 }
21191 static PyObject *_wrap_new_wxSysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21192 PyObject *resultobj;
21193 wxSysColourChangedEvent *result;
21194 char *kwnames[] = {
21195 NULL
21196 };
21197
21198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxSysColourChangedEvent",kwnames)) goto fail;
21199 {
21200 PyThreadState* __tstate = wxPyBeginAllowThreads();
21201 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21202
21203 wxPyEndAllowThreads(__tstate);
21204 if (PyErr_Occurred()) SWIG_fail;
21205 }
21206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21207 return resultobj;
21208 fail:
21209 return NULL;
21210 }
21211
21212
21213 static PyObject * wxSysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21214 PyObject *obj;
21215 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21216 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21217 Py_INCREF(obj);
21218 return Py_BuildValue((char *)"");
21219 }
21220 static PyObject *_wrap_new_wxMouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21221 PyObject *resultobj;
21222 int arg1 = (int) 0 ;
21223 wxWindow *arg2 = (wxWindow *) NULL ;
21224 wxMouseCaptureChangedEvent *result;
21225 PyObject * obj0 = 0 ;
21226 PyObject * obj1 = 0 ;
21227 char *kwnames[] = {
21228 (char *) "winid",(char *) "gainedCapture", NULL
21229 };
21230
21231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxMouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21232 if (obj0) {
21233 {
21234 arg1 = (int)(SWIG_As_int(obj0));
21235 if (SWIG_arg_fail(1)) SWIG_fail;
21236 }
21237 }
21238 if (obj1) {
21239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21240 if (SWIG_arg_fail(2)) SWIG_fail;
21241 }
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21245
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21250 return resultobj;
21251 fail:
21252 return NULL;
21253 }
21254
21255
21256 static PyObject *_wrap_wxMouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21257 PyObject *resultobj;
21258 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21259 wxWindow *result;
21260 PyObject * obj0 = 0 ;
21261 char *kwnames[] = {
21262 (char *) "self", NULL
21263 };
21264
21265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21267 if (SWIG_arg_fail(1)) SWIG_fail;
21268 {
21269 PyThreadState* __tstate = wxPyBeginAllowThreads();
21270 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21271
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 {
21276 resultobj = wxPyMake_wxObject(result, 0);
21277 }
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 static PyObject * wxMouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21285 PyObject *obj;
21286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21287 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21288 Py_INCREF(obj);
21289 return Py_BuildValue((char *)"");
21290 }
21291 static PyObject *_wrap_new_wxDisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21292 PyObject *resultobj;
21293 wxDisplayChangedEvent *result;
21294 char *kwnames[] = {
21295 NULL
21296 };
21297
21298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxDisplayChangedEvent",kwnames)) goto fail;
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject * wxDisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21314 PyObject *obj;
21315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21316 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21317 Py_INCREF(obj);
21318 return Py_BuildValue((char *)"");
21319 }
21320 static PyObject *_wrap_new_wxPaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21321 PyObject *resultobj;
21322 int arg1 = (int) 0 ;
21323 wxPaletteChangedEvent *result;
21324 PyObject * obj0 = 0 ;
21325 char *kwnames[] = {
21326 (char *) "id", NULL
21327 };
21328
21329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxPaletteChangedEvent",kwnames,&obj0)) goto fail;
21330 if (obj0) {
21331 {
21332 arg1 = (int)(SWIG_As_int(obj0));
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject *_wrap_wxPaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21351 PyObject *resultobj;
21352 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21353 wxWindow *arg2 = (wxWindow *) 0 ;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 char *kwnames[] = {
21357 (char *) "self",(char *) "win", NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21362 if (SWIG_arg_fail(1)) SWIG_fail;
21363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21364 if (SWIG_arg_fail(2)) SWIG_fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 (arg1)->SetChangedWindow(arg2);
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 Py_INCREF(Py_None); resultobj = Py_None;
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 static PyObject *_wrap_wxPaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21380 PyObject *resultobj;
21381 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21382 wxWindow *result;
21383 PyObject * obj0 = 0 ;
21384 char *kwnames[] = {
21385 (char *) "self", NULL
21386 };
21387
21388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21390 if (SWIG_arg_fail(1)) SWIG_fail;
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (wxWindow *)(arg1)->GetChangedWindow();
21394
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = wxPyMake_wxObject(result, 0);
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 static PyObject * wxPaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21408 PyObject *obj;
21409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21410 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21411 Py_INCREF(obj);
21412 return Py_BuildValue((char *)"");
21413 }
21414 static PyObject *_wrap_new_wxQueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21415 PyObject *resultobj;
21416 int arg1 = (int) 0 ;
21417 wxQueryNewPaletteEvent *result;
21418 PyObject * obj0 = 0 ;
21419 char *kwnames[] = {
21420 (char *) "winid", NULL
21421 };
21422
21423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxQueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21424 if (obj0) {
21425 {
21426 arg1 = (int)(SWIG_As_int(obj0));
21427 if (SWIG_arg_fail(1)) SWIG_fail;
21428 }
21429 }
21430 {
21431 PyThreadState* __tstate = wxPyBeginAllowThreads();
21432 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21433
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 static PyObject *_wrap_wxQueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21445 PyObject *resultobj;
21446 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21447 bool arg2 ;
21448 PyObject * obj0 = 0 ;
21449 PyObject * obj1 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self",(char *) "realized", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxQueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 {
21458 arg2 = (bool)(SWIG_As_bool(obj1));
21459 if (SWIG_arg_fail(2)) SWIG_fail;
21460 }
21461 {
21462 PyThreadState* __tstate = wxPyBeginAllowThreads();
21463 (arg1)->SetPaletteRealized(arg2);
21464
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 Py_INCREF(Py_None); resultobj = Py_None;
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject *_wrap_wxQueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj;
21477 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21478 bool result;
21479 PyObject * obj0 = 0 ;
21480 char *kwnames[] = {
21481 (char *) "self", NULL
21482 };
21483
21484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxQueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21486 if (SWIG_arg_fail(1)) SWIG_fail;
21487 {
21488 PyThreadState* __tstate = wxPyBeginAllowThreads();
21489 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21490
21491 wxPyEndAllowThreads(__tstate);
21492 if (PyErr_Occurred()) SWIG_fail;
21493 }
21494 {
21495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21496 }
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 static PyObject * wxQueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21504 PyObject *obj;
21505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21506 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21507 Py_INCREF(obj);
21508 return Py_BuildValue((char *)"");
21509 }
21510 static PyObject *_wrap_new_wxNavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxNavigationKeyEvent *result;
21513 char *kwnames[] = {
21514 NULL
21515 };
21516
21517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxNavigationKeyEvent",kwnames)) goto fail;
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 static PyObject *_wrap_wxNavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj;
21534 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21535 bool result;
21536 PyObject * obj0 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "self", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21543 if (SWIG_arg_fail(1)) SWIG_fail;
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 {
21552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21553 }
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 static PyObject *_wrap_wxNavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj;
21562 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21563 bool arg2 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 char *kwnames[] = {
21567 (char *) "self",(char *) "forward", NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxNavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21572 if (SWIG_arg_fail(1)) SWIG_fail;
21573 {
21574 arg2 = (bool)(SWIG_As_bool(obj1));
21575 if (SWIG_arg_fail(2)) SWIG_fail;
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 (arg1)->SetDirection(arg2);
21580
21581 wxPyEndAllowThreads(__tstate);
21582 if (PyErr_Occurred()) SWIG_fail;
21583 }
21584 Py_INCREF(Py_None); resultobj = Py_None;
21585 return resultobj;
21586 fail:
21587 return NULL;
21588 }
21589
21590
21591 static PyObject *_wrap_wxNavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21592 PyObject *resultobj;
21593 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21594 bool result;
21595 PyObject * obj0 = 0 ;
21596 char *kwnames[] = {
21597 (char *) "self", NULL
21598 };
21599
21600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21602 if (SWIG_arg_fail(1)) SWIG_fail;
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 {
21611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21612 }
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_wxNavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21622 bool arg2 ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 char *kwnames[] = {
21626 (char *) "self",(char *) "ischange", NULL
21627 };
21628
21629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxNavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 {
21633 arg2 = (bool)(SWIG_As_bool(obj1));
21634 if (SWIG_arg_fail(2)) SWIG_fail;
21635 }
21636 {
21637 PyThreadState* __tstate = wxPyBeginAllowThreads();
21638 (arg1)->SetWindowChange(arg2);
21639
21640 wxPyEndAllowThreads(__tstate);
21641 if (PyErr_Occurred()) SWIG_fail;
21642 }
21643 Py_INCREF(Py_None); resultobj = Py_None;
21644 return resultobj;
21645 fail:
21646 return NULL;
21647 }
21648
21649
21650 static PyObject *_wrap_wxNavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21651 PyObject *resultobj;
21652 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21653 bool result;
21654 PyObject * obj0 = 0 ;
21655 char *kwnames[] = {
21656 (char *) "self", NULL
21657 };
21658
21659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21661 if (SWIG_arg_fail(1)) SWIG_fail;
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21665
21666 wxPyEndAllowThreads(__tstate);
21667 if (PyErr_Occurred()) SWIG_fail;
21668 }
21669 {
21670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21671 }
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_wxNavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj;
21680 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21681 bool arg2 ;
21682 PyObject * obj0 = 0 ;
21683 PyObject * obj1 = 0 ;
21684 char *kwnames[] = {
21685 (char *) "self",(char *) "bIs", NULL
21686 };
21687
21688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxNavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21690 if (SWIG_arg_fail(1)) SWIG_fail;
21691 {
21692 arg2 = (bool)(SWIG_As_bool(obj1));
21693 if (SWIG_arg_fail(2)) SWIG_fail;
21694 }
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 (arg1)->SetFromTab(arg2);
21698
21699 wxPyEndAllowThreads(__tstate);
21700 if (PyErr_Occurred()) SWIG_fail;
21701 }
21702 Py_INCREF(Py_None); resultobj = Py_None;
21703 return resultobj;
21704 fail:
21705 return NULL;
21706 }
21707
21708
21709 static PyObject *_wrap_wxNavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21710 PyObject *resultobj;
21711 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21712 long arg2 ;
21713 PyObject * obj0 = 0 ;
21714 PyObject * obj1 = 0 ;
21715 char *kwnames[] = {
21716 (char *) "self",(char *) "flags", NULL
21717 };
21718
21719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxNavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21721 if (SWIG_arg_fail(1)) SWIG_fail;
21722 {
21723 arg2 = (long)(SWIG_As_long(obj1));
21724 if (SWIG_arg_fail(2)) SWIG_fail;
21725 }
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 (arg1)->SetFlags(arg2);
21729
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 Py_INCREF(Py_None); resultobj = Py_None;
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 static PyObject *_wrap_wxNavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21741 PyObject *resultobj;
21742 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21743 wxWindow *result;
21744 PyObject * obj0 = 0 ;
21745 char *kwnames[] = {
21746 (char *) "self", NULL
21747 };
21748
21749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxNavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21751 if (SWIG_arg_fail(1)) SWIG_fail;
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21755
21756 wxPyEndAllowThreads(__tstate);
21757 if (PyErr_Occurred()) SWIG_fail;
21758 }
21759 {
21760 resultobj = wxPyMake_wxObject(result, 0);
21761 }
21762 return resultobj;
21763 fail:
21764 return NULL;
21765 }
21766
21767
21768 static PyObject *_wrap_wxNavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21769 PyObject *resultobj;
21770 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21771 wxWindow *arg2 = (wxWindow *) 0 ;
21772 PyObject * obj0 = 0 ;
21773 PyObject * obj1 = 0 ;
21774 char *kwnames[] = {
21775 (char *) "self",(char *) "win", NULL
21776 };
21777
21778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxNavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21780 if (SWIG_arg_fail(1)) SWIG_fail;
21781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21782 if (SWIG_arg_fail(2)) SWIG_fail;
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 (arg1)->SetCurrentFocus(arg2);
21786
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 Py_INCREF(Py_None); resultobj = Py_None;
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 static PyObject * wxNavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21798 PyObject *obj;
21799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21800 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21801 Py_INCREF(obj);
21802 return Py_BuildValue((char *)"");
21803 }
21804 static PyObject *_wrap_new_wxWindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21805 PyObject *resultobj;
21806 wxWindow *arg1 = (wxWindow *) NULL ;
21807 wxWindowCreateEvent *result;
21808 PyObject * obj0 = 0 ;
21809 char *kwnames[] = {
21810 (char *) "win", NULL
21811 };
21812
21813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxWindowCreateEvent",kwnames,&obj0)) goto fail;
21814 if (obj0) {
21815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 }
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_wxWindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21835 wxWindow *result;
21836 PyObject * obj0 = 0 ;
21837 char *kwnames[] = {
21838 (char *) "self", NULL
21839 };
21840
21841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21847
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 {
21852 resultobj = wxPyMake_wxObject(result, 0);
21853 }
21854 return resultobj;
21855 fail:
21856 return NULL;
21857 }
21858
21859
21860 static PyObject * wxWindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21861 PyObject *obj;
21862 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21863 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21864 Py_INCREF(obj);
21865 return Py_BuildValue((char *)"");
21866 }
21867 static PyObject *_wrap_new_wxWindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21868 PyObject *resultobj;
21869 wxWindow *arg1 = (wxWindow *) NULL ;
21870 wxWindowDestroyEvent *result;
21871 PyObject * obj0 = 0 ;
21872 char *kwnames[] = {
21873 (char *) "win", NULL
21874 };
21875
21876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxWindowDestroyEvent",kwnames,&obj0)) goto fail;
21877 if (obj0) {
21878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21879 if (SWIG_arg_fail(1)) SWIG_fail;
21880 }
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21884
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21889 return resultobj;
21890 fail:
21891 return NULL;
21892 }
21893
21894
21895 static PyObject *_wrap_wxWindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21896 PyObject *resultobj;
21897 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21898 wxWindow *result;
21899 PyObject * obj0 = 0 ;
21900 char *kwnames[] = {
21901 (char *) "self", NULL
21902 };
21903
21904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21906 if (SWIG_arg_fail(1)) SWIG_fail;
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21910
21911 wxPyEndAllowThreads(__tstate);
21912 if (PyErr_Occurred()) SWIG_fail;
21913 }
21914 {
21915 resultobj = wxPyMake_wxObject(result, 0);
21916 }
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 static PyObject * wxWindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21924 PyObject *obj;
21925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21926 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21927 Py_INCREF(obj);
21928 return Py_BuildValue((char *)"");
21929 }
21930 static PyObject *_wrap_new_wxContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21931 PyObject *resultobj;
21932 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21933 int arg2 = (int) 0 ;
21934 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21935 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21936 wxContextMenuEvent *result;
21937 wxPoint temp3 ;
21938 PyObject * obj0 = 0 ;
21939 PyObject * obj1 = 0 ;
21940 PyObject * obj2 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "type",(char *) "winid",(char *) "pt", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_wxContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21946 if (obj0) {
21947 {
21948 arg1 = (wxEventType)(SWIG_As_int(obj0));
21949 if (SWIG_arg_fail(1)) SWIG_fail;
21950 }
21951 }
21952 if (obj1) {
21953 {
21954 arg2 = (int)(SWIG_As_int(obj1));
21955 if (SWIG_arg_fail(2)) SWIG_fail;
21956 }
21957 }
21958 if (obj2) {
21959 {
21960 arg3 = &temp3;
21961 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21962 }
21963 }
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21967
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21972 return resultobj;
21973 fail:
21974 return NULL;
21975 }
21976
21977
21978 static PyObject *_wrap_wxContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj;
21980 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21981 wxPoint *result;
21982 PyObject * obj0 = 0 ;
21983 char *kwnames[] = {
21984 (char *) "self", NULL
21985 };
21986
21987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21989 if (SWIG_arg_fail(1)) SWIG_fail;
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 {
21993 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21994 result = (wxPoint *) &_result_ref;
21995 }
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22001 return resultobj;
22002 fail:
22003 return NULL;
22004 }
22005
22006
22007 static PyObject *_wrap_wxContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22008 PyObject *resultobj;
22009 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22010 wxPoint *arg2 = 0 ;
22011 wxPoint temp2 ;
22012 PyObject * obj0 = 0 ;
22013 PyObject * obj1 = 0 ;
22014 char *kwnames[] = {
22015 (char *) "self",(char *) "pos", NULL
22016 };
22017
22018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22020 if (SWIG_arg_fail(1)) SWIG_fail;
22021 {
22022 arg2 = &temp2;
22023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22024 }
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 (arg1)->SetPosition((wxPoint const &)*arg2);
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 Py_INCREF(Py_None); resultobj = Py_None;
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 static PyObject * wxContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22040 PyObject *obj;
22041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22042 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22043 Py_INCREF(obj);
22044 return Py_BuildValue((char *)"");
22045 }
22046 static PyObject *_wrap_new_wxIdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxIdleEvent *result;
22049 char *kwnames[] = {
22050 NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxIdleEvent",kwnames)) goto fail;
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (wxIdleEvent *)new wxIdleEvent();
22057
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 static PyObject *_wrap_wxIdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22069 PyObject *resultobj;
22070 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22071 bool arg2 = (bool) true ;
22072 PyObject * obj0 = 0 ;
22073 PyObject * obj1 = 0 ;
22074 char *kwnames[] = {
22075 (char *) "self",(char *) "needMore", NULL
22076 };
22077
22078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxIdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(1)) SWIG_fail;
22081 if (obj1) {
22082 {
22083 arg2 = (bool)(SWIG_As_bool(obj1));
22084 if (SWIG_arg_fail(2)) SWIG_fail;
22085 }
22086 }
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 (arg1)->RequestMore(arg2);
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 Py_INCREF(Py_None); resultobj = Py_None;
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject *_wrap_wxIdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj;
22103 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22104 bool result;
22105 PyObject * obj0 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22116
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22122 }
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 static PyObject *_wrap_wxIdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22130 PyObject *resultobj;
22131 wxIdleMode arg1 ;
22132 PyObject * obj0 = 0 ;
22133 char *kwnames[] = {
22134 (char *) "mode", NULL
22135 };
22136
22137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIdleEvent_SetMode",kwnames,&obj0)) goto fail;
22138 {
22139 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22140 if (SWIG_arg_fail(1)) SWIG_fail;
22141 }
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 wxIdleEvent::SetMode((wxIdleMode )arg1);
22145
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 Py_INCREF(Py_None); resultobj = Py_None;
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 static PyObject *_wrap_wxIdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22157 PyObject *resultobj;
22158 wxIdleMode result;
22159 char *kwnames[] = {
22160 NULL
22161 };
22162
22163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxIdleEvent_GetMode",kwnames)) goto fail;
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (wxIdleMode)wxIdleEvent::GetMode();
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_From_int((result));
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_wxIdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj;
22180 wxWindow *arg1 = (wxWindow *) 0 ;
22181 bool result;
22182 PyObject * obj0 = 0 ;
22183 char *kwnames[] = {
22184 (char *) "win", NULL
22185 };
22186
22187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIdleEvent_CanSend",kwnames,&obj0)) goto fail;
22188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22189 if (SWIG_arg_fail(1)) SWIG_fail;
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 result = (bool)wxIdleEvent::CanSend(arg1);
22193
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22199 }
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 static PyObject * wxIdleEvent_swigregister(PyObject *, PyObject *args) {
22207 PyObject *obj;
22208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22209 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22210 Py_INCREF(obj);
22211 return Py_BuildValue((char *)"");
22212 }
22213 static PyObject *_wrap_new_wxPyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22214 PyObject *resultobj;
22215 int arg1 = (int) 0 ;
22216 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22217 wxPyEvent *result;
22218 PyObject * obj0 = 0 ;
22219 PyObject * obj1 = 0 ;
22220 char *kwnames[] = {
22221 (char *) "winid",(char *) "commandType", NULL
22222 };
22223
22224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxPyEvent",kwnames,&obj0,&obj1)) goto fail;
22225 if (obj0) {
22226 {
22227 arg1 = (int)(SWIG_As_int(obj0));
22228 if (SWIG_arg_fail(1)) SWIG_fail;
22229 }
22230 }
22231 if (obj1) {
22232 {
22233 arg2 = (wxEventType)(SWIG_As_int(obj1));
22234 if (SWIG_arg_fail(2)) SWIG_fail;
22235 }
22236 }
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_delete_wxPyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22254 PyObject * obj0 = 0 ;
22255 char *kwnames[] = {
22256 (char *) "self", NULL
22257 };
22258
22259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxPyEvent",kwnames,&obj0)) goto fail;
22260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22261 if (SWIG_arg_fail(1)) SWIG_fail;
22262 {
22263 PyThreadState* __tstate = wxPyBeginAllowThreads();
22264 delete arg1;
22265
22266 wxPyEndAllowThreads(__tstate);
22267 if (PyErr_Occurred()) SWIG_fail;
22268 }
22269 Py_INCREF(Py_None); resultobj = Py_None;
22270 return resultobj;
22271 fail:
22272 return NULL;
22273 }
22274
22275
22276 static PyObject *_wrap_wxPyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22277 PyObject *resultobj;
22278 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22279 PyObject *arg2 = (PyObject *) 0 ;
22280 PyObject * obj0 = 0 ;
22281 PyObject * obj1 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "self",(char *) "self", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(1)) SWIG_fail;
22289 arg2 = obj1;
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 (arg1)->SetSelf(arg2);
22293
22294 wxPyEndAllowThreads(__tstate);
22295 if (PyErr_Occurred()) SWIG_fail;
22296 }
22297 Py_INCREF(Py_None); resultobj = Py_None;
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_wxPyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22307 PyObject *result;
22308 PyObject * obj0 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "self", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyEvent_GetSelf",kwnames,&obj0)) goto fail;
22314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = (PyObject *)(arg1)->GetSelf();
22319
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 resultobj = result;
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 static PyObject * wxPyEvent_swigregister(PyObject *, PyObject *args) {
22331 PyObject *obj;
22332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22333 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22334 Py_INCREF(obj);
22335 return Py_BuildValue((char *)"");
22336 }
22337 static PyObject *_wrap_new_wxPyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22338 PyObject *resultobj;
22339 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22340 int arg2 = (int) 0 ;
22341 wxPyCommandEvent *result;
22342 PyObject * obj0 = 0 ;
22343 PyObject * obj1 = 0 ;
22344 char *kwnames[] = {
22345 (char *) "commandType",(char *) "id", NULL
22346 };
22347
22348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxPyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22349 if (obj0) {
22350 {
22351 arg1 = (wxEventType)(SWIG_As_int(obj0));
22352 if (SWIG_arg_fail(1)) SWIG_fail;
22353 }
22354 }
22355 if (obj1) {
22356 {
22357 arg2 = (int)(SWIG_As_int(obj1));
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 }
22360 }
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22364
22365 wxPyEndAllowThreads(__tstate);
22366 if (PyErr_Occurred()) SWIG_fail;
22367 }
22368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 static PyObject *_wrap_delete_wxPyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22376 PyObject *resultobj;
22377 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22378 PyObject * obj0 = 0 ;
22379 char *kwnames[] = {
22380 (char *) "self", NULL
22381 };
22382
22383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxPyCommandEvent",kwnames,&obj0)) goto fail;
22384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(1)) SWIG_fail;
22386 {
22387 PyThreadState* __tstate = wxPyBeginAllowThreads();
22388 delete arg1;
22389
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 Py_INCREF(Py_None); resultobj = Py_None;
22394 return resultobj;
22395 fail:
22396 return NULL;
22397 }
22398
22399
22400 static PyObject *_wrap_wxPyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22401 PyObject *resultobj;
22402 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22403 PyObject *arg2 = (PyObject *) 0 ;
22404 PyObject * obj0 = 0 ;
22405 PyObject * obj1 = 0 ;
22406 char *kwnames[] = {
22407 (char *) "self",(char *) "self", NULL
22408 };
22409
22410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22412 if (SWIG_arg_fail(1)) SWIG_fail;
22413 arg2 = obj1;
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 (arg1)->SetSelf(arg2);
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 Py_INCREF(Py_None); resultobj = Py_None;
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_wxPyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22431 PyObject *result;
22432 PyObject * obj0 = 0 ;
22433 char *kwnames[] = {
22434 (char *) "self", NULL
22435 };
22436
22437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22439 if (SWIG_arg_fail(1)) SWIG_fail;
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 result = (PyObject *)(arg1)->GetSelf();
22443
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 resultobj = result;
22448 return resultobj;
22449 fail:
22450 return NULL;
22451 }
22452
22453
22454 static PyObject * wxPyCommandEvent_swigregister(PyObject *, PyObject *args) {
22455 PyObject *obj;
22456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22457 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22458 Py_INCREF(obj);
22459 return Py_BuildValue((char *)"");
22460 }
22461 static PyObject *_wrap_new_wxDateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxWindow *arg1 = (wxWindow *) 0 ;
22464 wxDateTime *arg2 = 0 ;
22465 wxEventType arg3 ;
22466 wxDateEvent *result;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 PyObject * obj2 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "win",(char *) "dt",(char *) "type", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_wxDateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 {
22478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22479 if (SWIG_arg_fail(2)) SWIG_fail;
22480 if (arg2 == NULL) {
22481 SWIG_null_ref("wxDateTime");
22482 }
22483 if (SWIG_arg_fail(2)) SWIG_fail;
22484 }
22485 {
22486 arg3 = (wxEventType)(SWIG_As_int(obj2));
22487 if (SWIG_arg_fail(3)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_wxDateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22506 wxDateTime *result;
22507 PyObject * obj0 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "self", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxDateEvent_GetDate",kwnames,&obj0)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 {
22518 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22519 result = (wxDateTime *) &_result_ref;
22520 }
22521
22522 wxPyEndAllowThreads(__tstate);
22523 if (PyErr_Occurred()) SWIG_fail;
22524 }
22525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22526 return resultobj;
22527 fail:
22528 return NULL;
22529 }
22530
22531
22532 static PyObject *_wrap_wxDateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22533 PyObject *resultobj;
22534 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22535 wxDateTime *arg2 = 0 ;
22536 PyObject * obj0 = 0 ;
22537 PyObject * obj1 = 0 ;
22538 char *kwnames[] = {
22539 (char *) "self",(char *) "date", NULL
22540 };
22541
22542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxDateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22544 if (SWIG_arg_fail(1)) SWIG_fail;
22545 {
22546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 if (arg2 == NULL) {
22549 SWIG_null_ref("wxDateTime");
22550 }
22551 if (SWIG_arg_fail(2)) SWIG_fail;
22552 }
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 (arg1)->SetDate((wxDateTime const &)*arg2);
22556
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 Py_INCREF(Py_None); resultobj = Py_None;
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 static PyObject * wxDateEvent_swigregister(PyObject *, PyObject *args) {
22568 PyObject *obj;
22569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22570 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22571 Py_INCREF(obj);
22572 return Py_BuildValue((char *)"");
22573 }
22574 static PyObject *_wrap_new_wxPyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22575 PyObject *resultobj;
22576 wxPyApp *result;
22577 char *kwnames[] = {
22578 NULL
22579 };
22580
22581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxPyApp",kwnames)) goto fail;
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 result = (wxPyApp *)new_wxPyApp();
22585
22586 wxPyEndAllowThreads(__tstate);
22587 if (PyErr_Occurred()) SWIG_fail;
22588 }
22589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22590 return resultobj;
22591 fail:
22592 return NULL;
22593 }
22594
22595
22596 static PyObject *_wrap_delete_wxPyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22597 PyObject *resultobj;
22598 wxPyApp *arg1 = (wxPyApp *) 0 ;
22599 PyObject * obj0 = 0 ;
22600 char *kwnames[] = {
22601 (char *) "self", NULL
22602 };
22603
22604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxPyApp",kwnames,&obj0)) goto fail;
22605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22606 if (SWIG_arg_fail(1)) SWIG_fail;
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 delete arg1;
22610
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 Py_INCREF(Py_None); resultobj = Py_None;
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 static PyObject *_wrap_wxPyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj;
22623 wxPyApp *arg1 = (wxPyApp *) 0 ;
22624 PyObject *arg2 = (PyObject *) 0 ;
22625 PyObject *arg3 = (PyObject *) 0 ;
22626 PyObject * obj0 = 0 ;
22627 PyObject * obj1 = 0 ;
22628 PyObject * obj2 = 0 ;
22629 char *kwnames[] = {
22630 (char *) "self",(char *) "self",(char *) "_class", NULL
22631 };
22632
22633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxPyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22635 if (SWIG_arg_fail(1)) SWIG_fail;
22636 arg2 = obj1;
22637 arg3 = obj2;
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 (arg1)->_setCallbackInfo(arg2,arg3);
22641
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 Py_INCREF(Py_None); resultobj = Py_None;
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 static PyObject *_wrap_wxPyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22653 PyObject *resultobj;
22654 wxPyApp *arg1 = (wxPyApp *) 0 ;
22655 wxString result;
22656 PyObject * obj0 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetAppName",kwnames,&obj0)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 result = ((wxPyApp const *)arg1)->GetAppName();
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 {
22672 #if wxUSE_UNICODE
22673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22674 #else
22675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22676 #endif
22677 }
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 static PyObject *_wrap_wxPyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj;
22686 wxPyApp *arg1 = (wxPyApp *) 0 ;
22687 wxString *arg2 = 0 ;
22688 bool temp2 = false ;
22689 PyObject * obj0 = 0 ;
22690 PyObject * obj1 = 0 ;
22691 char *kwnames[] = {
22692 (char *) "self",(char *) "name", NULL
22693 };
22694
22695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22697 if (SWIG_arg_fail(1)) SWIG_fail;
22698 {
22699 arg2 = wxString_in_helper(obj1);
22700 if (arg2 == NULL) SWIG_fail;
22701 temp2 = true;
22702 }
22703 {
22704 PyThreadState* __tstate = wxPyBeginAllowThreads();
22705 (arg1)->SetAppName((wxString const &)*arg2);
22706
22707 wxPyEndAllowThreads(__tstate);
22708 if (PyErr_Occurred()) SWIG_fail;
22709 }
22710 Py_INCREF(Py_None); resultobj = Py_None;
22711 {
22712 if (temp2)
22713 delete arg2;
22714 }
22715 return resultobj;
22716 fail:
22717 {
22718 if (temp2)
22719 delete arg2;
22720 }
22721 return NULL;
22722 }
22723
22724
22725 static PyObject *_wrap_wxPyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj;
22727 wxPyApp *arg1 = (wxPyApp *) 0 ;
22728 wxString result;
22729 PyObject * obj0 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetClassName",kwnames,&obj0)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = ((wxPyApp const *)arg1)->GetClassName();
22740
22741 wxPyEndAllowThreads(__tstate);
22742 if (PyErr_Occurred()) SWIG_fail;
22743 }
22744 {
22745 #if wxUSE_UNICODE
22746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22747 #else
22748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22749 #endif
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 static PyObject *_wrap_wxPyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22758 PyObject *resultobj;
22759 wxPyApp *arg1 = (wxPyApp *) 0 ;
22760 wxString *arg2 = 0 ;
22761 bool temp2 = false ;
22762 PyObject * obj0 = 0 ;
22763 PyObject * obj1 = 0 ;
22764 char *kwnames[] = {
22765 (char *) "self",(char *) "name", NULL
22766 };
22767
22768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(1)) SWIG_fail;
22771 {
22772 arg2 = wxString_in_helper(obj1);
22773 if (arg2 == NULL) SWIG_fail;
22774 temp2 = true;
22775 }
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 (arg1)->SetClassName((wxString const &)*arg2);
22779
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 Py_INCREF(Py_None); resultobj = Py_None;
22784 {
22785 if (temp2)
22786 delete arg2;
22787 }
22788 return resultobj;
22789 fail:
22790 {
22791 if (temp2)
22792 delete arg2;
22793 }
22794 return NULL;
22795 }
22796
22797
22798 static PyObject *_wrap_wxPyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj;
22800 wxPyApp *arg1 = (wxPyApp *) 0 ;
22801 wxString *result;
22802 PyObject * obj0 = 0 ;
22803 char *kwnames[] = {
22804 (char *) "self", NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetVendorName",kwnames,&obj0)) goto fail;
22808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22809 if (SWIG_arg_fail(1)) SWIG_fail;
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 {
22813 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22814 result = (wxString *) &_result_ref;
22815 }
22816
22817 wxPyEndAllowThreads(__tstate);
22818 if (PyErr_Occurred()) SWIG_fail;
22819 }
22820 {
22821 #if wxUSE_UNICODE
22822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22823 #else
22824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22825 #endif
22826 }
22827 return resultobj;
22828 fail:
22829 return NULL;
22830 }
22831
22832
22833 static PyObject *_wrap_wxPyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22834 PyObject *resultobj;
22835 wxPyApp *arg1 = (wxPyApp *) 0 ;
22836 wxString *arg2 = 0 ;
22837 bool temp2 = false ;
22838 PyObject * obj0 = 0 ;
22839 PyObject * obj1 = 0 ;
22840 char *kwnames[] = {
22841 (char *) "self",(char *) "name", NULL
22842 };
22843
22844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22846 if (SWIG_arg_fail(1)) SWIG_fail;
22847 {
22848 arg2 = wxString_in_helper(obj1);
22849 if (arg2 == NULL) SWIG_fail;
22850 temp2 = true;
22851 }
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 (arg1)->SetVendorName((wxString const &)*arg2);
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 Py_INCREF(Py_None); resultobj = Py_None;
22860 {
22861 if (temp2)
22862 delete arg2;
22863 }
22864 return resultobj;
22865 fail:
22866 {
22867 if (temp2)
22868 delete arg2;
22869 }
22870 return NULL;
22871 }
22872
22873
22874 static PyObject *_wrap_wxPyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj;
22876 wxPyApp *arg1 = (wxPyApp *) 0 ;
22877 wxAppTraits *result;
22878 PyObject * obj0 = 0 ;
22879 char *kwnames[] = {
22880 (char *) "self", NULL
22881 };
22882
22883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetTraits",kwnames,&obj0)) goto fail;
22884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22885 if (SWIG_arg_fail(1)) SWIG_fail;
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 result = (wxAppTraits *)(arg1)->GetTraits();
22889
22890 wxPyEndAllowThreads(__tstate);
22891 if (PyErr_Occurred()) SWIG_fail;
22892 }
22893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 static PyObject *_wrap_wxPyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22901 PyObject *resultobj;
22902 wxPyApp *arg1 = (wxPyApp *) 0 ;
22903 PyObject * obj0 = 0 ;
22904 char *kwnames[] = {
22905 (char *) "self", NULL
22906 };
22907
22908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(1)) SWIG_fail;
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 (arg1)->ProcessPendingEvents();
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 Py_INCREF(Py_None); resultobj = Py_None;
22919 return resultobj;
22920 fail:
22921 return NULL;
22922 }
22923
22924
22925 static PyObject *_wrap_wxPyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22926 PyObject *resultobj;
22927 wxPyApp *arg1 = (wxPyApp *) 0 ;
22928 bool arg2 = (bool) false ;
22929 bool result;
22930 PyObject * obj0 = 0 ;
22931 PyObject * obj1 = 0 ;
22932 char *kwnames[] = {
22933 (char *) "self",(char *) "onlyIfNeeded", NULL
22934 };
22935
22936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxPyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22938 if (SWIG_arg_fail(1)) SWIG_fail;
22939 if (obj1) {
22940 {
22941 arg2 = (bool)(SWIG_As_bool(obj1));
22942 if (SWIG_arg_fail(2)) SWIG_fail;
22943 }
22944 }
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = (bool)(arg1)->Yield(arg2);
22948
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 {
22953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22954 }
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 static PyObject *_wrap_wxPyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22962 PyObject *resultobj;
22963 wxPyApp *arg1 = (wxPyApp *) 0 ;
22964 PyObject * obj0 = 0 ;
22965 char *kwnames[] = {
22966 (char *) "self", NULL
22967 };
22968
22969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22971 if (SWIG_arg_fail(1)) SWIG_fail;
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 (arg1)->WakeUpIdle();
22975
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 Py_INCREF(Py_None); resultobj = Py_None;
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 static PyObject *_wrap_wxPyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22987 PyObject *resultobj;
22988 bool result;
22989 char *kwnames[] = {
22990 NULL
22991 };
22992
22993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_IsMainLoopRunning",kwnames)) goto fail;
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (bool)wxPyApp::IsMainLoopRunning();
22997
22998 wxPyEndAllowThreads(__tstate);
22999 if (PyErr_Occurred()) SWIG_fail;
23000 }
23001 {
23002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23003 }
23004 return resultobj;
23005 fail:
23006 return NULL;
23007 }
23008
23009
23010 static PyObject *_wrap_wxPyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23011 PyObject *resultobj;
23012 wxPyApp *arg1 = (wxPyApp *) 0 ;
23013 int result;
23014 PyObject * obj0 = 0 ;
23015 char *kwnames[] = {
23016 (char *) "self", NULL
23017 };
23018
23019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_MainLoop",kwnames,&obj0)) goto fail;
23020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23021 if (SWIG_arg_fail(1)) SWIG_fail;
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 result = (int)(arg1)->MainLoop();
23025
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 {
23030 resultobj = SWIG_From_int((int)(result));
23031 }
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 static PyObject *_wrap_wxPyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23039 PyObject *resultobj;
23040 wxPyApp *arg1 = (wxPyApp *) 0 ;
23041 PyObject * obj0 = 0 ;
23042 char *kwnames[] = {
23043 (char *) "self", NULL
23044 };
23045
23046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_Exit",kwnames,&obj0)) goto fail;
23047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23048 if (SWIG_arg_fail(1)) SWIG_fail;
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 (arg1)->Exit();
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 Py_INCREF(Py_None); resultobj = Py_None;
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 static PyObject *_wrap_wxPyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23064 PyObject *resultobj;
23065 wxPyApp *arg1 = (wxPyApp *) 0 ;
23066 PyObject * obj0 = 0 ;
23067 char *kwnames[] = {
23068 (char *) "self", NULL
23069 };
23070
23071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23073 if (SWIG_arg_fail(1)) SWIG_fail;
23074 {
23075 PyThreadState* __tstate = wxPyBeginAllowThreads();
23076 (arg1)->ExitMainLoop();
23077
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 Py_INCREF(Py_None); resultobj = Py_None;
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 static PyObject *_wrap_wxPyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23089 PyObject *resultobj;
23090 wxPyApp *arg1 = (wxPyApp *) 0 ;
23091 bool result;
23092 PyObject * obj0 = 0 ;
23093 char *kwnames[] = {
23094 (char *) "self", NULL
23095 };
23096
23097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_Pending",kwnames,&obj0)) goto fail;
23098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23099 if (SWIG_arg_fail(1)) SWIG_fail;
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (bool)(arg1)->Pending();
23103
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 {
23108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23109 }
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 static PyObject *_wrap_wxPyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23117 PyObject *resultobj;
23118 wxPyApp *arg1 = (wxPyApp *) 0 ;
23119 bool result;
23120 PyObject * obj0 = 0 ;
23121 char *kwnames[] = {
23122 (char *) "self", NULL
23123 };
23124
23125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_Dispatch",kwnames,&obj0)) goto fail;
23126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23127 if (SWIG_arg_fail(1)) SWIG_fail;
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (bool)(arg1)->Dispatch();
23131
23132 wxPyEndAllowThreads(__tstate);
23133 if (PyErr_Occurred()) SWIG_fail;
23134 }
23135 {
23136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23137 }
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 static PyObject *_wrap_wxPyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23145 PyObject *resultobj;
23146 wxPyApp *arg1 = (wxPyApp *) 0 ;
23147 bool result;
23148 PyObject * obj0 = 0 ;
23149 char *kwnames[] = {
23150 (char *) "self", NULL
23151 };
23152
23153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23155 if (SWIG_arg_fail(1)) SWIG_fail;
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (bool)(arg1)->ProcessIdle();
23159
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 {
23164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23165 }
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 static PyObject *_wrap_wxPyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23173 PyObject *resultobj;
23174 wxPyApp *arg1 = (wxPyApp *) 0 ;
23175 wxWindow *arg2 = (wxWindow *) 0 ;
23176 wxIdleEvent *arg3 = 0 ;
23177 bool result;
23178 PyObject * obj0 = 0 ;
23179 PyObject * obj1 = 0 ;
23180 PyObject * obj2 = 0 ;
23181 char *kwnames[] = {
23182 (char *) "self",(char *) "win",(char *) "event", NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxPyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(1)) SWIG_fail;
23188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23189 if (SWIG_arg_fail(2)) SWIG_fail;
23190 {
23191 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23192 if (SWIG_arg_fail(3)) SWIG_fail;
23193 if (arg3 == NULL) {
23194 SWIG_null_ref("wxIdleEvent");
23195 }
23196 if (SWIG_arg_fail(3)) SWIG_fail;
23197 }
23198 {
23199 PyThreadState* __tstate = wxPyBeginAllowThreads();
23200 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23201
23202 wxPyEndAllowThreads(__tstate);
23203 if (PyErr_Occurred()) SWIG_fail;
23204 }
23205 {
23206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23207 }
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 static PyObject *_wrap_wxPyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23215 PyObject *resultobj;
23216 wxPyApp *arg1 = (wxPyApp *) 0 ;
23217 bool result;
23218 PyObject * obj0 = 0 ;
23219 char *kwnames[] = {
23220 (char *) "self", NULL
23221 };
23222
23223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_IsActive",kwnames,&obj0)) goto fail;
23224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23225 if (SWIG_arg_fail(1)) SWIG_fail;
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (bool)((wxPyApp const *)arg1)->IsActive();
23229
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23235 }
23236 return resultobj;
23237 fail:
23238 return NULL;
23239 }
23240
23241
23242 static PyObject *_wrap_wxPyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23243 PyObject *resultobj;
23244 wxPyApp *arg1 = (wxPyApp *) 0 ;
23245 wxWindow *arg2 = (wxWindow *) 0 ;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 char *kwnames[] = {
23249 (char *) "self",(char *) "win", NULL
23250 };
23251
23252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23254 if (SWIG_arg_fail(1)) SWIG_fail;
23255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(2)) SWIG_fail;
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 (arg1)->SetTopWindow(arg2);
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 Py_INCREF(Py_None); resultobj = Py_None;
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 static PyObject *_wrap_wxPyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23272 PyObject *resultobj;
23273 wxPyApp *arg1 = (wxPyApp *) 0 ;
23274 wxWindow *result;
23275 PyObject * obj0 = 0 ;
23276 char *kwnames[] = {
23277 (char *) "self", NULL
23278 };
23279
23280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23282 if (SWIG_arg_fail(1)) SWIG_fail;
23283 {
23284 PyThreadState* __tstate = wxPyBeginAllowThreads();
23285 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23286
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 {
23291 resultobj = wxPyMake_wxObject(result, 0);
23292 }
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 static PyObject *_wrap_wxPyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj;
23301 wxPyApp *arg1 = (wxPyApp *) 0 ;
23302 bool arg2 ;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char *kwnames[] = {
23306 (char *) "self",(char *) "flag", NULL
23307 };
23308
23309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23311 if (SWIG_arg_fail(1)) SWIG_fail;
23312 {
23313 arg2 = (bool)(SWIG_As_bool(obj1));
23314 if (SWIG_arg_fail(2)) SWIG_fail;
23315 }
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 (arg1)->SetExitOnFrameDelete(arg2);
23319
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 Py_INCREF(Py_None); resultobj = Py_None;
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_wxPyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 wxPyApp *arg1 = (wxPyApp *) 0 ;
23333 bool result;
23334 PyObject * obj0 = 0 ;
23335 char *kwnames[] = {
23336 (char *) "self", NULL
23337 };
23338
23339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(1)) SWIG_fail;
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 {
23350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23351 }
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 static PyObject *_wrap_wxPyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23359 PyObject *resultobj;
23360 wxPyApp *arg1 = (wxPyApp *) 0 ;
23361 bool arg2 ;
23362 PyObject * obj0 = 0 ;
23363 PyObject * obj1 = 0 ;
23364 char *kwnames[] = {
23365 (char *) "self",(char *) "flag", NULL
23366 };
23367
23368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23370 if (SWIG_arg_fail(1)) SWIG_fail;
23371 {
23372 arg2 = (bool)(SWIG_As_bool(obj1));
23373 if (SWIG_arg_fail(2)) SWIG_fail;
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 (arg1)->SetUseBestVisual(arg2);
23378
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 Py_INCREF(Py_None); resultobj = Py_None;
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 static PyObject *_wrap_wxPyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj;
23391 wxPyApp *arg1 = (wxPyApp *) 0 ;
23392 bool result;
23393 PyObject * obj0 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "self", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23400 if (SWIG_arg_fail(1)) SWIG_fail;
23401 {
23402 PyThreadState* __tstate = wxPyBeginAllowThreads();
23403 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23404
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 {
23409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23410 }
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 static PyObject *_wrap_wxPyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 wxPyApp *arg1 = (wxPyApp *) 0 ;
23420 int arg2 ;
23421 PyObject * obj0 = 0 ;
23422 PyObject * obj1 = 0 ;
23423 char *kwnames[] = {
23424 (char *) "self",(char *) "mode", NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23429 if (SWIG_arg_fail(1)) SWIG_fail;
23430 {
23431 arg2 = (int)(SWIG_As_int(obj1));
23432 if (SWIG_arg_fail(2)) SWIG_fail;
23433 }
23434 {
23435 PyThreadState* __tstate = wxPyBeginAllowThreads();
23436 (arg1)->SetPrintMode(arg2);
23437
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 Py_INCREF(Py_None); resultobj = Py_None;
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 static PyObject *_wrap_wxPyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj;
23450 wxPyApp *arg1 = (wxPyApp *) 0 ;
23451 int result;
23452 PyObject * obj0 = 0 ;
23453 char *kwnames[] = {
23454 (char *) "self", NULL
23455 };
23456
23457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23459 if (SWIG_arg_fail(1)) SWIG_fail;
23460 {
23461 PyThreadState* __tstate = wxPyBeginAllowThreads();
23462 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23463
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 {
23468 resultobj = SWIG_From_int((int)(result));
23469 }
23470 return resultobj;
23471 fail:
23472 return NULL;
23473 }
23474
23475
23476 static PyObject *_wrap_wxPyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj;
23478 wxPyApp *arg1 = (wxPyApp *) 0 ;
23479 int arg2 ;
23480 PyObject * obj0 = 0 ;
23481 PyObject * obj1 = 0 ;
23482 char *kwnames[] = {
23483 (char *) "self",(char *) "mode", NULL
23484 };
23485
23486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23488 if (SWIG_arg_fail(1)) SWIG_fail;
23489 {
23490 arg2 = (int)(SWIG_As_int(obj1));
23491 if (SWIG_arg_fail(2)) SWIG_fail;
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 (arg1)->SetAssertMode(arg2);
23496
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 Py_INCREF(Py_None); resultobj = Py_None;
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 static PyObject *_wrap_wxPyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj;
23509 wxPyApp *arg1 = (wxPyApp *) 0 ;
23510 int result;
23511 PyObject * obj0 = 0 ;
23512 char *kwnames[] = {
23513 (char *) "self", NULL
23514 };
23515
23516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23518 if (SWIG_arg_fail(1)) SWIG_fail;
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 result = (int)(arg1)->GetAssertMode();
23522
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = SWIG_From_int((int)(result));
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 static PyObject *_wrap_wxPyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj;
23537 bool result;
23538 char *kwnames[] = {
23539 NULL
23540 };
23541
23542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_wxPyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj;
23561 long result;
23562 char *kwnames[] = {
23563 NULL
23564 };
23565
23566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 result = (long)wxPyApp::GetMacAboutMenuItemId();
23570
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 {
23575 resultobj = SWIG_From_long((long)(result));
23576 }
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 static PyObject *_wrap_wxPyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj;
23585 long result;
23586 char *kwnames[] = {
23587 NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_long((long)(result));
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_wxPyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 long result;
23610 char *kwnames[] = {
23611 NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (long)wxPyApp::GetMacExitMenuItemId();
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = SWIG_From_long((long)(result));
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 static PyObject *_wrap_wxPyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj;
23633 wxString result;
23634 char *kwnames[] = {
23635 NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = wxPyApp::GetMacHelpMenuTitleName();
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 #if wxUSE_UNICODE
23648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23649 #else
23650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23651 #endif
23652 }
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_wxPyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 bool arg1 ;
23662 PyObject * obj0 = 0 ;
23663 char *kwnames[] = {
23664 (char *) "val", NULL
23665 };
23666
23667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23668 {
23669 arg1 = (bool)(SWIG_As_bool(obj0));
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 }
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23675
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 Py_INCREF(Py_None); resultobj = Py_None;
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_wxPyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj;
23688 long arg1 ;
23689 PyObject * obj0 = 0 ;
23690 char *kwnames[] = {
23691 (char *) "val", NULL
23692 };
23693
23694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23695 {
23696 arg1 = (long)(SWIG_As_long(obj0));
23697 if (SWIG_arg_fail(1)) SWIG_fail;
23698 }
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 wxPyApp::SetMacAboutMenuItemId(arg1);
23702
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 Py_INCREF(Py_None); resultobj = Py_None;
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 static PyObject *_wrap_wxPyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23714 PyObject *resultobj;
23715 long arg1 ;
23716 PyObject * obj0 = 0 ;
23717 char *kwnames[] = {
23718 (char *) "val", NULL
23719 };
23720
23721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23722 {
23723 arg1 = (long)(SWIG_As_long(obj0));
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 }
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23729
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 Py_INCREF(Py_None); resultobj = Py_None;
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 static PyObject *_wrap_wxPyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 long arg1 ;
23743 PyObject * obj0 = 0 ;
23744 char *kwnames[] = {
23745 (char *) "val", NULL
23746 };
23747
23748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23749 {
23750 arg1 = (long)(SWIG_As_long(obj0));
23751 if (SWIG_arg_fail(1)) SWIG_fail;
23752 }
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 wxPyApp::SetMacExitMenuItemId(arg1);
23756
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 Py_INCREF(Py_None); resultobj = Py_None;
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 static PyObject *_wrap_wxPyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj;
23769 wxString *arg1 = 0 ;
23770 bool temp1 = false ;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "val", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23777 {
23778 arg1 = wxString_in_helper(obj0);
23779 if (arg1 == NULL) SWIG_fail;
23780 temp1 = true;
23781 }
23782 {
23783 PyThreadState* __tstate = wxPyBeginAllowThreads();
23784 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23785
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 Py_INCREF(Py_None); resultobj = Py_None;
23790 {
23791 if (temp1)
23792 delete arg1;
23793 }
23794 return resultobj;
23795 fail:
23796 {
23797 if (temp1)
23798 delete arg1;
23799 }
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_wxPyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj;
23806 wxPyApp *arg1 = (wxPyApp *) 0 ;
23807 PyObject * obj0 = 0 ;
23808 char *kwnames[] = {
23809 (char *) "self", NULL
23810 };
23811
23812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxPyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23814 if (SWIG_arg_fail(1)) SWIG_fail;
23815 {
23816 PyThreadState* __tstate = wxPyBeginAllowThreads();
23817 (arg1)->_BootstrapApp();
23818
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 Py_INCREF(Py_None); resultobj = Py_None;
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 static PyObject *_wrap_wxPyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj;
23831 int result;
23832 char *kwnames[] = {
23833 NULL
23834 };
23835
23836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxPyApp_GetComCtl32Version",kwnames)) goto fail;
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (int)wxPyApp_GetComCtl32Version();
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 {
23845 resultobj = SWIG_From_int((int)(result));
23846 }
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 static PyObject * wxPyApp_swigregister(PyObject *, PyObject *args) {
23854 PyObject *obj;
23855 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23856 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23857 Py_INCREF(obj);
23858 return Py_BuildValue((char *)"");
23859 }
23860 static PyObject *_wrap_wxExit(PyObject *, PyObject *args, PyObject *kwargs) {
23861 PyObject *resultobj;
23862 char *kwnames[] = {
23863 NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxExit",kwnames)) goto fail;
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 wxExit();
23870
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 Py_INCREF(Py_None); resultobj = Py_None;
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 static PyObject *_wrap_wxYield(PyObject *, PyObject *args, PyObject *kwargs) {
23882 PyObject *resultobj;
23883 bool result;
23884 char *kwnames[] = {
23885 NULL
23886 };
23887
23888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxYield",kwnames)) goto fail;
23889 {
23890 PyThreadState* __tstate = wxPyBeginAllowThreads();
23891 result = (bool)wxYield();
23892
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 {
23897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23898 }
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 static PyObject *_wrap_wxYieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj;
23907 bool result;
23908 char *kwnames[] = {
23909 NULL
23910 };
23911
23912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxYieldIfNeeded",kwnames)) goto fail;
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (bool)wxYieldIfNeeded();
23916
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_wxSafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 wxWindow *arg1 = (wxWindow *) NULL ;
23932 bool arg2 = (bool) false ;
23933 bool result;
23934 PyObject * obj0 = 0 ;
23935 PyObject * obj1 = 0 ;
23936 char *kwnames[] = {
23937 (char *) "win",(char *) "onlyIfNeeded", NULL
23938 };
23939
23940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:wxSafeYield",kwnames,&obj0,&obj1)) goto fail;
23941 if (obj0) {
23942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23943 if (SWIG_arg_fail(1)) SWIG_fail;
23944 }
23945 if (obj1) {
23946 {
23947 arg2 = (bool)(SWIG_As_bool(obj1));
23948 if (SWIG_arg_fail(2)) SWIG_fail;
23949 }
23950 }
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (bool)wxSafeYield(arg1,arg2);
23954
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 static PyObject *_wrap_wxWakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj;
23969 char *kwnames[] = {
23970 NULL
23971 };
23972
23973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxWakeUpIdle",kwnames)) goto fail;
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 wxWakeUpIdle();
23977
23978 wxPyEndAllowThreads(__tstate);
23979 if (PyErr_Occurred()) SWIG_fail;
23980 }
23981 Py_INCREF(Py_None); resultobj = Py_None;
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 static PyObject *_wrap_wxPostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj;
23990 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23991 wxEvent *arg2 = 0 ;
23992 PyObject * obj0 = 0 ;
23993 PyObject * obj1 = 0 ;
23994 char *kwnames[] = {
23995 (char *) "dest",(char *) "event", NULL
23996 };
23997
23998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxPostEvent",kwnames,&obj0,&obj1)) goto fail;
23999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24000 if (SWIG_arg_fail(1)) SWIG_fail;
24001 {
24002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24003 if (SWIG_arg_fail(2)) SWIG_fail;
24004 if (arg2 == NULL) {
24005 SWIG_null_ref("wxEvent");
24006 }
24007 if (SWIG_arg_fail(2)) SWIG_fail;
24008 }
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 wxPostEvent(arg1,*arg2);
24012
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 Py_INCREF(Py_None); resultobj = Py_None;
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 static PyObject *_wrap_wxApp_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj;
24025 char *kwnames[] = {
24026 NULL
24027 };
24028
24029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxApp_CleanUp",kwnames)) goto fail;
24030 {
24031 PyThreadState* __tstate = wxPyBeginAllowThreads();
24032 wxApp_CleanUp();
24033
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 Py_INCREF(Py_None); resultobj = Py_None;
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24045 PyObject *resultobj;
24046 wxPyApp *result;
24047 char *kwnames[] = {
24048 NULL
24049 };
24050
24051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24052 {
24053 PyThreadState* __tstate = wxPyBeginAllowThreads();
24054 result = (wxPyApp *)wxPyGetApp();
24055
24056 wxPyEndAllowThreads(__tstate);
24057 if (PyErr_Occurred()) SWIG_fail;
24058 }
24059 {
24060 resultobj = wxPyMake_wxObject(result, 0);
24061 }
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 static PyObject *_wrap_wxSetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24069 PyObject *resultobj;
24070 char *arg1 = (char *) 0 ;
24071 PyObject * obj0 = 0 ;
24072 char *kwnames[] = {
24073 (char *) "encoding", NULL
24074 };
24075
24076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24077 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24078 SWIG_arg_fail(1);SWIG_fail;
24079 }
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 wxSetDefaultPyEncoding((char const *)arg1);
24083
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 Py_INCREF(Py_None); resultobj = Py_None;
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 static PyObject *_wrap_wxGetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24095 PyObject *resultobj;
24096 char *result;
24097 char *kwnames[] = {
24098 NULL
24099 };
24100
24101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxGetDefaultPyEncoding",kwnames)) goto fail;
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 result = (char *)wxGetDefaultPyEncoding();
24105
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 resultobj = SWIG_FromCharPtr(result);
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_new_wxEventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxEventLoop *result;
24119 char *kwnames[] = {
24120 NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxEventLoop",kwnames)) goto fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (wxEventLoop *)new wxEventLoop();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_delete_wxEventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj;
24140 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24141 PyObject * obj0 = 0 ;
24142 char *kwnames[] = {
24143 (char *) "self", NULL
24144 };
24145
24146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxEventLoop",kwnames,&obj0)) goto fail;
24147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24148 if (SWIG_arg_fail(1)) SWIG_fail;
24149 {
24150 PyThreadState* __tstate = wxPyBeginAllowThreads();
24151 delete arg1;
24152
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 Py_INCREF(Py_None); resultobj = Py_None;
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 static PyObject *_wrap_wxEventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj;
24165 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24166 int result;
24167 PyObject * obj0 = 0 ;
24168 char *kwnames[] = {
24169 (char *) "self", NULL
24170 };
24171
24172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEventLoop_Run",kwnames,&obj0)) goto fail;
24173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24174 if (SWIG_arg_fail(1)) SWIG_fail;
24175 {
24176 PyThreadState* __tstate = wxPyBeginAllowThreads();
24177 result = (int)(arg1)->Run();
24178
24179 wxPyEndAllowThreads(__tstate);
24180 if (PyErr_Occurred()) SWIG_fail;
24181 }
24182 {
24183 resultobj = SWIG_From_int((int)(result));
24184 }
24185 return resultobj;
24186 fail:
24187 return NULL;
24188 }
24189
24190
24191 static PyObject *_wrap_wxEventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24192 PyObject *resultobj;
24193 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24194 int arg2 = (int) 0 ;
24195 PyObject * obj0 = 0 ;
24196 PyObject * obj1 = 0 ;
24197 char *kwnames[] = {
24198 (char *) "self",(char *) "rc", NULL
24199 };
24200
24201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxEventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24203 if (SWIG_arg_fail(1)) SWIG_fail;
24204 if (obj1) {
24205 {
24206 arg2 = (int)(SWIG_As_int(obj1));
24207 if (SWIG_arg_fail(2)) SWIG_fail;
24208 }
24209 }
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 (arg1)->Exit(arg2);
24213
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 Py_INCREF(Py_None); resultobj = Py_None;
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 static PyObject *_wrap_wxEventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj;
24226 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24227 bool result;
24228 PyObject * obj0 = 0 ;
24229 char *kwnames[] = {
24230 (char *) "self", NULL
24231 };
24232
24233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEventLoop_Pending",kwnames,&obj0)) goto fail;
24234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(1)) SWIG_fail;
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 result = (bool)((wxEventLoop const *)arg1)->Pending();
24239
24240 wxPyEndAllowThreads(__tstate);
24241 if (PyErr_Occurred()) SWIG_fail;
24242 }
24243 {
24244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24245 }
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_wxEventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj;
24254 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24255 bool result;
24256 PyObject * obj0 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEventLoop_Dispatch",kwnames,&obj0)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)(arg1)->Dispatch();
24267
24268 wxPyEndAllowThreads(__tstate);
24269 if (PyErr_Occurred()) SWIG_fail;
24270 }
24271 {
24272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 static PyObject *_wrap_wxEventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24281 PyObject *resultobj;
24282 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24283 bool result;
24284 PyObject * obj0 = 0 ;
24285 char *kwnames[] = {
24286 (char *) "self", NULL
24287 };
24288
24289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEventLoop_IsRunning",kwnames,&obj0)) goto fail;
24290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24291 if (SWIG_arg_fail(1)) SWIG_fail;
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24295
24296 wxPyEndAllowThreads(__tstate);
24297 if (PyErr_Occurred()) SWIG_fail;
24298 }
24299 {
24300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24301 }
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_wxEventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 wxEventLoop *result;
24311 char *kwnames[] = {
24312 NULL
24313 };
24314
24315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxEventLoop_GetActive",kwnames)) goto fail;
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 result = (wxEventLoop *)wxEventLoop::GetActive();
24319
24320 wxPyEndAllowThreads(__tstate);
24321 if (PyErr_Occurred()) SWIG_fail;
24322 }
24323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24324 return resultobj;
24325 fail:
24326 return NULL;
24327 }
24328
24329
24330 static PyObject *_wrap_wxEventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24331 PyObject *resultobj;
24332 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24333 PyObject * obj0 = 0 ;
24334 char *kwnames[] = {
24335 (char *) "loop", NULL
24336 };
24337
24338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxEventLoop_SetActive",kwnames,&obj0)) goto fail;
24339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24340 if (SWIG_arg_fail(1)) SWIG_fail;
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 wxEventLoop::SetActive(arg1);
24344
24345 wxPyEndAllowThreads(__tstate);
24346 if (PyErr_Occurred()) SWIG_fail;
24347 }
24348 Py_INCREF(Py_None); resultobj = Py_None;
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 static PyObject * wxEventLoop_swigregister(PyObject *, PyObject *args) {
24356 PyObject *obj;
24357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24358 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24359 Py_INCREF(obj);
24360 return Py_BuildValue((char *)"");
24361 }
24362 static PyObject *_wrap_new_wxAcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24363 PyObject *resultobj;
24364 int arg1 = (int) 0 ;
24365 int arg2 = (int) 0 ;
24366 int arg3 = (int) 0 ;
24367 wxAcceleratorEntry *result;
24368 PyObject * obj0 = 0 ;
24369 PyObject * obj1 = 0 ;
24370 PyObject * obj2 = 0 ;
24371 char *kwnames[] = {
24372 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24373 };
24374
24375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_wxAcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24376 if (obj0) {
24377 {
24378 arg1 = (int)(SWIG_As_int(obj0));
24379 if (SWIG_arg_fail(1)) SWIG_fail;
24380 }
24381 }
24382 if (obj1) {
24383 {
24384 arg2 = (int)(SWIG_As_int(obj1));
24385 if (SWIG_arg_fail(2)) SWIG_fail;
24386 }
24387 }
24388 if (obj2) {
24389 {
24390 arg3 = (int)(SWIG_As_int(obj2));
24391 if (SWIG_arg_fail(3)) SWIG_fail;
24392 }
24393 }
24394 {
24395 PyThreadState* __tstate = wxPyBeginAllowThreads();
24396 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24397
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_delete_wxAcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj;
24410 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24411 PyObject * obj0 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxAcceleratorEntry",kwnames,&obj0)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 delete arg1;
24422
24423 wxPyEndAllowThreads(__tstate);
24424 if (PyErr_Occurred()) SWIG_fail;
24425 }
24426 Py_INCREF(Py_None); resultobj = Py_None;
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 static PyObject *_wrap_wxAcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24434 PyObject *resultobj;
24435 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24436 int arg2 ;
24437 int arg3 ;
24438 int arg4 ;
24439 PyObject * obj0 = 0 ;
24440 PyObject * obj1 = 0 ;
24441 PyObject * obj2 = 0 ;
24442 PyObject * obj3 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxAcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 arg2 = (int)(SWIG_As_int(obj1));
24452 if (SWIG_arg_fail(2)) SWIG_fail;
24453 }
24454 {
24455 arg3 = (int)(SWIG_As_int(obj2));
24456 if (SWIG_arg_fail(3)) SWIG_fail;
24457 }
24458 {
24459 arg4 = (int)(SWIG_As_int(obj3));
24460 if (SWIG_arg_fail(4)) SWIG_fail;
24461 }
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 (arg1)->Set(arg2,arg3,arg4);
24465
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 Py_INCREF(Py_None); resultobj = Py_None;
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 static PyObject *_wrap_wxAcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj;
24478 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24479 int result;
24480 PyObject * obj0 = 0 ;
24481 char *kwnames[] = {
24482 (char *) "self", NULL
24483 };
24484
24485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxAcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24487 if (SWIG_arg_fail(1)) SWIG_fail;
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (int)(arg1)->GetFlags();
24491
24492 wxPyEndAllowThreads(__tstate);
24493 if (PyErr_Occurred()) SWIG_fail;
24494 }
24495 {
24496 resultobj = SWIG_From_int((int)(result));
24497 }
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 static PyObject *_wrap_wxAcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24505 PyObject *resultobj;
24506 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24507 int result;
24508 PyObject * obj0 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "self", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxAcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(1)) SWIG_fail;
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = (int)(arg1)->GetKeyCode();
24519
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 {
24524 resultobj = SWIG_From_int((int)(result));
24525 }
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject *_wrap_wxAcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24533 PyObject *resultobj;
24534 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24535 int result;
24536 PyObject * obj0 = 0 ;
24537 char *kwnames[] = {
24538 (char *) "self", NULL
24539 };
24540
24541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxAcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24543 if (SWIG_arg_fail(1)) SWIG_fail;
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 result = (int)(arg1)->GetCommand();
24547
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 {
24552 resultobj = SWIG_From_int((int)(result));
24553 }
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 static PyObject * wxAcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24561 PyObject *obj;
24562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24563 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24564 Py_INCREF(obj);
24565 return Py_BuildValue((char *)"");
24566 }
24567 static PyObject *_wrap_new_wxAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24568 PyObject *resultobj;
24569 int arg1 ;
24570 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24571 wxAcceleratorTable *result;
24572 PyObject * obj0 = 0 ;
24573 char *kwnames[] = {
24574 (char *) "n", NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_wxAcceleratorTable",kwnames,&obj0)) goto fail;
24578 {
24579 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24580 if (arg2) arg1 = PyList_Size(obj0);
24581 else arg1 = 0;
24582 }
24583 {
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24586
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24591 {
24592 delete [] arg2;
24593 }
24594 return resultobj;
24595 fail:
24596 {
24597 delete [] arg2;
24598 }
24599 return NULL;
24600 }
24601
24602
24603 static PyObject *_wrap_delete_wxAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj;
24605 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24606 PyObject * obj0 = 0 ;
24607 char *kwnames[] = {
24608 (char *) "self", NULL
24609 };
24610
24611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxAcceleratorTable",kwnames,&obj0)) goto fail;
24612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24613 if (SWIG_arg_fail(1)) SWIG_fail;
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 delete arg1;
24617
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 Py_INCREF(Py_None); resultobj = Py_None;
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject *_wrap_wxAcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24629 PyObject *resultobj;
24630 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24631 bool result;
24632 PyObject * obj0 = 0 ;
24633 char *kwnames[] = {
24634 (char *) "self", NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxAcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24639 if (SWIG_arg_fail(1)) SWIG_fail;
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24643
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 {
24648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24649 }
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 static PyObject * wxAcceleratorTable_swigregister(PyObject *, PyObject *args) {
24657 PyObject *obj;
24658 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24659 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24660 Py_INCREF(obj);
24661 return Py_BuildValue((char *)"");
24662 }
24663 static int _wrap_wxNullAcceleratorTable_set(PyObject *) {
24664 PyErr_SetString(PyExc_TypeError,"Variable wxNullAcceleratorTable is read-only.");
24665 return 1;
24666 }
24667
24668
24669 static PyObject *_wrap_wxNullAcceleratorTable_get(void) {
24670 PyObject *pyobj;
24671
24672 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24673 return pyobj;
24674 }
24675
24676
24677 static PyObject *_wrap_wxGetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24678 PyObject *resultobj;
24679 wxString *arg1 = 0 ;
24680 wxAcceleratorEntry *result;
24681 bool temp1 = false ;
24682 PyObject * obj0 = 0 ;
24683 char *kwnames[] = {
24684 (char *) "label", NULL
24685 };
24686
24687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGetAccelFromString",kwnames,&obj0)) goto fail;
24688 {
24689 arg1 = wxString_in_helper(obj0);
24690 if (arg1 == NULL) SWIG_fail;
24691 temp1 = true;
24692 }
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24696
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24701 {
24702 if (temp1)
24703 delete arg1;
24704 }
24705 return resultobj;
24706 fail:
24707 {
24708 if (temp1)
24709 delete arg1;
24710 }
24711 return NULL;
24712 }
24713
24714
24715 static int _wrap_PanelNameStr_set(PyObject *) {
24716 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24717 return 1;
24718 }
24719
24720
24721 static PyObject *_wrap_PanelNameStr_get(void) {
24722 PyObject *pyobj;
24723
24724 {
24725 #if wxUSE_UNICODE
24726 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24727 #else
24728 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24729 #endif
24730 }
24731 return pyobj;
24732 }
24733
24734
24735 static PyObject *_wrap_new_wxVisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24736 PyObject *resultobj;
24737 wxVisualAttributes *result;
24738 char *kwnames[] = {
24739 NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxVisualAttributes",kwnames)) goto fail;
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = (wxVisualAttributes *)new_wxVisualAttributes();
24746
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 static PyObject *_wrap_delete_wxVisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24758 PyObject *resultobj;
24759 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24760 PyObject * obj0 = 0 ;
24761 char *kwnames[] = {
24762 (char *) "self", NULL
24763 };
24764
24765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_wxVisualAttributes",kwnames,&obj0)) goto fail;
24766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24767 if (SWIG_arg_fail(1)) SWIG_fail;
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 delete_wxVisualAttributes(arg1);
24771
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 Py_INCREF(Py_None); resultobj = Py_None;
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 static PyObject *_wrap_wxVisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj;
24784 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24785 wxFont arg2 ;
24786 PyObject * obj0 = 0 ;
24787 PyObject * obj1 = 0 ;
24788 char *kwnames[] = {
24789 (char *) "self",(char *) "font", NULL
24790 };
24791
24792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxVisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24794 if (SWIG_arg_fail(1)) SWIG_fail;
24795 {
24796 wxFont * argp;
24797 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION);
24798 if (SWIG_arg_fail(2)) SWIG_fail;
24799 if (argp == NULL) {
24800 SWIG_null_ref("wxFont");
24801 }
24802 if (SWIG_arg_fail(2)) SWIG_fail;
24803 arg2 = *argp;
24804 }
24805 if (arg1) (arg1)->font = arg2;
24806
24807 Py_INCREF(Py_None); resultobj = Py_None;
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 static PyObject *_wrap_wxVisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj;
24816 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24817 wxFont result;
24818 PyObject * obj0 = 0 ;
24819 char *kwnames[] = {
24820 (char *) "self", NULL
24821 };
24822
24823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxVisualAttributes_font_get",kwnames,&obj0)) goto fail;
24824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24825 if (SWIG_arg_fail(1)) SWIG_fail;
24826 result = ((arg1)->font);
24827
24828 {
24829 wxFont * resultptr;
24830 resultptr = new wxFont((wxFont &)(result));
24831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
24832 }
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 static PyObject *_wrap_wxVisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj;
24841 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24842 wxColour arg2 ;
24843 PyObject * obj0 = 0 ;
24844 PyObject * obj1 = 0 ;
24845 char *kwnames[] = {
24846 (char *) "self",(char *) "colFg", NULL
24847 };
24848
24849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxVisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24851 if (SWIG_arg_fail(1)) SWIG_fail;
24852 {
24853 wxColour * argp;
24854 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION);
24855 if (SWIG_arg_fail(2)) SWIG_fail;
24856 if (argp == NULL) {
24857 SWIG_null_ref("wxColour");
24858 }
24859 if (SWIG_arg_fail(2)) SWIG_fail;
24860 arg2 = *argp;
24861 }
24862 if (arg1) (arg1)->colFg = arg2;
24863
24864 Py_INCREF(Py_None); resultobj = Py_None;
24865 return resultobj;
24866 fail:
24867 return NULL;
24868 }
24869
24870
24871 static PyObject *_wrap_wxVisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24872 PyObject *resultobj;
24873 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24874 wxColour result;
24875 PyObject * obj0 = 0 ;
24876 char *kwnames[] = {
24877 (char *) "self", NULL
24878 };
24879
24880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxVisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24882 if (SWIG_arg_fail(1)) SWIG_fail;
24883 result = ((arg1)->colFg);
24884
24885 {
24886 wxColour * resultptr;
24887 resultptr = new wxColour((wxColour &)(result));
24888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
24889 }
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 static PyObject *_wrap_wxVisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24897 PyObject *resultobj;
24898 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24899 wxColour arg2 ;
24900 PyObject * obj0 = 0 ;
24901 PyObject * obj1 = 0 ;
24902 char *kwnames[] = {
24903 (char *) "self",(char *) "colBg", NULL
24904 };
24905
24906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxVisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24908 if (SWIG_arg_fail(1)) SWIG_fail;
24909 {
24910 wxColour * argp;
24911 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION);
24912 if (SWIG_arg_fail(2)) SWIG_fail;
24913 if (argp == NULL) {
24914 SWIG_null_ref("wxColour");
24915 }
24916 if (SWIG_arg_fail(2)) SWIG_fail;
24917 arg2 = *argp;
24918 }
24919 if (arg1) (arg1)->colBg = arg2;
24920
24921 Py_INCREF(Py_None); resultobj = Py_None;
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_wxVisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj;
24930 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24931 wxColour result;
24932 PyObject * obj0 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxVisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 result = ((arg1)->colBg);
24941
24942 {
24943 wxColour * resultptr;
24944 resultptr = new wxColour((wxColour &)(result));
24945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
24946 }
24947 return resultobj;
24948 fail:
24949 return NULL;
24950 }
24951
24952
24953 static PyObject * wxVisualAttributes_swigregister(PyObject *, PyObject *args) {
24954 PyObject *obj;
24955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24956 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24957 Py_INCREF(obj);
24958 return Py_BuildValue((char *)"");
24959 }
24960 static PyObject *_wrap_new_wxWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24961 PyObject *resultobj;
24962 wxWindow *arg1 = (wxWindow *) 0 ;
24963 int arg2 = (int) (int)-1 ;
24964 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24965 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24966 wxSize const &arg4_defvalue = wxDefaultSize ;
24967 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24968 long arg5 = (long) 0 ;
24969 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24970 wxString *arg6 = (wxString *) &arg6_defvalue ;
24971 wxWindow *result;
24972 wxPoint temp3 ;
24973 wxSize temp4 ;
24974 bool temp6 = false ;
24975 PyObject * obj0 = 0 ;
24976 PyObject * obj1 = 0 ;
24977 PyObject * obj2 = 0 ;
24978 PyObject * obj3 = 0 ;
24979 PyObject * obj4 = 0 ;
24980 PyObject * obj5 = 0 ;
24981 char *kwnames[] = {
24982 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24983 };
24984
24985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_wxWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24987 if (SWIG_arg_fail(1)) SWIG_fail;
24988 if (obj1) {
24989 {
24990 arg2 = (int const)(SWIG_As_int(obj1));
24991 if (SWIG_arg_fail(2)) SWIG_fail;
24992 }
24993 }
24994 if (obj2) {
24995 {
24996 arg3 = &temp3;
24997 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24998 }
24999 }
25000 if (obj3) {
25001 {
25002 arg4 = &temp4;
25003 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25004 }
25005 }
25006 if (obj4) {
25007 {
25008 arg5 = (long)(SWIG_As_long(obj4));
25009 if (SWIG_arg_fail(5)) SWIG_fail;
25010 }
25011 }
25012 if (obj5) {
25013 {
25014 arg6 = wxString_in_helper(obj5);
25015 if (arg6 == NULL) SWIG_fail;
25016 temp6 = true;
25017 }
25018 }
25019 {
25020 if (!wxPyCheckForApp()) SWIG_fail;
25021 PyThreadState* __tstate = wxPyBeginAllowThreads();
25022 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25023
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25028 {
25029 if (temp6)
25030 delete arg6;
25031 }
25032 return resultobj;
25033 fail:
25034 {
25035 if (temp6)
25036 delete arg6;
25037 }
25038 return NULL;
25039 }
25040
25041
25042 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25043 PyObject *resultobj;
25044 wxWindow *result;
25045 char *kwnames[] = {
25046 NULL
25047 };
25048
25049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25050 {
25051 if (!wxPyCheckForApp()) SWIG_fail;
25052 PyThreadState* __tstate = wxPyBeginAllowThreads();
25053 result = (wxWindow *)new wxWindow();
25054
25055 wxPyEndAllowThreads(__tstate);
25056 if (PyErr_Occurred()) SWIG_fail;
25057 }
25058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_wxWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj;
25067 wxWindow *arg1 = (wxWindow *) 0 ;
25068 wxWindow *arg2 = (wxWindow *) 0 ;
25069 int arg3 = (int) (int)-1 ;
25070 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25071 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25072 wxSize const &arg5_defvalue = wxDefaultSize ;
25073 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25074 long arg6 = (long) 0 ;
25075 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25076 wxString *arg7 = (wxString *) &arg7_defvalue ;
25077 bool result;
25078 wxPoint temp4 ;
25079 wxSize temp5 ;
25080 bool temp7 = false ;
25081 PyObject * obj0 = 0 ;
25082 PyObject * obj1 = 0 ;
25083 PyObject * obj2 = 0 ;
25084 PyObject * obj3 = 0 ;
25085 PyObject * obj4 = 0 ;
25086 PyObject * obj5 = 0 ;
25087 PyObject * obj6 = 0 ;
25088 char *kwnames[] = {
25089 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25090 };
25091
25092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:wxWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25094 if (SWIG_arg_fail(1)) SWIG_fail;
25095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25096 if (SWIG_arg_fail(2)) SWIG_fail;
25097 if (obj2) {
25098 {
25099 arg3 = (int const)(SWIG_As_int(obj2));
25100 if (SWIG_arg_fail(3)) SWIG_fail;
25101 }
25102 }
25103 if (obj3) {
25104 {
25105 arg4 = &temp4;
25106 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25107 }
25108 }
25109 if (obj4) {
25110 {
25111 arg5 = &temp5;
25112 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25113 }
25114 }
25115 if (obj5) {
25116 {
25117 arg6 = (long)(SWIG_As_long(obj5));
25118 if (SWIG_arg_fail(6)) SWIG_fail;
25119 }
25120 }
25121 if (obj6) {
25122 {
25123 arg7 = wxString_in_helper(obj6);
25124 if (arg7 == NULL) SWIG_fail;
25125 temp7 = true;
25126 }
25127 }
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 {
25136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25137 }
25138 {
25139 if (temp7)
25140 delete arg7;
25141 }
25142 return resultobj;
25143 fail:
25144 {
25145 if (temp7)
25146 delete arg7;
25147 }
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_wxWindow_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 wxWindow *arg1 = (wxWindow *) 0 ;
25155 bool arg2 = (bool) false ;
25156 bool result;
25157 PyObject * obj0 = 0 ;
25158 PyObject * obj1 = 0 ;
25159 char *kwnames[] = {
25160 (char *) "self",(char *) "force", NULL
25161 };
25162
25163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_Close",kwnames,&obj0,&obj1)) goto fail;
25164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25165 if (SWIG_arg_fail(1)) SWIG_fail;
25166 if (obj1) {
25167 {
25168 arg2 = (bool)(SWIG_As_bool(obj1));
25169 if (SWIG_arg_fail(2)) SWIG_fail;
25170 }
25171 }
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 result = (bool)(arg1)->Close(arg2);
25175
25176 wxPyEndAllowThreads(__tstate);
25177 if (PyErr_Occurred()) SWIG_fail;
25178 }
25179 {
25180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25181 }
25182 return resultobj;
25183 fail:
25184 return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_wxWindow_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj;
25190 wxWindow *arg1 = (wxWindow *) 0 ;
25191 bool result;
25192 PyObject * obj0 = 0 ;
25193 char *kwnames[] = {
25194 (char *) "self", NULL
25195 };
25196
25197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Destroy",kwnames,&obj0)) goto fail;
25198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25199 if (SWIG_arg_fail(1)) SWIG_fail;
25200 {
25201 PyThreadState* __tstate = wxPyBeginAllowThreads();
25202 result = (bool)(arg1)->Destroy();
25203
25204 wxPyEndAllowThreads(__tstate);
25205 if (PyErr_Occurred()) SWIG_fail;
25206 }
25207 {
25208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25209 }
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 static PyObject *_wrap_wxWindow_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25217 PyObject *resultobj;
25218 wxWindow *arg1 = (wxWindow *) 0 ;
25219 bool result;
25220 PyObject * obj0 = 0 ;
25221 char *kwnames[] = {
25222 (char *) "self", NULL
25223 };
25224
25225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_DestroyChildren",kwnames,&obj0)) goto fail;
25226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25227 if (SWIG_arg_fail(1)) SWIG_fail;
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 result = (bool)(arg1)->DestroyChildren();
25231
25232 wxPyEndAllowThreads(__tstate);
25233 if (PyErr_Occurred()) SWIG_fail;
25234 }
25235 {
25236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25237 }
25238 return resultobj;
25239 fail:
25240 return NULL;
25241 }
25242
25243
25244 static PyObject *_wrap_wxWindow_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25245 PyObject *resultobj;
25246 wxWindow *arg1 = (wxWindow *) 0 ;
25247 bool result;
25248 PyObject * obj0 = 0 ;
25249 char *kwnames[] = {
25250 (char *) "self", NULL
25251 };
25252
25253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_IsBeingDeleted",kwnames,&obj0)) goto fail;
25254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25255 if (SWIG_arg_fail(1)) SWIG_fail;
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25259
25260 wxPyEndAllowThreads(__tstate);
25261 if (PyErr_Occurred()) SWIG_fail;
25262 }
25263 {
25264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25265 }
25266 return resultobj;
25267 fail:
25268 return NULL;
25269 }
25270
25271
25272 static PyObject *_wrap_wxWindow_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25273 PyObject *resultobj;
25274 wxWindow *arg1 = (wxWindow *) 0 ;
25275 wxString *arg2 = 0 ;
25276 bool temp2 = false ;
25277 PyObject * obj0 = 0 ;
25278 PyObject * obj1 = 0 ;
25279 char *kwnames[] = {
25280 (char *) "self",(char *) "title", NULL
25281 };
25282
25283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25285 if (SWIG_arg_fail(1)) SWIG_fail;
25286 {
25287 arg2 = wxString_in_helper(obj1);
25288 if (arg2 == NULL) SWIG_fail;
25289 temp2 = true;
25290 }
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 (arg1)->SetTitle((wxString const &)*arg2);
25294
25295 wxPyEndAllowThreads(__tstate);
25296 if (PyErr_Occurred()) SWIG_fail;
25297 }
25298 Py_INCREF(Py_None); resultobj = Py_None;
25299 {
25300 if (temp2)
25301 delete arg2;
25302 }
25303 return resultobj;
25304 fail:
25305 {
25306 if (temp2)
25307 delete arg2;
25308 }
25309 return NULL;
25310 }
25311
25312
25313 static PyObject *_wrap_wxWindow_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25314 PyObject *resultobj;
25315 wxWindow *arg1 = (wxWindow *) 0 ;
25316 wxString result;
25317 PyObject * obj0 = 0 ;
25318 char *kwnames[] = {
25319 (char *) "self", NULL
25320 };
25321
25322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetTitle",kwnames,&obj0)) goto fail;
25323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25324 if (SWIG_arg_fail(1)) SWIG_fail;
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 result = ((wxWindow const *)arg1)->GetTitle();
25328
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 {
25333 #if wxUSE_UNICODE
25334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25335 #else
25336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25337 #endif
25338 }
25339 return resultobj;
25340 fail:
25341 return NULL;
25342 }
25343
25344
25345 static PyObject *_wrap_wxWindow_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj;
25347 wxWindow *arg1 = (wxWindow *) 0 ;
25348 wxString *arg2 = 0 ;
25349 bool temp2 = false ;
25350 PyObject * obj0 = 0 ;
25351 PyObject * obj1 = 0 ;
25352 char *kwnames[] = {
25353 (char *) "self",(char *) "label", NULL
25354 };
25355
25356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25358 if (SWIG_arg_fail(1)) SWIG_fail;
25359 {
25360 arg2 = wxString_in_helper(obj1);
25361 if (arg2 == NULL) SWIG_fail;
25362 temp2 = true;
25363 }
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 (arg1)->SetLabel((wxString const &)*arg2);
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 Py_INCREF(Py_None); resultobj = Py_None;
25372 {
25373 if (temp2)
25374 delete arg2;
25375 }
25376 return resultobj;
25377 fail:
25378 {
25379 if (temp2)
25380 delete arg2;
25381 }
25382 return NULL;
25383 }
25384
25385
25386 static PyObject *_wrap_wxWindow_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25387 PyObject *resultobj;
25388 wxWindow *arg1 = (wxWindow *) 0 ;
25389 wxString result;
25390 PyObject * obj0 = 0 ;
25391 char *kwnames[] = {
25392 (char *) "self", NULL
25393 };
25394
25395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetLabel",kwnames,&obj0)) goto fail;
25396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25397 if (SWIG_arg_fail(1)) SWIG_fail;
25398 {
25399 PyThreadState* __tstate = wxPyBeginAllowThreads();
25400 result = ((wxWindow const *)arg1)->GetLabel();
25401
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 {
25406 #if wxUSE_UNICODE
25407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25408 #else
25409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25410 #endif
25411 }
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 static PyObject *_wrap_wxWindow_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25419 PyObject *resultobj;
25420 wxWindow *arg1 = (wxWindow *) 0 ;
25421 wxString *arg2 = 0 ;
25422 bool temp2 = false ;
25423 PyObject * obj0 = 0 ;
25424 PyObject * obj1 = 0 ;
25425 char *kwnames[] = {
25426 (char *) "self",(char *) "name", NULL
25427 };
25428
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetName",kwnames,&obj0,&obj1)) goto fail;
25430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25431 if (SWIG_arg_fail(1)) SWIG_fail;
25432 {
25433 arg2 = wxString_in_helper(obj1);
25434 if (arg2 == NULL) SWIG_fail;
25435 temp2 = true;
25436 }
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 (arg1)->SetName((wxString const &)*arg2);
25440
25441 wxPyEndAllowThreads(__tstate);
25442 if (PyErr_Occurred()) SWIG_fail;
25443 }
25444 Py_INCREF(Py_None); resultobj = Py_None;
25445 {
25446 if (temp2)
25447 delete arg2;
25448 }
25449 return resultobj;
25450 fail:
25451 {
25452 if (temp2)
25453 delete arg2;
25454 }
25455 return NULL;
25456 }
25457
25458
25459 static PyObject *_wrap_wxWindow_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25460 PyObject *resultobj;
25461 wxWindow *arg1 = (wxWindow *) 0 ;
25462 wxString result;
25463 PyObject * obj0 = 0 ;
25464 char *kwnames[] = {
25465 (char *) "self", NULL
25466 };
25467
25468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetName",kwnames,&obj0)) goto fail;
25469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25470 if (SWIG_arg_fail(1)) SWIG_fail;
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 result = ((wxWindow const *)arg1)->GetName();
25474
25475 wxPyEndAllowThreads(__tstate);
25476 if (PyErr_Occurred()) SWIG_fail;
25477 }
25478 {
25479 #if wxUSE_UNICODE
25480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25481 #else
25482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25483 #endif
25484 }
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_wxWindow_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 wxWindow *arg1 = (wxWindow *) 0 ;
25494 wxWindowVariant arg2 ;
25495 PyObject * obj0 = 0 ;
25496 PyObject * obj1 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "self",(char *) "variant", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25503 if (SWIG_arg_fail(1)) SWIG_fail;
25504 {
25505 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25506 if (SWIG_arg_fail(2)) SWIG_fail;
25507 }
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25511
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 Py_INCREF(Py_None); resultobj = Py_None;
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject *_wrap_wxWindow_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj;
25524 wxWindow *arg1 = (wxWindow *) 0 ;
25525 wxWindowVariant result;
25526 PyObject * obj0 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetWindowVariant",kwnames,&obj0)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 PyThreadState* __tstate = wxPyBeginAllowThreads();
25536 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25537
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 resultobj = SWIG_From_int((result));
25542 return resultobj;
25543 fail:
25544 return NULL;
25545 }
25546
25547
25548 static PyObject *_wrap_wxWindow_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25549 PyObject *resultobj;
25550 wxWindow *arg1 = (wxWindow *) 0 ;
25551 int arg2 ;
25552 PyObject * obj0 = 0 ;
25553 PyObject * obj1 = 0 ;
25554 char *kwnames[] = {
25555 (char *) "self",(char *) "winid", NULL
25556 };
25557
25558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetId",kwnames,&obj0,&obj1)) goto fail;
25559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25560 if (SWIG_arg_fail(1)) SWIG_fail;
25561 {
25562 arg2 = (int)(SWIG_As_int(obj1));
25563 if (SWIG_arg_fail(2)) SWIG_fail;
25564 }
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 (arg1)->SetId(arg2);
25568
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 Py_INCREF(Py_None); resultobj = Py_None;
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 static PyObject *_wrap_wxWindow_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj;
25581 wxWindow *arg1 = (wxWindow *) 0 ;
25582 int result;
25583 PyObject * obj0 = 0 ;
25584 char *kwnames[] = {
25585 (char *) "self", NULL
25586 };
25587
25588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetId",kwnames,&obj0)) goto fail;
25589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25590 if (SWIG_arg_fail(1)) SWIG_fail;
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = (int)((wxWindow const *)arg1)->GetId();
25594
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 {
25599 resultobj = SWIG_From_int((int)(result));
25600 }
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 static PyObject *_wrap_wxWindow_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25608 PyObject *resultobj;
25609 int result;
25610 char *kwnames[] = {
25611 NULL
25612 };
25613
25614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxWindow_NewControlId",kwnames)) goto fail;
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = (int)wxWindow::NewControlId();
25618
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 {
25623 resultobj = SWIG_From_int((int)(result));
25624 }
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 static PyObject *_wrap_wxWindow_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25632 PyObject *resultobj;
25633 int arg1 ;
25634 int result;
25635 PyObject * obj0 = 0 ;
25636 char *kwnames[] = {
25637 (char *) "winid", NULL
25638 };
25639
25640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_NextControlId",kwnames,&obj0)) goto fail;
25641 {
25642 arg1 = (int)(SWIG_As_int(obj0));
25643 if (SWIG_arg_fail(1)) SWIG_fail;
25644 }
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 result = (int)wxWindow::NextControlId(arg1);
25648
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 {
25653 resultobj = SWIG_From_int((int)(result));
25654 }
25655 return resultobj;
25656 fail:
25657 return NULL;
25658 }
25659
25660
25661 static PyObject *_wrap_wxWindow_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25662 PyObject *resultobj;
25663 int arg1 ;
25664 int result;
25665 PyObject * obj0 = 0 ;
25666 char *kwnames[] = {
25667 (char *) "winid", NULL
25668 };
25669
25670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_PrevControlId",kwnames,&obj0)) goto fail;
25671 {
25672 arg1 = (int)(SWIG_As_int(obj0));
25673 if (SWIG_arg_fail(1)) SWIG_fail;
25674 }
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 result = (int)wxWindow::PrevControlId(arg1);
25678
25679 wxPyEndAllowThreads(__tstate);
25680 if (PyErr_Occurred()) SWIG_fail;
25681 }
25682 {
25683 resultobj = SWIG_From_int((int)(result));
25684 }
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 static PyObject *_wrap_wxWindow_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj;
25693 wxWindow *arg1 = (wxWindow *) 0 ;
25694 wxSize *arg2 = 0 ;
25695 wxSize temp2 ;
25696 PyObject * obj0 = 0 ;
25697 PyObject * obj1 = 0 ;
25698 char *kwnames[] = {
25699 (char *) "self",(char *) "size", NULL
25700 };
25701
25702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetSize",kwnames,&obj0,&obj1)) goto fail;
25703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25704 if (SWIG_arg_fail(1)) SWIG_fail;
25705 {
25706 arg2 = &temp2;
25707 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25708 }
25709 {
25710 PyThreadState* __tstate = wxPyBeginAllowThreads();
25711 (arg1)->SetSize((wxSize const &)*arg2);
25712
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 Py_INCREF(Py_None); resultobj = Py_None;
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 static PyObject *_wrap_wxWindow_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj;
25725 wxWindow *arg1 = (wxWindow *) 0 ;
25726 int arg2 ;
25727 int arg3 ;
25728 int arg4 ;
25729 int arg5 ;
25730 int arg6 = (int) wxSIZE_AUTO ;
25731 PyObject * obj0 = 0 ;
25732 PyObject * obj1 = 0 ;
25733 PyObject * obj2 = 0 ;
25734 PyObject * obj3 = 0 ;
25735 PyObject * obj4 = 0 ;
25736 PyObject * obj5 = 0 ;
25737 char *kwnames[] = {
25738 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25739 };
25740
25741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:wxWindow_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(1)) SWIG_fail;
25744 {
25745 arg2 = (int)(SWIG_As_int(obj1));
25746 if (SWIG_arg_fail(2)) SWIG_fail;
25747 }
25748 {
25749 arg3 = (int)(SWIG_As_int(obj2));
25750 if (SWIG_arg_fail(3)) SWIG_fail;
25751 }
25752 {
25753 arg4 = (int)(SWIG_As_int(obj3));
25754 if (SWIG_arg_fail(4)) SWIG_fail;
25755 }
25756 {
25757 arg5 = (int)(SWIG_As_int(obj4));
25758 if (SWIG_arg_fail(5)) SWIG_fail;
25759 }
25760 if (obj5) {
25761 {
25762 arg6 = (int)(SWIG_As_int(obj5));
25763 if (SWIG_arg_fail(6)) SWIG_fail;
25764 }
25765 }
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25769
25770 wxPyEndAllowThreads(__tstate);
25771 if (PyErr_Occurred()) SWIG_fail;
25772 }
25773 Py_INCREF(Py_None); resultobj = Py_None;
25774 return resultobj;
25775 fail:
25776 return NULL;
25777 }
25778
25779
25780 static PyObject *_wrap_wxWindow_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25781 PyObject *resultobj;
25782 wxWindow *arg1 = (wxWindow *) 0 ;
25783 wxRect *arg2 = 0 ;
25784 int arg3 = (int) wxSIZE_AUTO ;
25785 wxRect temp2 ;
25786 PyObject * obj0 = 0 ;
25787 PyObject * obj1 = 0 ;
25788 PyObject * obj2 = 0 ;
25789 char *kwnames[] = {
25790 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25791 };
25792
25793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25795 if (SWIG_arg_fail(1)) SWIG_fail;
25796 {
25797 arg2 = &temp2;
25798 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25799 }
25800 if (obj2) {
25801 {
25802 arg3 = (int)(SWIG_As_int(obj2));
25803 if (SWIG_arg_fail(3)) SWIG_fail;
25804 }
25805 }
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25809
25810 wxPyEndAllowThreads(__tstate);
25811 if (PyErr_Occurred()) SWIG_fail;
25812 }
25813 Py_INCREF(Py_None); resultobj = Py_None;
25814 return resultobj;
25815 fail:
25816 return NULL;
25817 }
25818
25819
25820 static PyObject *_wrap_wxWindow_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25821 PyObject *resultobj;
25822 wxWindow *arg1 = (wxWindow *) 0 ;
25823 int arg2 ;
25824 int arg3 ;
25825 PyObject * obj0 = 0 ;
25826 PyObject * obj1 = 0 ;
25827 PyObject * obj2 = 0 ;
25828 char *kwnames[] = {
25829 (char *) "self",(char *) "width",(char *) "height", NULL
25830 };
25831
25832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25834 if (SWIG_arg_fail(1)) SWIG_fail;
25835 {
25836 arg2 = (int)(SWIG_As_int(obj1));
25837 if (SWIG_arg_fail(2)) SWIG_fail;
25838 }
25839 {
25840 arg3 = (int)(SWIG_As_int(obj2));
25841 if (SWIG_arg_fail(3)) SWIG_fail;
25842 }
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 (arg1)->SetSize(arg2,arg3);
25846
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 Py_INCREF(Py_None); resultobj = Py_None;
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_wxWindow_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxWindow *arg1 = (wxWindow *) 0 ;
25860 wxPoint *arg2 = 0 ;
25861 int arg3 = (int) wxSIZE_USE_EXISTING ;
25862 wxPoint temp2 ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 PyObject * obj2 = 0 ;
25866 char *kwnames[] = {
25867 (char *) "self",(char *) "pt",(char *) "flags", NULL
25868 };
25869
25870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25872 if (SWIG_arg_fail(1)) SWIG_fail;
25873 {
25874 arg2 = &temp2;
25875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25876 }
25877 if (obj2) {
25878 {
25879 arg3 = (int)(SWIG_As_int(obj2));
25880 if (SWIG_arg_fail(3)) SWIG_fail;
25881 }
25882 }
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 (arg1)->Move((wxPoint const &)*arg2,arg3);
25886
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 Py_INCREF(Py_None); resultobj = Py_None;
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 static PyObject *_wrap_wxWindow_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj;
25899 wxWindow *arg1 = (wxWindow *) 0 ;
25900 int arg2 ;
25901 int arg3 ;
25902 int arg4 = (int) wxSIZE_USE_EXISTING ;
25903 PyObject * obj0 = 0 ;
25904 PyObject * obj1 = 0 ;
25905 PyObject * obj2 = 0 ;
25906 PyObject * obj3 = 0 ;
25907 char *kwnames[] = {
25908 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25909 };
25910
25911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxWindow_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25913 if (SWIG_arg_fail(1)) SWIG_fail;
25914 {
25915 arg2 = (int)(SWIG_As_int(obj1));
25916 if (SWIG_arg_fail(2)) SWIG_fail;
25917 }
25918 {
25919 arg3 = (int)(SWIG_As_int(obj2));
25920 if (SWIG_arg_fail(3)) SWIG_fail;
25921 }
25922 if (obj3) {
25923 {
25924 arg4 = (int)(SWIG_As_int(obj3));
25925 if (SWIG_arg_fail(4)) SWIG_fail;
25926 }
25927 }
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 (arg1)->Move(arg2,arg3,arg4);
25931
25932 wxPyEndAllowThreads(__tstate);
25933 if (PyErr_Occurred()) SWIG_fail;
25934 }
25935 Py_INCREF(Py_None); resultobj = Py_None;
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 static PyObject *_wrap_wxWindow_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj;
25944 wxWindow *arg1 = (wxWindow *) 0 ;
25945 wxSize const &arg2_defvalue = wxDefaultSize ;
25946 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25947 wxSize temp2 ;
25948 PyObject * obj0 = 0 ;
25949 PyObject * obj1 = 0 ;
25950 char *kwnames[] = {
25951 (char *) "self",(char *) "size", NULL
25952 };
25953
25954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25956 if (SWIG_arg_fail(1)) SWIG_fail;
25957 if (obj1) {
25958 {
25959 arg2 = &temp2;
25960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25961 }
25962 }
25963 {
25964 PyThreadState* __tstate = wxPyBeginAllowThreads();
25965 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25966
25967 wxPyEndAllowThreads(__tstate);
25968 if (PyErr_Occurred()) SWIG_fail;
25969 }
25970 Py_INCREF(Py_None); resultobj = Py_None;
25971 return resultobj;
25972 fail:
25973 return NULL;
25974 }
25975
25976
25977 static PyObject *_wrap_wxWindow_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25978 PyObject *resultobj;
25979 wxWindow *arg1 = (wxWindow *) 0 ;
25980 PyObject * obj0 = 0 ;
25981 char *kwnames[] = {
25982 (char *) "self", NULL
25983 };
25984
25985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Raise",kwnames,&obj0)) goto fail;
25986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25987 if (SWIG_arg_fail(1)) SWIG_fail;
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 (arg1)->Raise();
25991
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 Py_INCREF(Py_None); resultobj = Py_None;
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 static PyObject *_wrap_wxWindow_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj;
26004 wxWindow *arg1 = (wxWindow *) 0 ;
26005 PyObject * obj0 = 0 ;
26006 char *kwnames[] = {
26007 (char *) "self", NULL
26008 };
26009
26010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Lower",kwnames,&obj0)) goto fail;
26011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26012 if (SWIG_arg_fail(1)) SWIG_fail;
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 (arg1)->Lower();
26016
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 Py_INCREF(Py_None); resultobj = Py_None;
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 static PyObject *_wrap_wxWindow_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj;
26029 wxWindow *arg1 = (wxWindow *) 0 ;
26030 wxSize *arg2 = 0 ;
26031 wxSize temp2 ;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char *kwnames[] = {
26035 (char *) "self",(char *) "size", NULL
26036 };
26037
26038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26040 if (SWIG_arg_fail(1)) SWIG_fail;
26041 {
26042 arg2 = &temp2;
26043 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26044 }
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 (arg1)->SetClientSize((wxSize const &)*arg2);
26048
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 Py_INCREF(Py_None); resultobj = Py_None;
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 static PyObject *_wrap_wxWindow_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26060 PyObject *resultobj;
26061 wxWindow *arg1 = (wxWindow *) 0 ;
26062 int arg2 ;
26063 int arg3 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 PyObject * obj2 = 0 ;
26067 char *kwnames[] = {
26068 (char *) "self",(char *) "width",(char *) "height", NULL
26069 };
26070
26071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(1)) SWIG_fail;
26074 {
26075 arg2 = (int)(SWIG_As_int(obj1));
26076 if (SWIG_arg_fail(2)) SWIG_fail;
26077 }
26078 {
26079 arg3 = (int)(SWIG_As_int(obj2));
26080 if (SWIG_arg_fail(3)) SWIG_fail;
26081 }
26082 {
26083 PyThreadState* __tstate = wxPyBeginAllowThreads();
26084 (arg1)->SetClientSize(arg2,arg3);
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 Py_INCREF(Py_None); resultobj = Py_None;
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 static PyObject *_wrap_wxWindow_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj;
26098 wxWindow *arg1 = (wxWindow *) 0 ;
26099 wxRect *arg2 = 0 ;
26100 wxRect temp2 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 char *kwnames[] = {
26104 (char *) "self",(char *) "rect", NULL
26105 };
26106
26107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(1)) SWIG_fail;
26110 {
26111 arg2 = &temp2;
26112 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26113 }
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 (arg1)->SetClientSize((wxRect const &)*arg2);
26117
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 Py_INCREF(Py_None); resultobj = Py_None;
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 static PyObject *_wrap_wxWindow_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj;
26130 wxWindow *arg1 = (wxWindow *) 0 ;
26131 wxPoint result;
26132 PyObject * obj0 = 0 ;
26133 char *kwnames[] = {
26134 (char *) "self", NULL
26135 };
26136
26137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetPosition",kwnames,&obj0)) goto fail;
26138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26139 if (SWIG_arg_fail(1)) SWIG_fail;
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 result = (arg1)->GetPosition();
26143
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 {
26148 wxPoint * resultptr;
26149 resultptr = new wxPoint((wxPoint &)(result));
26150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26151 }
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 static PyObject *_wrap_wxWindow_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj;
26160 wxWindow *arg1 = (wxWindow *) 0 ;
26161 int *arg2 = (int *) 0 ;
26162 int *arg3 = (int *) 0 ;
26163 int temp2 ;
26164 int res2 = 0 ;
26165 int temp3 ;
26166 int res3 = 0 ;
26167 PyObject * obj0 = 0 ;
26168 char *kwnames[] = {
26169 (char *) "self", NULL
26170 };
26171
26172 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26173 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetPositionTuple",kwnames,&obj0)) goto fail;
26175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26176 if (SWIG_arg_fail(1)) SWIG_fail;
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->GetPosition(arg2,arg3);
26180
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 Py_INCREF(Py_None); resultobj = Py_None;
26185 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26186 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26187 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26188 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26189 return resultobj;
26190 fail:
26191 return NULL;
26192 }
26193
26194
26195 static PyObject *_wrap_wxWindow_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26196 PyObject *resultobj;
26197 wxWindow *arg1 = (wxWindow *) 0 ;
26198 wxSize result;
26199 PyObject * obj0 = 0 ;
26200 char *kwnames[] = {
26201 (char *) "self", NULL
26202 };
26203
26204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetSize",kwnames,&obj0)) goto fail;
26205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26206 if (SWIG_arg_fail(1)) SWIG_fail;
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 result = ((wxWindow const *)arg1)->GetSize();
26210
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 {
26215 wxSize * resultptr;
26216 resultptr = new wxSize((wxSize &)(result));
26217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26218 }
26219 return resultobj;
26220 fail:
26221 return NULL;
26222 }
26223
26224
26225 static PyObject *_wrap_wxWindow_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26226 PyObject *resultobj;
26227 wxWindow *arg1 = (wxWindow *) 0 ;
26228 int *arg2 = (int *) 0 ;
26229 int *arg3 = (int *) 0 ;
26230 int temp2 ;
26231 int res2 = 0 ;
26232 int temp3 ;
26233 int res3 = 0 ;
26234 PyObject * obj0 = 0 ;
26235 char *kwnames[] = {
26236 (char *) "self", NULL
26237 };
26238
26239 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26240 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetSizeTuple",kwnames,&obj0)) goto fail;
26242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26243 if (SWIG_arg_fail(1)) SWIG_fail;
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26247
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 Py_INCREF(Py_None); resultobj = Py_None;
26252 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26253 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26254 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26255 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26256 return resultobj;
26257 fail:
26258 return NULL;
26259 }
26260
26261
26262 static PyObject *_wrap_wxWindow_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26263 PyObject *resultobj;
26264 wxWindow *arg1 = (wxWindow *) 0 ;
26265 wxRect result;
26266 PyObject * obj0 = 0 ;
26267 char *kwnames[] = {
26268 (char *) "self", NULL
26269 };
26270
26271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetRect",kwnames,&obj0)) goto fail;
26272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26273 if (SWIG_arg_fail(1)) SWIG_fail;
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = ((wxWindow const *)arg1)->GetRect();
26277
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 {
26282 wxRect * resultptr;
26283 resultptr = new wxRect((wxRect &)(result));
26284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26285 }
26286 return resultobj;
26287 fail:
26288 return NULL;
26289 }
26290
26291
26292 static PyObject *_wrap_wxWindow_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26293 PyObject *resultobj;
26294 wxWindow *arg1 = (wxWindow *) 0 ;
26295 wxSize result;
26296 PyObject * obj0 = 0 ;
26297 char *kwnames[] = {
26298 (char *) "self", NULL
26299 };
26300
26301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetClientSize",kwnames,&obj0)) goto fail;
26302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26303 if (SWIG_arg_fail(1)) SWIG_fail;
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = ((wxWindow const *)arg1)->GetClientSize();
26307
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 {
26312 wxSize * resultptr;
26313 resultptr = new wxSize((wxSize &)(result));
26314 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26315 }
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 static PyObject *_wrap_wxWindow_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj;
26324 wxWindow *arg1 = (wxWindow *) 0 ;
26325 int *arg2 = (int *) 0 ;
26326 int *arg3 = (int *) 0 ;
26327 int temp2 ;
26328 int res2 = 0 ;
26329 int temp3 ;
26330 int res3 = 0 ;
26331 PyObject * obj0 = 0 ;
26332 char *kwnames[] = {
26333 (char *) "self", NULL
26334 };
26335
26336 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26337 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26340 if (SWIG_arg_fail(1)) SWIG_fail;
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26344
26345 wxPyEndAllowThreads(__tstate);
26346 if (PyErr_Occurred()) SWIG_fail;
26347 }
26348 Py_INCREF(Py_None); resultobj = Py_None;
26349 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26350 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26351 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26352 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26353 return resultobj;
26354 fail:
26355 return NULL;
26356 }
26357
26358
26359 static PyObject *_wrap_wxWindow_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26360 PyObject *resultobj;
26361 wxWindow *arg1 = (wxWindow *) 0 ;
26362 wxPoint result;
26363 PyObject * obj0 = 0 ;
26364 char *kwnames[] = {
26365 (char *) "self", NULL
26366 };
26367
26368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26370 if (SWIG_arg_fail(1)) SWIG_fail;
26371 {
26372 PyThreadState* __tstate = wxPyBeginAllowThreads();
26373 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26374
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 {
26379 wxPoint * resultptr;
26380 resultptr = new wxPoint((wxPoint &)(result));
26381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26382 }
26383 return resultobj;
26384 fail:
26385 return NULL;
26386 }
26387
26388
26389 static PyObject *_wrap_wxWindow_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26390 PyObject *resultobj;
26391 wxWindow *arg1 = (wxWindow *) 0 ;
26392 wxRect result;
26393 PyObject * obj0 = 0 ;
26394 char *kwnames[] = {
26395 (char *) "self", NULL
26396 };
26397
26398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetClientRect",kwnames,&obj0)) goto fail;
26399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26400 if (SWIG_arg_fail(1)) SWIG_fail;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = ((wxWindow const *)arg1)->GetClientRect();
26404
26405 wxPyEndAllowThreads(__tstate);
26406 if (PyErr_Occurred()) SWIG_fail;
26407 }
26408 {
26409 wxRect * resultptr;
26410 resultptr = new wxRect((wxRect &)(result));
26411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26412 }
26413 return resultobj;
26414 fail:
26415 return NULL;
26416 }
26417
26418
26419 static PyObject *_wrap_wxWindow_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26420 PyObject *resultobj;
26421 wxWindow *arg1 = (wxWindow *) 0 ;
26422 wxSize result;
26423 PyObject * obj0 = 0 ;
26424 char *kwnames[] = {
26425 (char *) "self", NULL
26426 };
26427
26428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetBestSize",kwnames,&obj0)) goto fail;
26429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26430 if (SWIG_arg_fail(1)) SWIG_fail;
26431 {
26432 PyThreadState* __tstate = wxPyBeginAllowThreads();
26433 result = ((wxWindow const *)arg1)->GetBestSize();
26434
26435 wxPyEndAllowThreads(__tstate);
26436 if (PyErr_Occurred()) SWIG_fail;
26437 }
26438 {
26439 wxSize * resultptr;
26440 resultptr = new wxSize((wxSize &)(result));
26441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26442 }
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 static PyObject *_wrap_wxWindow_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26450 PyObject *resultobj;
26451 wxWindow *arg1 = (wxWindow *) 0 ;
26452 int *arg2 = (int *) 0 ;
26453 int *arg3 = (int *) 0 ;
26454 int temp2 ;
26455 int res2 = 0 ;
26456 int temp3 ;
26457 int res3 = 0 ;
26458 PyObject * obj0 = 0 ;
26459 char *kwnames[] = {
26460 (char *) "self", NULL
26461 };
26462
26463 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26464 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26467 if (SWIG_arg_fail(1)) SWIG_fail;
26468 {
26469 PyThreadState* __tstate = wxPyBeginAllowThreads();
26470 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26471
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 Py_INCREF(Py_None); resultobj = Py_None;
26476 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26477 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26478 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26479 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26480 return resultobj;
26481 fail:
26482 return NULL;
26483 }
26484
26485
26486 static PyObject *_wrap_wxWindow_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26487 PyObject *resultobj;
26488 wxWindow *arg1 = (wxWindow *) 0 ;
26489 PyObject * obj0 = 0 ;
26490 char *kwnames[] = {
26491 (char *) "self", NULL
26492 };
26493
26494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_InvalidateBestSize",kwnames,&obj0)) goto fail;
26495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26496 if (SWIG_arg_fail(1)) SWIG_fail;
26497 {
26498 PyThreadState* __tstate = wxPyBeginAllowThreads();
26499 (arg1)->InvalidateBestSize();
26500
26501 wxPyEndAllowThreads(__tstate);
26502 if (PyErr_Occurred()) SWIG_fail;
26503 }
26504 Py_INCREF(Py_None); resultobj = Py_None;
26505 return resultobj;
26506 fail:
26507 return NULL;
26508 }
26509
26510
26511 static PyObject *_wrap_wxWindow_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26512 PyObject *resultobj;
26513 wxWindow *arg1 = (wxWindow *) 0 ;
26514 wxSize result;
26515 PyObject * obj0 = 0 ;
26516 char *kwnames[] = {
26517 (char *) "self", NULL
26518 };
26519
26520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetBestFittingSize",kwnames,&obj0)) goto fail;
26521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26522 if (SWIG_arg_fail(1)) SWIG_fail;
26523 {
26524 PyThreadState* __tstate = wxPyBeginAllowThreads();
26525 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26526
26527 wxPyEndAllowThreads(__tstate);
26528 if (PyErr_Occurred()) SWIG_fail;
26529 }
26530 {
26531 wxSize * resultptr;
26532 resultptr = new wxSize((wxSize &)(result));
26533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26534 }
26535 return resultobj;
26536 fail:
26537 return NULL;
26538 }
26539
26540
26541 static PyObject *_wrap_wxWindow_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26542 PyObject *resultobj;
26543 wxWindow *arg1 = (wxWindow *) 0 ;
26544 wxSize result;
26545 PyObject * obj0 = 0 ;
26546 char *kwnames[] = {
26547 (char *) "self", NULL
26548 };
26549
26550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26552 if (SWIG_arg_fail(1)) SWIG_fail;
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26556
26557 wxPyEndAllowThreads(__tstate);
26558 if (PyErr_Occurred()) SWIG_fail;
26559 }
26560 {
26561 wxSize * resultptr;
26562 resultptr = new wxSize((wxSize &)(result));
26563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26564 }
26565 return resultobj;
26566 fail:
26567 return NULL;
26568 }
26569
26570
26571 static PyObject *_wrap_wxWindow_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26572 PyObject *resultobj;
26573 wxWindow *arg1 = (wxWindow *) 0 ;
26574 int arg2 = (int) wxBOTH ;
26575 PyObject * obj0 = 0 ;
26576 PyObject * obj1 = 0 ;
26577 char *kwnames[] = {
26578 (char *) "self",(char *) "direction", NULL
26579 };
26580
26581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_Center",kwnames,&obj0,&obj1)) goto fail;
26582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26583 if (SWIG_arg_fail(1)) SWIG_fail;
26584 if (obj1) {
26585 {
26586 arg2 = (int)(SWIG_As_int(obj1));
26587 if (SWIG_arg_fail(2)) SWIG_fail;
26588 }
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 (arg1)->Center(arg2);
26593
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 Py_INCREF(Py_None); resultobj = Py_None;
26598 return resultobj;
26599 fail:
26600 return NULL;
26601 }
26602
26603
26604 static PyObject *_wrap_wxWindow_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26605 PyObject *resultobj;
26606 wxWindow *arg1 = (wxWindow *) 0 ;
26607 int arg2 = (int) wxBOTH ;
26608 PyObject * obj0 = 0 ;
26609 PyObject * obj1 = 0 ;
26610 char *kwnames[] = {
26611 (char *) "self",(char *) "dir", NULL
26612 };
26613
26614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26616 if (SWIG_arg_fail(1)) SWIG_fail;
26617 if (obj1) {
26618 {
26619 arg2 = (int)(SWIG_As_int(obj1));
26620 if (SWIG_arg_fail(2)) SWIG_fail;
26621 }
26622 }
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 (arg1)->CenterOnScreen(arg2);
26626
26627 wxPyEndAllowThreads(__tstate);
26628 if (PyErr_Occurred()) SWIG_fail;
26629 }
26630 Py_INCREF(Py_None); resultobj = Py_None;
26631 return resultobj;
26632 fail:
26633 return NULL;
26634 }
26635
26636
26637 static PyObject *_wrap_wxWindow_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26638 PyObject *resultobj;
26639 wxWindow *arg1 = (wxWindow *) 0 ;
26640 int arg2 = (int) wxBOTH ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char *kwnames[] = {
26644 (char *) "self",(char *) "dir", NULL
26645 };
26646
26647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26649 if (SWIG_arg_fail(1)) SWIG_fail;
26650 if (obj1) {
26651 {
26652 arg2 = (int)(SWIG_As_int(obj1));
26653 if (SWIG_arg_fail(2)) SWIG_fail;
26654 }
26655 }
26656 {
26657 PyThreadState* __tstate = wxPyBeginAllowThreads();
26658 (arg1)->CenterOnParent(arg2);
26659
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 Py_INCREF(Py_None); resultobj = Py_None;
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 static PyObject *_wrap_wxWindow_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26671 PyObject *resultobj;
26672 wxWindow *arg1 = (wxWindow *) 0 ;
26673 PyObject * obj0 = 0 ;
26674 char *kwnames[] = {
26675 (char *) "self", NULL
26676 };
26677
26678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Fit",kwnames,&obj0)) goto fail;
26679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26680 if (SWIG_arg_fail(1)) SWIG_fail;
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 (arg1)->Fit();
26684
26685 wxPyEndAllowThreads(__tstate);
26686 if (PyErr_Occurred()) SWIG_fail;
26687 }
26688 Py_INCREF(Py_None); resultobj = Py_None;
26689 return resultobj;
26690 fail:
26691 return NULL;
26692 }
26693
26694
26695 static PyObject *_wrap_wxWindow_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26696 PyObject *resultobj;
26697 wxWindow *arg1 = (wxWindow *) 0 ;
26698 PyObject * obj0 = 0 ;
26699 char *kwnames[] = {
26700 (char *) "self", NULL
26701 };
26702
26703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_FitInside",kwnames,&obj0)) goto fail;
26704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26705 if (SWIG_arg_fail(1)) SWIG_fail;
26706 {
26707 PyThreadState* __tstate = wxPyBeginAllowThreads();
26708 (arg1)->FitInside();
26709
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 Py_INCREF(Py_None); resultobj = Py_None;
26714 return resultobj;
26715 fail:
26716 return NULL;
26717 }
26718
26719
26720 static PyObject *_wrap_wxWindow_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26721 PyObject *resultobj;
26722 wxWindow *arg1 = (wxWindow *) 0 ;
26723 int arg2 ;
26724 int arg3 ;
26725 int arg4 = (int) -1 ;
26726 int arg5 = (int) -1 ;
26727 int arg6 = (int) -1 ;
26728 int arg7 = (int) -1 ;
26729 PyObject * obj0 = 0 ;
26730 PyObject * obj1 = 0 ;
26731 PyObject * obj2 = 0 ;
26732 PyObject * obj3 = 0 ;
26733 PyObject * obj4 = 0 ;
26734 PyObject * obj5 = 0 ;
26735 PyObject * obj6 = 0 ;
26736 char *kwnames[] = {
26737 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26738 };
26739
26740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:wxWindow_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26742 if (SWIG_arg_fail(1)) SWIG_fail;
26743 {
26744 arg2 = (int)(SWIG_As_int(obj1));
26745 if (SWIG_arg_fail(2)) SWIG_fail;
26746 }
26747 {
26748 arg3 = (int)(SWIG_As_int(obj2));
26749 if (SWIG_arg_fail(3)) SWIG_fail;
26750 }
26751 if (obj3) {
26752 {
26753 arg4 = (int)(SWIG_As_int(obj3));
26754 if (SWIG_arg_fail(4)) SWIG_fail;
26755 }
26756 }
26757 if (obj4) {
26758 {
26759 arg5 = (int)(SWIG_As_int(obj4));
26760 if (SWIG_arg_fail(5)) SWIG_fail;
26761 }
26762 }
26763 if (obj5) {
26764 {
26765 arg6 = (int)(SWIG_As_int(obj5));
26766 if (SWIG_arg_fail(6)) SWIG_fail;
26767 }
26768 }
26769 if (obj6) {
26770 {
26771 arg7 = (int)(SWIG_As_int(obj6));
26772 if (SWIG_arg_fail(7)) SWIG_fail;
26773 }
26774 }
26775 {
26776 PyThreadState* __tstate = wxPyBeginAllowThreads();
26777 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26778
26779 wxPyEndAllowThreads(__tstate);
26780 if (PyErr_Occurred()) SWIG_fail;
26781 }
26782 Py_INCREF(Py_None); resultobj = Py_None;
26783 return resultobj;
26784 fail:
26785 return NULL;
26786 }
26787
26788
26789 static PyObject *_wrap_wxWindow_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26790 PyObject *resultobj;
26791 wxWindow *arg1 = (wxWindow *) 0 ;
26792 wxSize *arg2 = 0 ;
26793 wxSize const &arg3_defvalue = wxDefaultSize ;
26794 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26795 wxSize const &arg4_defvalue = wxDefaultSize ;
26796 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26797 wxSize temp2 ;
26798 wxSize temp3 ;
26799 wxSize temp4 ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 PyObject * obj2 = 0 ;
26803 PyObject * obj3 = 0 ;
26804 char *kwnames[] = {
26805 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26806 };
26807
26808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxWindow_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26810 if (SWIG_arg_fail(1)) SWIG_fail;
26811 {
26812 arg2 = &temp2;
26813 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26814 }
26815 if (obj2) {
26816 {
26817 arg3 = &temp3;
26818 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26819 }
26820 }
26821 if (obj3) {
26822 {
26823 arg4 = &temp4;
26824 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26825 }
26826 }
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 Py_INCREF(Py_None); resultobj = Py_None;
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 static PyObject *_wrap_wxWindow_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj;
26843 wxWindow *arg1 = (wxWindow *) 0 ;
26844 int arg2 ;
26845 int arg3 ;
26846 int arg4 = (int) -1 ;
26847 int arg5 = (int) -1 ;
26848 PyObject * obj0 = 0 ;
26849 PyObject * obj1 = 0 ;
26850 PyObject * obj2 = 0 ;
26851 PyObject * obj3 = 0 ;
26852 PyObject * obj4 = 0 ;
26853 char *kwnames[] = {
26854 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26855 };
26856
26857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:wxWindow_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26859 if (SWIG_arg_fail(1)) SWIG_fail;
26860 {
26861 arg2 = (int)(SWIG_As_int(obj1));
26862 if (SWIG_arg_fail(2)) SWIG_fail;
26863 }
26864 {
26865 arg3 = (int)(SWIG_As_int(obj2));
26866 if (SWIG_arg_fail(3)) SWIG_fail;
26867 }
26868 if (obj3) {
26869 {
26870 arg4 = (int)(SWIG_As_int(obj3));
26871 if (SWIG_arg_fail(4)) SWIG_fail;
26872 }
26873 }
26874 if (obj4) {
26875 {
26876 arg5 = (int)(SWIG_As_int(obj4));
26877 if (SWIG_arg_fail(5)) SWIG_fail;
26878 }
26879 }
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 Py_INCREF(Py_None); resultobj = Py_None;
26888 return resultobj;
26889 fail:
26890 return NULL;
26891 }
26892
26893
26894 static PyObject *_wrap_wxWindow_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj;
26896 wxWindow *arg1 = (wxWindow *) 0 ;
26897 wxSize *arg2 = 0 ;
26898 wxSize const &arg3_defvalue = wxDefaultSize ;
26899 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26900 wxSize temp2 ;
26901 wxSize temp3 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 PyObject * obj2 = 0 ;
26905 char *kwnames[] = {
26906 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26907 };
26908
26909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26911 if (SWIG_arg_fail(1)) SWIG_fail;
26912 {
26913 arg2 = &temp2;
26914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26915 }
26916 if (obj2) {
26917 {
26918 arg3 = &temp3;
26919 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26920 }
26921 }
26922 {
26923 PyThreadState* __tstate = wxPyBeginAllowThreads();
26924 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26925
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 Py_INCREF(Py_None); resultobj = Py_None;
26930 return resultobj;
26931 fail:
26932 return NULL;
26933 }
26934
26935
26936 static PyObject *_wrap_wxWindow_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26937 PyObject *resultobj;
26938 wxWindow *arg1 = (wxWindow *) 0 ;
26939 wxSize result;
26940 PyObject * obj0 = 0 ;
26941 char *kwnames[] = {
26942 (char *) "self", NULL
26943 };
26944
26945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetMaxSize",kwnames,&obj0)) goto fail;
26946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26947 if (SWIG_arg_fail(1)) SWIG_fail;
26948 {
26949 PyThreadState* __tstate = wxPyBeginAllowThreads();
26950 result = ((wxWindow const *)arg1)->GetMaxSize();
26951
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 {
26956 wxSize * resultptr;
26957 resultptr = new wxSize((wxSize &)(result));
26958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26959 }
26960 return resultobj;
26961 fail:
26962 return NULL;
26963 }
26964
26965
26966 static PyObject *_wrap_wxWindow_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj;
26968 wxWindow *arg1 = (wxWindow *) 0 ;
26969 wxSize result;
26970 PyObject * obj0 = 0 ;
26971 char *kwnames[] = {
26972 (char *) "self", NULL
26973 };
26974
26975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetMinSize",kwnames,&obj0)) goto fail;
26976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26977 if (SWIG_arg_fail(1)) SWIG_fail;
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 result = ((wxWindow const *)arg1)->GetMinSize();
26981
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 {
26986 wxSize * resultptr;
26987 resultptr = new wxSize((wxSize &)(result));
26988 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26989 }
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 static PyObject *_wrap_wxWindow_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj;
26998 wxWindow *arg1 = (wxWindow *) 0 ;
26999 wxSize *arg2 = 0 ;
27000 wxSize temp2 ;
27001 PyObject * obj0 = 0 ;
27002 PyObject * obj1 = 0 ;
27003 char *kwnames[] = {
27004 (char *) "self",(char *) "minSize", NULL
27005 };
27006
27007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27009 if (SWIG_arg_fail(1)) SWIG_fail;
27010 {
27011 arg2 = &temp2;
27012 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27013 }
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 (arg1)->SetMinSize((wxSize const &)*arg2);
27017
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 Py_INCREF(Py_None); resultobj = Py_None;
27022 return resultobj;
27023 fail:
27024 return NULL;
27025 }
27026
27027
27028 static PyObject *_wrap_wxWindow_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj;
27030 wxWindow *arg1 = (wxWindow *) 0 ;
27031 wxSize *arg2 = 0 ;
27032 wxSize temp2 ;
27033 PyObject * obj0 = 0 ;
27034 PyObject * obj1 = 0 ;
27035 char *kwnames[] = {
27036 (char *) "self",(char *) "maxSize", NULL
27037 };
27038
27039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27041 if (SWIG_arg_fail(1)) SWIG_fail;
27042 {
27043 arg2 = &temp2;
27044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27045 }
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 (arg1)->SetMaxSize((wxSize const &)*arg2);
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 Py_INCREF(Py_None); resultobj = Py_None;
27054 return resultobj;
27055 fail:
27056 return NULL;
27057 }
27058
27059
27060 static PyObject *_wrap_wxWindow_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27061 PyObject *resultobj;
27062 wxWindow *arg1 = (wxWindow *) 0 ;
27063 int result;
27064 PyObject * obj0 = 0 ;
27065 char *kwnames[] = {
27066 (char *) "self", NULL
27067 };
27068
27069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetMinWidth",kwnames,&obj0)) goto fail;
27070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27071 if (SWIG_arg_fail(1)) SWIG_fail;
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27075
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 {
27080 resultobj = SWIG_From_int((int)(result));
27081 }
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 static PyObject *_wrap_wxWindow_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj;
27090 wxWindow *arg1 = (wxWindow *) 0 ;
27091 int result;
27092 PyObject * obj0 = 0 ;
27093 char *kwnames[] = {
27094 (char *) "self", NULL
27095 };
27096
27097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetMinHeight",kwnames,&obj0)) goto fail;
27098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27099 if (SWIG_arg_fail(1)) SWIG_fail;
27100 {
27101 PyThreadState* __tstate = wxPyBeginAllowThreads();
27102 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27103
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 {
27108 resultobj = SWIG_From_int((int)(result));
27109 }
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 static PyObject *_wrap_wxWindow_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj;
27118 wxWindow *arg1 = (wxWindow *) 0 ;
27119 int result;
27120 PyObject * obj0 = 0 ;
27121 char *kwnames[] = {
27122 (char *) "self", NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetMaxWidth",kwnames,&obj0)) goto fail;
27126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(1)) SWIG_fail;
27128 {
27129 PyThreadState* __tstate = wxPyBeginAllowThreads();
27130 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27131
27132 wxPyEndAllowThreads(__tstate);
27133 if (PyErr_Occurred()) SWIG_fail;
27134 }
27135 {
27136 resultobj = SWIG_From_int((int)(result));
27137 }
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 static PyObject *_wrap_wxWindow_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj;
27146 wxWindow *arg1 = (wxWindow *) 0 ;
27147 int result;
27148 PyObject * obj0 = 0 ;
27149 char *kwnames[] = {
27150 (char *) "self", NULL
27151 };
27152
27153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetMaxHeight",kwnames,&obj0)) goto fail;
27154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27155 if (SWIG_arg_fail(1)) SWIG_fail;
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27159
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 {
27164 resultobj = SWIG_From_int((int)(result));
27165 }
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 static PyObject *_wrap_wxWindow_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj;
27174 wxWindow *arg1 = (wxWindow *) 0 ;
27175 wxSize *arg2 = 0 ;
27176 wxSize temp2 ;
27177 PyObject * obj0 = 0 ;
27178 PyObject * obj1 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self",(char *) "size", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 arg2 = &temp2;
27188 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27189 }
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27193
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 Py_INCREF(Py_None); resultobj = Py_None;
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 static PyObject *_wrap_wxWindow_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj;
27206 wxWindow *arg1 = (wxWindow *) 0 ;
27207 int arg2 ;
27208 int arg3 ;
27209 PyObject * obj0 = 0 ;
27210 PyObject * obj1 = 0 ;
27211 PyObject * obj2 = 0 ;
27212 char *kwnames[] = {
27213 (char *) "self",(char *) "w",(char *) "h", NULL
27214 };
27215
27216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27218 if (SWIG_arg_fail(1)) SWIG_fail;
27219 {
27220 arg2 = (int)(SWIG_As_int(obj1));
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 }
27223 {
27224 arg3 = (int)(SWIG_As_int(obj2));
27225 if (SWIG_arg_fail(3)) SWIG_fail;
27226 }
27227 {
27228 PyThreadState* __tstate = wxPyBeginAllowThreads();
27229 (arg1)->SetVirtualSize(arg2,arg3);
27230
27231 wxPyEndAllowThreads(__tstate);
27232 if (PyErr_Occurred()) SWIG_fail;
27233 }
27234 Py_INCREF(Py_None); resultobj = Py_None;
27235 return resultobj;
27236 fail:
27237 return NULL;
27238 }
27239
27240
27241 static PyObject *_wrap_wxWindow_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27242 PyObject *resultobj;
27243 wxWindow *arg1 = (wxWindow *) 0 ;
27244 wxSize result;
27245 PyObject * obj0 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetVirtualSize",kwnames,&obj0)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 result = ((wxWindow const *)arg1)->GetVirtualSize();
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 {
27261 wxSize * resultptr;
27262 resultptr = new wxSize((wxSize &)(result));
27263 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27264 }
27265 return resultobj;
27266 fail:
27267 return NULL;
27268 }
27269
27270
27271 static PyObject *_wrap_wxWindow_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27272 PyObject *resultobj;
27273 wxWindow *arg1 = (wxWindow *) 0 ;
27274 int *arg2 = (int *) 0 ;
27275 int *arg3 = (int *) 0 ;
27276 int temp2 ;
27277 int res2 = 0 ;
27278 int temp3 ;
27279 int res3 = 0 ;
27280 PyObject * obj0 = 0 ;
27281 char *kwnames[] = {
27282 (char *) "self", NULL
27283 };
27284
27285 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27286 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27289 if (SWIG_arg_fail(1)) SWIG_fail;
27290 {
27291 PyThreadState* __tstate = wxPyBeginAllowThreads();
27292 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27293
27294 wxPyEndAllowThreads(__tstate);
27295 if (PyErr_Occurred()) SWIG_fail;
27296 }
27297 Py_INCREF(Py_None); resultobj = Py_None;
27298 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27299 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27300 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27301 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 static PyObject *_wrap_wxWindow_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27309 PyObject *resultobj;
27310 wxWindow *arg1 = (wxWindow *) 0 ;
27311 wxSize result;
27312 PyObject * obj0 = 0 ;
27313 char *kwnames[] = {
27314 (char *) "self", NULL
27315 };
27316
27317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27319 if (SWIG_arg_fail(1)) SWIG_fail;
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27323
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 {
27328 wxSize * resultptr;
27329 resultptr = new wxSize((wxSize &)(result));
27330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27331 }
27332 return resultobj;
27333 fail:
27334 return NULL;
27335 }
27336
27337
27338 static PyObject *_wrap_wxWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27339 PyObject *resultobj;
27340 wxWindow *arg1 = (wxWindow *) 0 ;
27341 bool arg2 = (bool) true ;
27342 bool result;
27343 PyObject * obj0 = 0 ;
27344 PyObject * obj1 = 0 ;
27345 char *kwnames[] = {
27346 (char *) "self",(char *) "show", NULL
27347 };
27348
27349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_Show",kwnames,&obj0,&obj1)) goto fail;
27350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27351 if (SWIG_arg_fail(1)) SWIG_fail;
27352 if (obj1) {
27353 {
27354 arg2 = (bool)(SWIG_As_bool(obj1));
27355 if (SWIG_arg_fail(2)) SWIG_fail;
27356 }
27357 }
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 result = (bool)(arg1)->Show(arg2);
27361
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 {
27366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27367 }
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 static PyObject *_wrap_wxWindow_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj;
27376 wxWindow *arg1 = (wxWindow *) 0 ;
27377 bool result;
27378 PyObject * obj0 = 0 ;
27379 char *kwnames[] = {
27380 (char *) "self", NULL
27381 };
27382
27383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Hide",kwnames,&obj0)) goto fail;
27384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27385 if (SWIG_arg_fail(1)) SWIG_fail;
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (bool)(arg1)->Hide();
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 {
27394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27395 }
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 static PyObject *_wrap_wxWindow_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27403 PyObject *resultobj;
27404 wxWindow *arg1 = (wxWindow *) 0 ;
27405 bool arg2 = (bool) true ;
27406 bool result;
27407 PyObject * obj0 = 0 ;
27408 PyObject * obj1 = 0 ;
27409 char *kwnames[] = {
27410 (char *) "self",(char *) "enable", NULL
27411 };
27412
27413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_Enable",kwnames,&obj0,&obj1)) goto fail;
27414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27415 if (SWIG_arg_fail(1)) SWIG_fail;
27416 if (obj1) {
27417 {
27418 arg2 = (bool)(SWIG_As_bool(obj1));
27419 if (SWIG_arg_fail(2)) SWIG_fail;
27420 }
27421 }
27422 {
27423 PyThreadState* __tstate = wxPyBeginAllowThreads();
27424 result = (bool)(arg1)->Enable(arg2);
27425
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 {
27430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27431 }
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 static PyObject *_wrap_wxWindow_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27439 PyObject *resultobj;
27440 wxWindow *arg1 = (wxWindow *) 0 ;
27441 bool result;
27442 PyObject * obj0 = 0 ;
27443 char *kwnames[] = {
27444 (char *) "self", NULL
27445 };
27446
27447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Disable",kwnames,&obj0)) goto fail;
27448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27449 if (SWIG_arg_fail(1)) SWIG_fail;
27450 {
27451 PyThreadState* __tstate = wxPyBeginAllowThreads();
27452 result = (bool)(arg1)->Disable();
27453
27454 wxPyEndAllowThreads(__tstate);
27455 if (PyErr_Occurred()) SWIG_fail;
27456 }
27457 {
27458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27459 }
27460 return resultobj;
27461 fail:
27462 return NULL;
27463 }
27464
27465
27466 static PyObject *_wrap_wxWindow_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27467 PyObject *resultobj;
27468 wxWindow *arg1 = (wxWindow *) 0 ;
27469 bool result;
27470 PyObject * obj0 = 0 ;
27471 char *kwnames[] = {
27472 (char *) "self", NULL
27473 };
27474
27475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_IsShown",kwnames,&obj0)) goto fail;
27476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27477 if (SWIG_arg_fail(1)) SWIG_fail;
27478 {
27479 PyThreadState* __tstate = wxPyBeginAllowThreads();
27480 result = (bool)((wxWindow const *)arg1)->IsShown();
27481
27482 wxPyEndAllowThreads(__tstate);
27483 if (PyErr_Occurred()) SWIG_fail;
27484 }
27485 {
27486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27487 }
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 static PyObject *_wrap_wxWindow_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj;
27496 wxWindow *arg1 = (wxWindow *) 0 ;
27497 bool result;
27498 PyObject * obj0 = 0 ;
27499 char *kwnames[] = {
27500 (char *) "self", NULL
27501 };
27502
27503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_IsEnabled",kwnames,&obj0)) goto fail;
27504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27505 if (SWIG_arg_fail(1)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 {
27514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27515 }
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 static PyObject *_wrap_wxWindow_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj;
27524 wxWindow *arg1 = (wxWindow *) 0 ;
27525 long arg2 ;
27526 PyObject * obj0 = 0 ;
27527 PyObject * obj1 = 0 ;
27528 char *kwnames[] = {
27529 (char *) "self",(char *) "style", NULL
27530 };
27531
27532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27534 if (SWIG_arg_fail(1)) SWIG_fail;
27535 {
27536 arg2 = (long)(SWIG_As_long(obj1));
27537 if (SWIG_arg_fail(2)) SWIG_fail;
27538 }
27539 {
27540 PyThreadState* __tstate = wxPyBeginAllowThreads();
27541 (arg1)->SetWindowStyleFlag(arg2);
27542
27543 wxPyEndAllowThreads(__tstate);
27544 if (PyErr_Occurred()) SWIG_fail;
27545 }
27546 Py_INCREF(Py_None); resultobj = Py_None;
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 static PyObject *_wrap_wxWindow_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27554 PyObject *resultobj;
27555 wxWindow *arg1 = (wxWindow *) 0 ;
27556 long result;
27557 PyObject * obj0 = 0 ;
27558 char *kwnames[] = {
27559 (char *) "self", NULL
27560 };
27561
27562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(1)) SWIG_fail;
27565 {
27566 PyThreadState* __tstate = wxPyBeginAllowThreads();
27567 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27568
27569 wxPyEndAllowThreads(__tstate);
27570 if (PyErr_Occurred()) SWIG_fail;
27571 }
27572 {
27573 resultobj = SWIG_From_long((long)(result));
27574 }
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 static PyObject *_wrap_wxWindow_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27582 PyObject *resultobj;
27583 wxWindow *arg1 = (wxWindow *) 0 ;
27584 int arg2 ;
27585 bool result;
27586 PyObject * obj0 = 0 ;
27587 PyObject * obj1 = 0 ;
27588 char *kwnames[] = {
27589 (char *) "self",(char *) "flag", NULL
27590 };
27591
27592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27594 if (SWIG_arg_fail(1)) SWIG_fail;
27595 {
27596 arg2 = (int)(SWIG_As_int(obj1));
27597 if (SWIG_arg_fail(2)) SWIG_fail;
27598 }
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27602
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 {
27607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27608 }
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 static PyObject *_wrap_wxWindow_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27616 PyObject *resultobj;
27617 wxWindow *arg1 = (wxWindow *) 0 ;
27618 bool result;
27619 PyObject * obj0 = 0 ;
27620 char *kwnames[] = {
27621 (char *) "self", NULL
27622 };
27623
27624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_IsRetained",kwnames,&obj0)) goto fail;
27625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27626 if (SWIG_arg_fail(1)) SWIG_fail;
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 result = (bool)((wxWindow const *)arg1)->IsRetained();
27630
27631 wxPyEndAllowThreads(__tstate);
27632 if (PyErr_Occurred()) SWIG_fail;
27633 }
27634 {
27635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27636 }
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 static PyObject *_wrap_wxWindow_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27644 PyObject *resultobj;
27645 wxWindow *arg1 = (wxWindow *) 0 ;
27646 long arg2 ;
27647 PyObject * obj0 = 0 ;
27648 PyObject * obj1 = 0 ;
27649 char *kwnames[] = {
27650 (char *) "self",(char *) "exStyle", NULL
27651 };
27652
27653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27655 if (SWIG_arg_fail(1)) SWIG_fail;
27656 {
27657 arg2 = (long)(SWIG_As_long(obj1));
27658 if (SWIG_arg_fail(2)) SWIG_fail;
27659 }
27660 {
27661 PyThreadState* __tstate = wxPyBeginAllowThreads();
27662 (arg1)->SetExtraStyle(arg2);
27663
27664 wxPyEndAllowThreads(__tstate);
27665 if (PyErr_Occurred()) SWIG_fail;
27666 }
27667 Py_INCREF(Py_None); resultobj = Py_None;
27668 return resultobj;
27669 fail:
27670 return NULL;
27671 }
27672
27673
27674 static PyObject *_wrap_wxWindow_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27675 PyObject *resultobj;
27676 wxWindow *arg1 = (wxWindow *) 0 ;
27677 long result;
27678 PyObject * obj0 = 0 ;
27679 char *kwnames[] = {
27680 (char *) "self", NULL
27681 };
27682
27683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetExtraStyle",kwnames,&obj0)) goto fail;
27684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27685 if (SWIG_arg_fail(1)) SWIG_fail;
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27689
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 {
27694 resultobj = SWIG_From_long((long)(result));
27695 }
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 static PyObject *_wrap_wxWindow_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27703 PyObject *resultobj;
27704 wxWindow *arg1 = (wxWindow *) 0 ;
27705 bool arg2 = (bool) true ;
27706 PyObject * obj0 = 0 ;
27707 PyObject * obj1 = 0 ;
27708 char *kwnames[] = {
27709 (char *) "self",(char *) "modal", NULL
27710 };
27711
27712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27714 if (SWIG_arg_fail(1)) SWIG_fail;
27715 if (obj1) {
27716 {
27717 arg2 = (bool)(SWIG_As_bool(obj1));
27718 if (SWIG_arg_fail(2)) SWIG_fail;
27719 }
27720 }
27721 {
27722 PyThreadState* __tstate = wxPyBeginAllowThreads();
27723 (arg1)->MakeModal(arg2);
27724
27725 wxPyEndAllowThreads(__tstate);
27726 if (PyErr_Occurred()) SWIG_fail;
27727 }
27728 Py_INCREF(Py_None); resultobj = Py_None;
27729 return resultobj;
27730 fail:
27731 return NULL;
27732 }
27733
27734
27735 static PyObject *_wrap_wxWindow_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27736 PyObject *resultobj;
27737 wxWindow *arg1 = (wxWindow *) 0 ;
27738 bool arg2 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char *kwnames[] = {
27742 (char *) "self",(char *) "enableTheme", NULL
27743 };
27744
27745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27747 if (SWIG_arg_fail(1)) SWIG_fail;
27748 {
27749 arg2 = (bool)(SWIG_As_bool(obj1));
27750 if (SWIG_arg_fail(2)) SWIG_fail;
27751 }
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 (arg1)->SetThemeEnabled(arg2);
27755
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 Py_INCREF(Py_None); resultobj = Py_None;
27760 return resultobj;
27761 fail:
27762 return NULL;
27763 }
27764
27765
27766 static PyObject *_wrap_wxWindow_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27767 PyObject *resultobj;
27768 wxWindow *arg1 = (wxWindow *) 0 ;
27769 bool result;
27770 PyObject * obj0 = 0 ;
27771 char *kwnames[] = {
27772 (char *) "self", NULL
27773 };
27774
27775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetThemeEnabled",kwnames,&obj0)) goto fail;
27776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27777 if (SWIG_arg_fail(1)) SWIG_fail;
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27781
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 {
27786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27787 }
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 static PyObject *_wrap_wxWindow_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27795 PyObject *resultobj;
27796 wxWindow *arg1 = (wxWindow *) 0 ;
27797 PyObject * obj0 = 0 ;
27798 char *kwnames[] = {
27799 (char *) "self", NULL
27800 };
27801
27802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_SetFocus",kwnames,&obj0)) goto fail;
27803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27804 if (SWIG_arg_fail(1)) SWIG_fail;
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 (arg1)->SetFocus();
27808
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 Py_INCREF(Py_None); resultobj = Py_None;
27813 return resultobj;
27814 fail:
27815 return NULL;
27816 }
27817
27818
27819 static PyObject *_wrap_wxWindow_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27820 PyObject *resultobj;
27821 wxWindow *arg1 = (wxWindow *) 0 ;
27822 PyObject * obj0 = 0 ;
27823 char *kwnames[] = {
27824 (char *) "self", NULL
27825 };
27826
27827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27829 if (SWIG_arg_fail(1)) SWIG_fail;
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 (arg1)->SetFocusFromKbd();
27833
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 Py_INCREF(Py_None); resultobj = Py_None;
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 static PyObject *_wrap_wxWindow_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj;
27846 wxWindow *result;
27847 char *kwnames[] = {
27848 NULL
27849 };
27850
27851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxWindow_FindFocus",kwnames)) goto fail;
27852 {
27853 if (!wxPyCheckForApp()) SWIG_fail;
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 result = (wxWindow *)wxWindow::FindFocus();
27856
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 {
27861 resultobj = wxPyMake_wxObject(result, 0);
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 static PyObject *_wrap_wxWindow_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27870 PyObject *resultobj;
27871 wxWindow *arg1 = (wxWindow *) 0 ;
27872 bool result;
27873 PyObject * obj0 = 0 ;
27874 char *kwnames[] = {
27875 (char *) "self", NULL
27876 };
27877
27878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_AcceptsFocus",kwnames,&obj0)) goto fail;
27879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27880 if (SWIG_arg_fail(1)) SWIG_fail;
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27884
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 {
27889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27890 }
27891 return resultobj;
27892 fail:
27893 return NULL;
27894 }
27895
27896
27897 static PyObject *_wrap_wxWindow_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27898 PyObject *resultobj;
27899 wxWindow *arg1 = (wxWindow *) 0 ;
27900 bool result;
27901 PyObject * obj0 = 0 ;
27902 char *kwnames[] = {
27903 (char *) "self", NULL
27904 };
27905
27906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27908 if (SWIG_arg_fail(1)) SWIG_fail;
27909 {
27910 PyThreadState* __tstate = wxPyBeginAllowThreads();
27911 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27912
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 {
27917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27918 }
27919 return resultobj;
27920 fail:
27921 return NULL;
27922 }
27923
27924
27925 static PyObject *_wrap_wxWindow_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27926 PyObject *resultobj;
27927 wxWindow *arg1 = (wxWindow *) 0 ;
27928 wxWindow *result;
27929 PyObject * obj0 = 0 ;
27930 char *kwnames[] = {
27931 (char *) "self", NULL
27932 };
27933
27934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetDefaultItem",kwnames,&obj0)) goto fail;
27935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27936 if (SWIG_arg_fail(1)) SWIG_fail;
27937 {
27938 PyThreadState* __tstate = wxPyBeginAllowThreads();
27939 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27940
27941 wxPyEndAllowThreads(__tstate);
27942 if (PyErr_Occurred()) SWIG_fail;
27943 }
27944 {
27945 resultobj = wxPyMake_wxObject(result, 0);
27946 }
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 static PyObject *_wrap_wxWindow_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27954 PyObject *resultobj;
27955 wxWindow *arg1 = (wxWindow *) 0 ;
27956 wxWindow *arg2 = (wxWindow *) 0 ;
27957 wxWindow *result;
27958 PyObject * obj0 = 0 ;
27959 PyObject * obj1 = 0 ;
27960 char *kwnames[] = {
27961 (char *) "self",(char *) "child", NULL
27962 };
27963
27964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27966 if (SWIG_arg_fail(1)) SWIG_fail;
27967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27968 if (SWIG_arg_fail(2)) SWIG_fail;
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27972
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 {
27977 resultobj = wxPyMake_wxObject(result, 0);
27978 }
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 static PyObject *_wrap_wxWindow_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj;
27987 wxWindow *arg1 = (wxWindow *) 0 ;
27988 wxWindow *arg2 = (wxWindow *) 0 ;
27989 PyObject * obj0 = 0 ;
27990 PyObject * obj1 = 0 ;
27991 char *kwnames[] = {
27992 (char *) "self",(char *) "win", NULL
27993 };
27994
27995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27997 if (SWIG_arg_fail(1)) SWIG_fail;
27998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27999 if (SWIG_arg_fail(2)) SWIG_fail;
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 (arg1)->SetTmpDefaultItem(arg2);
28003
28004 wxPyEndAllowThreads(__tstate);
28005 if (PyErr_Occurred()) SWIG_fail;
28006 }
28007 Py_INCREF(Py_None); resultobj = Py_None;
28008 return resultobj;
28009 fail:
28010 return NULL;
28011 }
28012
28013
28014 static PyObject *_wrap_wxWindow_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28015 PyObject *resultobj;
28016 wxWindow *arg1 = (wxWindow *) 0 ;
28017 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28018 bool result;
28019 PyObject * obj0 = 0 ;
28020 PyObject * obj1 = 0 ;
28021 char *kwnames[] = {
28022 (char *) "self",(char *) "flags", NULL
28023 };
28024
28025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_Navigate",kwnames,&obj0,&obj1)) goto fail;
28026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28027 if (SWIG_arg_fail(1)) SWIG_fail;
28028 if (obj1) {
28029 {
28030 arg2 = (int)(SWIG_As_int(obj1));
28031 if (SWIG_arg_fail(2)) SWIG_fail;
28032 }
28033 }
28034 {
28035 PyThreadState* __tstate = wxPyBeginAllowThreads();
28036 result = (bool)(arg1)->Navigate(arg2);
28037
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 {
28042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28043 }
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 static PyObject *_wrap_wxWindow_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj;
28052 wxWindow *arg1 = (wxWindow *) 0 ;
28053 wxWindow *arg2 = (wxWindow *) 0 ;
28054 PyObject * obj0 = 0 ;
28055 PyObject * obj1 = 0 ;
28056 char *kwnames[] = {
28057 (char *) "self",(char *) "win", NULL
28058 };
28059
28060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28062 if (SWIG_arg_fail(1)) SWIG_fail;
28063 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28064 if (SWIG_arg_fail(2)) SWIG_fail;
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 (arg1)->MoveAfterInTabOrder(arg2);
28068
28069 wxPyEndAllowThreads(__tstate);
28070 if (PyErr_Occurred()) SWIG_fail;
28071 }
28072 Py_INCREF(Py_None); resultobj = Py_None;
28073 return resultobj;
28074 fail:
28075 return NULL;
28076 }
28077
28078
28079 static PyObject *_wrap_wxWindow_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28080 PyObject *resultobj;
28081 wxWindow *arg1 = (wxWindow *) 0 ;
28082 wxWindow *arg2 = (wxWindow *) 0 ;
28083 PyObject * obj0 = 0 ;
28084 PyObject * obj1 = 0 ;
28085 char *kwnames[] = {
28086 (char *) "self",(char *) "win", NULL
28087 };
28088
28089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28091 if (SWIG_arg_fail(1)) SWIG_fail;
28092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28093 if (SWIG_arg_fail(2)) SWIG_fail;
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 (arg1)->MoveBeforeInTabOrder(arg2);
28097
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 Py_INCREF(Py_None); resultobj = Py_None;
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_wxWindow_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj;
28110 wxWindow *arg1 = (wxWindow *) 0 ;
28111 PyObject *result;
28112 PyObject * obj0 = 0 ;
28113 char *kwnames[] = {
28114 (char *) "self", NULL
28115 };
28116
28117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetChildren",kwnames,&obj0)) goto fail;
28118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28119 if (SWIG_arg_fail(1)) SWIG_fail;
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = (PyObject *)wxWindow_GetChildren(arg1);
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = result;
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 static PyObject *_wrap_wxWindow_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj;
28136 wxWindow *arg1 = (wxWindow *) 0 ;
28137 wxWindow *result;
28138 PyObject * obj0 = 0 ;
28139 char *kwnames[] = {
28140 (char *) "self", NULL
28141 };
28142
28143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetParent",kwnames,&obj0)) goto fail;
28144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28145 if (SWIG_arg_fail(1)) SWIG_fail;
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28149
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 resultobj = wxPyMake_wxObject(result, 0);
28155 }
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 static PyObject *_wrap_wxWindow_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28163 PyObject *resultobj;
28164 wxWindow *arg1 = (wxWindow *) 0 ;
28165 wxWindow *result;
28166 PyObject * obj0 = 0 ;
28167 char *kwnames[] = {
28168 (char *) "self", NULL
28169 };
28170
28171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetGrandParent",kwnames,&obj0)) goto fail;
28172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28173 if (SWIG_arg_fail(1)) SWIG_fail;
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28177
28178 wxPyEndAllowThreads(__tstate);
28179 if (PyErr_Occurred()) SWIG_fail;
28180 }
28181 {
28182 resultobj = wxPyMake_wxObject(result, 0);
28183 }
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 static PyObject *_wrap_wxWindow_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28191 PyObject *resultobj;
28192 wxWindow *arg1 = (wxWindow *) 0 ;
28193 bool result;
28194 PyObject * obj0 = 0 ;
28195 char *kwnames[] = {
28196 (char *) "self", NULL
28197 };
28198
28199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_IsTopLevel",kwnames,&obj0)) goto fail;
28200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28201 if (SWIG_arg_fail(1)) SWIG_fail;
28202 {
28203 PyThreadState* __tstate = wxPyBeginAllowThreads();
28204 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28205
28206 wxPyEndAllowThreads(__tstate);
28207 if (PyErr_Occurred()) SWIG_fail;
28208 }
28209 {
28210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28211 }
28212 return resultobj;
28213 fail:
28214 return NULL;
28215 }
28216
28217
28218 static PyObject *_wrap_wxWindow_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28219 PyObject *resultobj;
28220 wxWindow *arg1 = (wxWindow *) 0 ;
28221 wxWindow *arg2 = (wxWindow *) 0 ;
28222 bool result;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char *kwnames[] = {
28226 (char *) "self",(char *) "newParent", NULL
28227 };
28228
28229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_Reparent",kwnames,&obj0,&obj1)) goto fail;
28230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28231 if (SWIG_arg_fail(1)) SWIG_fail;
28232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(2)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (bool)(arg1)->Reparent(arg2);
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28243 }
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 static PyObject *_wrap_wxWindow_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj;
28252 wxWindow *arg1 = (wxWindow *) 0 ;
28253 wxWindow *arg2 = (wxWindow *) 0 ;
28254 PyObject * obj0 = 0 ;
28255 PyObject * obj1 = 0 ;
28256 char *kwnames[] = {
28257 (char *) "self",(char *) "child", NULL
28258 };
28259
28260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_AddChild",kwnames,&obj0,&obj1)) goto fail;
28261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28262 if (SWIG_arg_fail(1)) SWIG_fail;
28263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28264 if (SWIG_arg_fail(2)) SWIG_fail;
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 (arg1)->AddChild(arg2);
28268
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 Py_INCREF(Py_None); resultobj = Py_None;
28273 return resultobj;
28274 fail:
28275 return NULL;
28276 }
28277
28278
28279 static PyObject *_wrap_wxWindow_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28280 PyObject *resultobj;
28281 wxWindow *arg1 = (wxWindow *) 0 ;
28282 wxWindow *arg2 = (wxWindow *) 0 ;
28283 PyObject * obj0 = 0 ;
28284 PyObject * obj1 = 0 ;
28285 char *kwnames[] = {
28286 (char *) "self",(char *) "child", NULL
28287 };
28288
28289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28291 if (SWIG_arg_fail(1)) SWIG_fail;
28292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28293 if (SWIG_arg_fail(2)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 (arg1)->RemoveChild(arg2);
28297
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 Py_INCREF(Py_None); resultobj = Py_None;
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_wxWindow_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28309 PyObject *resultobj;
28310 wxWindow *arg1 = (wxWindow *) 0 ;
28311 long arg2 ;
28312 wxWindow *result;
28313 PyObject * obj0 = 0 ;
28314 PyObject * obj1 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self",(char *) "winid", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 {
28323 arg2 = (long)(SWIG_As_long(obj1));
28324 if (SWIG_arg_fail(2)) SWIG_fail;
28325 }
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 result = (wxWindow *)(arg1)->FindWindow(arg2);
28329
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 {
28334 resultobj = wxPyMake_wxObject(result, 0);
28335 }
28336 return resultobj;
28337 fail:
28338 return NULL;
28339 }
28340
28341
28342 static PyObject *_wrap_wxWindow_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28343 PyObject *resultobj;
28344 wxWindow *arg1 = (wxWindow *) 0 ;
28345 wxString *arg2 = 0 ;
28346 wxWindow *result;
28347 bool temp2 = false ;
28348 PyObject * obj0 = 0 ;
28349 PyObject * obj1 = 0 ;
28350 char *kwnames[] = {
28351 (char *) "self",(char *) "name", NULL
28352 };
28353
28354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28356 if (SWIG_arg_fail(1)) SWIG_fail;
28357 {
28358 arg2 = wxString_in_helper(obj1);
28359 if (arg2 == NULL) SWIG_fail;
28360 temp2 = true;
28361 }
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 {
28370 resultobj = wxPyMake_wxObject(result, 0);
28371 }
28372 {
28373 if (temp2)
28374 delete arg2;
28375 }
28376 return resultobj;
28377 fail:
28378 {
28379 if (temp2)
28380 delete arg2;
28381 }
28382 return NULL;
28383 }
28384
28385
28386 static PyObject *_wrap_wxWindow_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28387 PyObject *resultobj;
28388 wxWindow *arg1 = (wxWindow *) 0 ;
28389 wxEvtHandler *result;
28390 PyObject * obj0 = 0 ;
28391 char *kwnames[] = {
28392 (char *) "self", NULL
28393 };
28394
28395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetEventHandler",kwnames,&obj0)) goto fail;
28396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28397 if (SWIG_arg_fail(1)) SWIG_fail;
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28401
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 {
28406 resultobj = wxPyMake_wxObject(result, 0);
28407 }
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 static PyObject *_wrap_wxWindow_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj;
28416 wxWindow *arg1 = (wxWindow *) 0 ;
28417 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28418 PyObject * obj0 = 0 ;
28419 PyObject * obj1 = 0 ;
28420 char *kwnames[] = {
28421 (char *) "self",(char *) "handler", NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28428 if (SWIG_arg_fail(2)) SWIG_fail;
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 (arg1)->SetEventHandler(arg2);
28432
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 Py_INCREF(Py_None); resultobj = Py_None;
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject *_wrap_wxWindow_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj;
28445 wxWindow *arg1 = (wxWindow *) 0 ;
28446 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28447 PyObject * obj0 = 0 ;
28448 PyObject * obj1 = 0 ;
28449 char *kwnames[] = {
28450 (char *) "self",(char *) "handler", NULL
28451 };
28452
28453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28455 if (SWIG_arg_fail(1)) SWIG_fail;
28456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28457 if (SWIG_arg_fail(2)) SWIG_fail;
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 (arg1)->PushEventHandler(arg2);
28461
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 Py_INCREF(Py_None); resultobj = Py_None;
28466 return resultobj;
28467 fail:
28468 return NULL;
28469 }
28470
28471
28472 static PyObject *_wrap_wxWindow_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28473 PyObject *resultobj;
28474 wxWindow *arg1 = (wxWindow *) 0 ;
28475 bool arg2 = (bool) false ;
28476 wxEvtHandler *result;
28477 PyObject * obj0 = 0 ;
28478 PyObject * obj1 = 0 ;
28479 char *kwnames[] = {
28480 (char *) "self",(char *) "deleteHandler", NULL
28481 };
28482
28483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28485 if (SWIG_arg_fail(1)) SWIG_fail;
28486 if (obj1) {
28487 {
28488 arg2 = (bool)(SWIG_As_bool(obj1));
28489 if (SWIG_arg_fail(2)) SWIG_fail;
28490 }
28491 }
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28495
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 {
28500 resultobj = wxPyMake_wxObject(result, 0);
28501 }
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 static PyObject *_wrap_wxWindow_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj;
28510 wxWindow *arg1 = (wxWindow *) 0 ;
28511 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28512 bool result;
28513 PyObject * obj0 = 0 ;
28514 PyObject * obj1 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "self",(char *) "handler", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(2)) SWIG_fail;
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = (bool)(arg1)->RemoveEventHandler(arg2);
28527
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 {
28532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28533 }
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_wxWindow_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxWindow *arg1 = (wxWindow *) 0 ;
28543 wxValidator *arg2 = 0 ;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char *kwnames[] = {
28547 (char *) "self",(char *) "validator", NULL
28548 };
28549
28550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28552 if (SWIG_arg_fail(1)) SWIG_fail;
28553 {
28554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(2)) SWIG_fail;
28556 if (arg2 == NULL) {
28557 SWIG_null_ref("wxValidator");
28558 }
28559 if (SWIG_arg_fail(2)) SWIG_fail;
28560 }
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 (arg1)->SetValidator((wxValidator const &)*arg2);
28564
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 Py_INCREF(Py_None); resultobj = Py_None;
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 static PyObject *_wrap_wxWindow_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28576 PyObject *resultobj;
28577 wxWindow *arg1 = (wxWindow *) 0 ;
28578 wxValidator *result;
28579 PyObject * obj0 = 0 ;
28580 char *kwnames[] = {
28581 (char *) "self", NULL
28582 };
28583
28584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetValidator",kwnames,&obj0)) goto fail;
28585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(1)) SWIG_fail;
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 result = (wxValidator *)(arg1)->GetValidator();
28590
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 resultobj = wxPyMake_wxObject(result, 0);
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 static PyObject *_wrap_wxWindow_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28604 PyObject *resultobj;
28605 wxWindow *arg1 = (wxWindow *) 0 ;
28606 bool result;
28607 PyObject * obj0 = 0 ;
28608 char *kwnames[] = {
28609 (char *) "self", NULL
28610 };
28611
28612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Validate",kwnames,&obj0)) goto fail;
28613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28614 if (SWIG_arg_fail(1)) SWIG_fail;
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = (bool)(arg1)->Validate();
28618
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 {
28623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 static PyObject *_wrap_wxWindow_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28632 PyObject *resultobj;
28633 wxWindow *arg1 = (wxWindow *) 0 ;
28634 bool result;
28635 PyObject * obj0 = 0 ;
28636 char *kwnames[] = {
28637 (char *) "self", NULL
28638 };
28639
28640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_TransferDataToWindow",kwnames,&obj0)) goto fail;
28641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28642 if (SWIG_arg_fail(1)) SWIG_fail;
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 result = (bool)(arg1)->TransferDataToWindow();
28646
28647 wxPyEndAllowThreads(__tstate);
28648 if (PyErr_Occurred()) SWIG_fail;
28649 }
28650 {
28651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28652 }
28653 return resultobj;
28654 fail:
28655 return NULL;
28656 }
28657
28658
28659 static PyObject *_wrap_wxWindow_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28660 PyObject *resultobj;
28661 wxWindow *arg1 = (wxWindow *) 0 ;
28662 bool result;
28663 PyObject * obj0 = 0 ;
28664 char *kwnames[] = {
28665 (char *) "self", NULL
28666 };
28667
28668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28670 if (SWIG_arg_fail(1)) SWIG_fail;
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = (bool)(arg1)->TransferDataFromWindow();
28674
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 {
28679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28680 }
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 static PyObject *_wrap_wxWindow_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28688 PyObject *resultobj;
28689 wxWindow *arg1 = (wxWindow *) 0 ;
28690 PyObject * obj0 = 0 ;
28691 char *kwnames[] = {
28692 (char *) "self", NULL
28693 };
28694
28695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_InitDialog",kwnames,&obj0)) goto fail;
28696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28697 if (SWIG_arg_fail(1)) SWIG_fail;
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 (arg1)->InitDialog();
28701
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 Py_INCREF(Py_None); resultobj = Py_None;
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 static PyObject *_wrap_wxWindow_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28713 PyObject *resultobj;
28714 wxWindow *arg1 = (wxWindow *) 0 ;
28715 wxAcceleratorTable *arg2 = 0 ;
28716 PyObject * obj0 = 0 ;
28717 PyObject * obj1 = 0 ;
28718 char *kwnames[] = {
28719 (char *) "self",(char *) "accel", NULL
28720 };
28721
28722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28724 if (SWIG_arg_fail(1)) SWIG_fail;
28725 {
28726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28727 if (SWIG_arg_fail(2)) SWIG_fail;
28728 if (arg2 == NULL) {
28729 SWIG_null_ref("wxAcceleratorTable");
28730 }
28731 if (SWIG_arg_fail(2)) SWIG_fail;
28732 }
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28736
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 Py_INCREF(Py_None); resultobj = Py_None;
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 static PyObject *_wrap_wxWindow_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28748 PyObject *resultobj;
28749 wxWindow *arg1 = (wxWindow *) 0 ;
28750 wxAcceleratorTable *result;
28751 PyObject * obj0 = 0 ;
28752 char *kwnames[] = {
28753 (char *) "self", NULL
28754 };
28755
28756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28758 if (SWIG_arg_fail(1)) SWIG_fail;
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28762
28763 wxPyEndAllowThreads(__tstate);
28764 if (PyErr_Occurred()) SWIG_fail;
28765 }
28766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 static PyObject *_wrap_wxWindow_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28774 PyObject *resultobj;
28775 wxWindow *arg1 = (wxWindow *) 0 ;
28776 int arg2 ;
28777 int arg3 ;
28778 int arg4 ;
28779 bool result;
28780 PyObject * obj0 = 0 ;
28781 PyObject * obj1 = 0 ;
28782 PyObject * obj2 = 0 ;
28783 PyObject * obj3 = 0 ;
28784 char *kwnames[] = {
28785 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28786 };
28787
28788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxWindow_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28790 if (SWIG_arg_fail(1)) SWIG_fail;
28791 {
28792 arg2 = (int)(SWIG_As_int(obj1));
28793 if (SWIG_arg_fail(2)) SWIG_fail;
28794 }
28795 {
28796 arg3 = (int)(SWIG_As_int(obj2));
28797 if (SWIG_arg_fail(3)) SWIG_fail;
28798 }
28799 {
28800 arg4 = (int)(SWIG_As_int(obj3));
28801 if (SWIG_arg_fail(4)) SWIG_fail;
28802 }
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28806
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 {
28811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28812 }
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 static PyObject *_wrap_wxWindow_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28820 PyObject *resultobj;
28821 wxWindow *arg1 = (wxWindow *) 0 ;
28822 int arg2 ;
28823 bool result;
28824 PyObject * obj0 = 0 ;
28825 PyObject * obj1 = 0 ;
28826 char *kwnames[] = {
28827 (char *) "self",(char *) "hotkeyId", NULL
28828 };
28829
28830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28832 if (SWIG_arg_fail(1)) SWIG_fail;
28833 {
28834 arg2 = (int)(SWIG_As_int(obj1));
28835 if (SWIG_arg_fail(2)) SWIG_fail;
28836 }
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28840
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 {
28845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28846 }
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 static PyObject *_wrap_wxWindow_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj;
28855 wxWindow *arg1 = (wxWindow *) 0 ;
28856 wxPoint *arg2 = 0 ;
28857 wxPoint result;
28858 wxPoint temp2 ;
28859 PyObject * obj0 = 0 ;
28860 PyObject * obj1 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self",(char *) "pt", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 {
28869 arg2 = &temp2;
28870 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28871 }
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28875
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 {
28880 wxPoint * resultptr;
28881 resultptr = new wxPoint((wxPoint &)(result));
28882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28883 }
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 static PyObject *_wrap_wxWindow_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj;
28892 wxWindow *arg1 = (wxWindow *) 0 ;
28893 wxSize *arg2 = 0 ;
28894 wxSize result;
28895 wxSize temp2 ;
28896 PyObject * obj0 = 0 ;
28897 PyObject * obj1 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self",(char *) "sz", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 {
28906 arg2 = &temp2;
28907 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28908 }
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 {
28917 wxSize * resultptr;
28918 resultptr = new wxSize((wxSize &)(result));
28919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28920 }
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 static PyObject *_wrap_wxWindow_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28928 PyObject *resultobj;
28929 wxWindow *arg1 = (wxWindow *) 0 ;
28930 wxPoint *arg2 = 0 ;
28931 wxPoint result;
28932 wxPoint temp2 ;
28933 PyObject * obj0 = 0 ;
28934 PyObject * obj1 = 0 ;
28935 char *kwnames[] = {
28936 (char *) "self",(char *) "pt", NULL
28937 };
28938
28939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28941 if (SWIG_arg_fail(1)) SWIG_fail;
28942 {
28943 arg2 = &temp2;
28944 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28945 }
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28949
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 {
28954 wxPoint * resultptr;
28955 resultptr = new wxPoint((wxPoint &)(result));
28956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28957 }
28958 return resultobj;
28959 fail:
28960 return NULL;
28961 }
28962
28963
28964 static PyObject *_wrap_wxWindow_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28965 PyObject *resultobj;
28966 wxWindow *arg1 = (wxWindow *) 0 ;
28967 wxSize *arg2 = 0 ;
28968 wxSize result;
28969 wxSize temp2 ;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 char *kwnames[] = {
28973 (char *) "self",(char *) "sz", NULL
28974 };
28975
28976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28978 if (SWIG_arg_fail(1)) SWIG_fail;
28979 {
28980 arg2 = &temp2;
28981 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28982 }
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28986
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 {
28991 wxSize * resultptr;
28992 resultptr = new wxSize((wxSize &)(result));
28993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28994 }
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 static PyObject *_wrap_wxWindow_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj;
29003 wxWindow *arg1 = (wxWindow *) 0 ;
29004 wxPoint *arg2 = 0 ;
29005 wxPoint result;
29006 wxPoint temp2 ;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self",(char *) "pt", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 {
29017 arg2 = &temp2;
29018 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29019 }
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29023
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 {
29028 wxPoint * resultptr;
29029 resultptr = new wxPoint((wxPoint &)(result));
29030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29031 }
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 static PyObject *_wrap_wxWindow_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj;
29040 wxWindow *arg1 = (wxWindow *) 0 ;
29041 wxSize *arg2 = 0 ;
29042 wxSize result;
29043 wxSize temp2 ;
29044 PyObject * obj0 = 0 ;
29045 PyObject * obj1 = 0 ;
29046 char *kwnames[] = {
29047 (char *) "self",(char *) "sz", NULL
29048 };
29049
29050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29052 if (SWIG_arg_fail(1)) SWIG_fail;
29053 {
29054 arg2 = &temp2;
29055 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29056 }
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29060
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 {
29065 wxSize * resultptr;
29066 resultptr = new wxSize((wxSize &)(result));
29067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29068 }
29069 return resultobj;
29070 fail:
29071 return NULL;
29072 }
29073
29074
29075 static PyObject *_wrap_wxWindow_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29076 PyObject *resultobj;
29077 wxWindow *arg1 = (wxWindow *) 0 ;
29078 int arg2 ;
29079 int arg3 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 PyObject * obj2 = 0 ;
29083 char *kwnames[] = {
29084 (char *) "self",(char *) "x",(char *) "y", NULL
29085 };
29086
29087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29089 if (SWIG_arg_fail(1)) SWIG_fail;
29090 {
29091 arg2 = (int)(SWIG_As_int(obj1));
29092 if (SWIG_arg_fail(2)) SWIG_fail;
29093 }
29094 {
29095 arg3 = (int)(SWIG_As_int(obj2));
29096 if (SWIG_arg_fail(3)) SWIG_fail;
29097 }
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 (arg1)->WarpPointer(arg2,arg3);
29101
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 Py_INCREF(Py_None); resultobj = Py_None;
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 static PyObject *_wrap_wxWindow_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29113 PyObject *resultobj;
29114 wxWindow *arg1 = (wxWindow *) 0 ;
29115 PyObject * obj0 = 0 ;
29116 char *kwnames[] = {
29117 (char *) "self", NULL
29118 };
29119
29120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_CaptureMouse",kwnames,&obj0)) goto fail;
29121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29122 if (SWIG_arg_fail(1)) SWIG_fail;
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 (arg1)->CaptureMouse();
29126
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 Py_INCREF(Py_None); resultobj = Py_None;
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 static PyObject *_wrap_wxWindow_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj;
29139 wxWindow *arg1 = (wxWindow *) 0 ;
29140 PyObject * obj0 = 0 ;
29141 char *kwnames[] = {
29142 (char *) "self", NULL
29143 };
29144
29145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_ReleaseMouse",kwnames,&obj0)) goto fail;
29146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29147 if (SWIG_arg_fail(1)) SWIG_fail;
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 (arg1)->ReleaseMouse();
29151
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 Py_INCREF(Py_None); resultobj = Py_None;
29156 return resultobj;
29157 fail:
29158 return NULL;
29159 }
29160
29161
29162 static PyObject *_wrap_wxWindow_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29163 PyObject *resultobj;
29164 wxWindow *result;
29165 char *kwnames[] = {
29166 NULL
29167 };
29168
29169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxWindow_GetCapture",kwnames)) goto fail;
29170 {
29171 if (!wxPyCheckForApp()) SWIG_fail;
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = (wxWindow *)wxWindow::GetCapture();
29174
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 {
29179 resultobj = wxPyMake_wxObject(result, 0);
29180 }
29181 return resultobj;
29182 fail:
29183 return NULL;
29184 }
29185
29186
29187 static PyObject *_wrap_wxWindow_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29188 PyObject *resultobj;
29189 wxWindow *arg1 = (wxWindow *) 0 ;
29190 bool result;
29191 PyObject * obj0 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "self", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_HasCapture",kwnames,&obj0)) goto fail;
29197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29198 if (SWIG_arg_fail(1)) SWIG_fail;
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 result = (bool)((wxWindow const *)arg1)->HasCapture();
29202
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 {
29207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29208 }
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 static PyObject *_wrap_wxWindow_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29216 PyObject *resultobj;
29217 wxWindow *arg1 = (wxWindow *) 0 ;
29218 bool arg2 = (bool) true ;
29219 wxRect *arg3 = (wxRect *) NULL ;
29220 PyObject * obj0 = 0 ;
29221 PyObject * obj1 = 0 ;
29222 PyObject * obj2 = 0 ;
29223 char *kwnames[] = {
29224 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29225 };
29226
29227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:wxWindow_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29229 if (SWIG_arg_fail(1)) SWIG_fail;
29230 if (obj1) {
29231 {
29232 arg2 = (bool)(SWIG_As_bool(obj1));
29233 if (SWIG_arg_fail(2)) SWIG_fail;
29234 }
29235 }
29236 if (obj2) {
29237 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29238 if (SWIG_arg_fail(3)) SWIG_fail;
29239 }
29240 {
29241 PyThreadState* __tstate = wxPyBeginAllowThreads();
29242 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29243
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 Py_INCREF(Py_None); resultobj = Py_None;
29248 return resultobj;
29249 fail:
29250 return NULL;
29251 }
29252
29253
29254 static PyObject *_wrap_wxWindow_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29255 PyObject *resultobj;
29256 wxWindow *arg1 = (wxWindow *) 0 ;
29257 wxRect *arg2 = 0 ;
29258 bool arg3 = (bool) true ;
29259 wxRect temp2 ;
29260 PyObject * obj0 = 0 ;
29261 PyObject * obj1 = 0 ;
29262 PyObject * obj2 = 0 ;
29263 char *kwnames[] = {
29264 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29265 };
29266
29267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29269 if (SWIG_arg_fail(1)) SWIG_fail;
29270 {
29271 arg2 = &temp2;
29272 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29273 }
29274 if (obj2) {
29275 {
29276 arg3 = (bool)(SWIG_As_bool(obj2));
29277 if (SWIG_arg_fail(3)) SWIG_fail;
29278 }
29279 }
29280 {
29281 PyThreadState* __tstate = wxPyBeginAllowThreads();
29282 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29283
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 Py_INCREF(Py_None); resultobj = Py_None;
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 static PyObject *_wrap_wxWindow_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29295 PyObject *resultobj;
29296 wxWindow *arg1 = (wxWindow *) 0 ;
29297 PyObject * obj0 = 0 ;
29298 char *kwnames[] = {
29299 (char *) "self", NULL
29300 };
29301
29302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Update",kwnames,&obj0)) goto fail;
29303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29304 if (SWIG_arg_fail(1)) SWIG_fail;
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 (arg1)->Update();
29308
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 Py_INCREF(Py_None); resultobj = Py_None;
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 static PyObject *_wrap_wxWindow_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29320 PyObject *resultobj;
29321 wxWindow *arg1 = (wxWindow *) 0 ;
29322 PyObject * obj0 = 0 ;
29323 char *kwnames[] = {
29324 (char *) "self", NULL
29325 };
29326
29327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_ClearBackground",kwnames,&obj0)) goto fail;
29328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29329 if (SWIG_arg_fail(1)) SWIG_fail;
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 (arg1)->ClearBackground();
29333
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 Py_INCREF(Py_None); resultobj = Py_None;
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_wxWindow_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj;
29346 wxWindow *arg1 = (wxWindow *) 0 ;
29347 PyObject * obj0 = 0 ;
29348 char *kwnames[] = {
29349 (char *) "self", NULL
29350 };
29351
29352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Freeze",kwnames,&obj0)) goto fail;
29353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29354 if (SWIG_arg_fail(1)) SWIG_fail;
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 (arg1)->Freeze();
29358
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 Py_INCREF(Py_None); resultobj = Py_None;
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 static PyObject *_wrap_wxWindow_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj;
29371 wxWindow *arg1 = (wxWindow *) 0 ;
29372 PyObject * obj0 = 0 ;
29373 char *kwnames[] = {
29374 (char *) "self", NULL
29375 };
29376
29377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Thaw",kwnames,&obj0)) goto fail;
29378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29379 if (SWIG_arg_fail(1)) SWIG_fail;
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 (arg1)->Thaw();
29383
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 Py_INCREF(Py_None); resultobj = Py_None;
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 static PyObject *_wrap_wxWindow_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29395 PyObject *resultobj;
29396 wxWindow *arg1 = (wxWindow *) 0 ;
29397 wxDC *arg2 = 0 ;
29398 PyObject * obj0 = 0 ;
29399 PyObject * obj1 = 0 ;
29400 char *kwnames[] = {
29401 (char *) "self",(char *) "dc", NULL
29402 };
29403
29404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29406 if (SWIG_arg_fail(1)) SWIG_fail;
29407 {
29408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29409 if (SWIG_arg_fail(2)) SWIG_fail;
29410 if (arg2 == NULL) {
29411 SWIG_null_ref("wxDC");
29412 }
29413 if (SWIG_arg_fail(2)) SWIG_fail;
29414 }
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 (arg1)->PrepareDC(*arg2);
29418
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 Py_INCREF(Py_None); resultobj = Py_None;
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 static PyObject *_wrap_wxWindow_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29430 PyObject *resultobj;
29431 wxWindow *arg1 = (wxWindow *) 0 ;
29432 wxRegion *result;
29433 PyObject * obj0 = 0 ;
29434 char *kwnames[] = {
29435 (char *) "self", NULL
29436 };
29437
29438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetUpdateRegion",kwnames,&obj0)) goto fail;
29439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29440 if (SWIG_arg_fail(1)) SWIG_fail;
29441 {
29442 PyThreadState* __tstate = wxPyBeginAllowThreads();
29443 {
29444 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29445 result = (wxRegion *) &_result_ref;
29446 }
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 static PyObject *_wrap_wxWindow_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29459 PyObject *resultobj;
29460 wxWindow *arg1 = (wxWindow *) 0 ;
29461 wxRect result;
29462 PyObject * obj0 = 0 ;
29463 char *kwnames[] = {
29464 (char *) "self", NULL
29465 };
29466
29467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29469 if (SWIG_arg_fail(1)) SWIG_fail;
29470 {
29471 PyThreadState* __tstate = wxPyBeginAllowThreads();
29472 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29473
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 {
29478 wxRect * resultptr;
29479 resultptr = new wxRect((wxRect &)(result));
29480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29481 }
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 static PyObject *_wrap_wxWindow_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29489 PyObject *resultobj;
29490 wxWindow *arg1 = (wxWindow *) 0 ;
29491 int arg2 ;
29492 int arg3 ;
29493 int arg4 = (int) 1 ;
29494 int arg5 = (int) 1 ;
29495 bool result;
29496 PyObject * obj0 = 0 ;
29497 PyObject * obj1 = 0 ;
29498 PyObject * obj2 = 0 ;
29499 PyObject * obj3 = 0 ;
29500 PyObject * obj4 = 0 ;
29501 char *kwnames[] = {
29502 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29503 };
29504
29505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:wxWindow_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29507 if (SWIG_arg_fail(1)) SWIG_fail;
29508 {
29509 arg2 = (int)(SWIG_As_int(obj1));
29510 if (SWIG_arg_fail(2)) SWIG_fail;
29511 }
29512 {
29513 arg3 = (int)(SWIG_As_int(obj2));
29514 if (SWIG_arg_fail(3)) SWIG_fail;
29515 }
29516 if (obj3) {
29517 {
29518 arg4 = (int)(SWIG_As_int(obj3));
29519 if (SWIG_arg_fail(4)) SWIG_fail;
29520 }
29521 }
29522 if (obj4) {
29523 {
29524 arg5 = (int)(SWIG_As_int(obj4));
29525 if (SWIG_arg_fail(5)) SWIG_fail;
29526 }
29527 }
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29531
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 {
29536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29537 }
29538 return resultobj;
29539 fail:
29540 return NULL;
29541 }
29542
29543
29544 static PyObject *_wrap_wxWindow_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29545 PyObject *resultobj;
29546 wxWindow *arg1 = (wxWindow *) 0 ;
29547 wxPoint *arg2 = 0 ;
29548 bool result;
29549 wxPoint temp2 ;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self",(char *) "pt", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 arg2 = &temp2;
29561 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29562 }
29563 {
29564 PyThreadState* __tstate = wxPyBeginAllowThreads();
29565 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29566
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 {
29571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29572 }
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 static PyObject *_wrap_wxWindow_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj;
29581 wxWindow *arg1 = (wxWindow *) 0 ;
29582 wxRect *arg2 = 0 ;
29583 bool result;
29584 wxRect temp2 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char *kwnames[] = {
29588 (char *) "self",(char *) "rect", NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29593 if (SWIG_arg_fail(1)) SWIG_fail;
29594 {
29595 arg2 = &temp2;
29596 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29597 }
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 {
29606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29607 }
29608 return resultobj;
29609 fail:
29610 return NULL;
29611 }
29612
29613
29614 static PyObject *_wrap_wxWindow_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 wxVisualAttributes result;
29618 PyObject * obj0 = 0 ;
29619 char *kwnames[] = {
29620 (char *) "self", NULL
29621 };
29622
29623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29625 if (SWIG_arg_fail(1)) SWIG_fail;
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29629
29630 wxPyEndAllowThreads(__tstate);
29631 if (PyErr_Occurred()) SWIG_fail;
29632 }
29633 {
29634 wxVisualAttributes * resultptr;
29635 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29637 }
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 static PyObject *_wrap_wxWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29645 PyObject *resultobj;
29646 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29647 wxVisualAttributes result;
29648 PyObject * obj0 = 0 ;
29649 char *kwnames[] = {
29650 (char *) "variant", NULL
29651 };
29652
29653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:wxWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29654 if (obj0) {
29655 {
29656 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 }
29659 }
29660 {
29661 if (!wxPyCheckForApp()) SWIG_fail;
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29664
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 wxVisualAttributes * resultptr;
29670 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29672 }
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 static PyObject *_wrap_wxWindow_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29680 PyObject *resultobj;
29681 wxWindow *arg1 = (wxWindow *) 0 ;
29682 wxColour *arg2 = 0 ;
29683 bool result;
29684 wxColour temp2 ;
29685 PyObject * obj0 = 0 ;
29686 PyObject * obj1 = 0 ;
29687 char *kwnames[] = {
29688 (char *) "self",(char *) "colour", NULL
29689 };
29690
29691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 {
29695 arg2 = &temp2;
29696 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29697 }
29698 {
29699 PyThreadState* __tstate = wxPyBeginAllowThreads();
29700 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29701
29702 wxPyEndAllowThreads(__tstate);
29703 if (PyErr_Occurred()) SWIG_fail;
29704 }
29705 {
29706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29707 }
29708 return resultobj;
29709 fail:
29710 return NULL;
29711 }
29712
29713
29714 static PyObject *_wrap_wxWindow_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29715 PyObject *resultobj;
29716 wxWindow *arg1 = (wxWindow *) 0 ;
29717 wxColour *arg2 = 0 ;
29718 wxColour temp2 ;
29719 PyObject * obj0 = 0 ;
29720 PyObject * obj1 = 0 ;
29721 char *kwnames[] = {
29722 (char *) "self",(char *) "colour", NULL
29723 };
29724
29725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29727 if (SWIG_arg_fail(1)) SWIG_fail;
29728 {
29729 arg2 = &temp2;
29730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29731 }
29732 {
29733 PyThreadState* __tstate = wxPyBeginAllowThreads();
29734 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29735
29736 wxPyEndAllowThreads(__tstate);
29737 if (PyErr_Occurred()) SWIG_fail;
29738 }
29739 Py_INCREF(Py_None); resultobj = Py_None;
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 static PyObject *_wrap_wxWindow_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29747 PyObject *resultobj;
29748 wxWindow *arg1 = (wxWindow *) 0 ;
29749 wxColour *arg2 = 0 ;
29750 bool result;
29751 wxColour temp2 ;
29752 PyObject * obj0 = 0 ;
29753 PyObject * obj1 = 0 ;
29754 char *kwnames[] = {
29755 (char *) "self",(char *) "colour", NULL
29756 };
29757
29758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29760 if (SWIG_arg_fail(1)) SWIG_fail;
29761 {
29762 arg2 = &temp2;
29763 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29764 }
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29768
29769 wxPyEndAllowThreads(__tstate);
29770 if (PyErr_Occurred()) SWIG_fail;
29771 }
29772 {
29773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29774 }
29775 return resultobj;
29776 fail:
29777 return NULL;
29778 }
29779
29780
29781 static PyObject *_wrap_wxWindow_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj;
29783 wxWindow *arg1 = (wxWindow *) 0 ;
29784 wxColour *arg2 = 0 ;
29785 wxColour temp2 ;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 char *kwnames[] = {
29789 (char *) "self",(char *) "colour", NULL
29790 };
29791
29792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29794 if (SWIG_arg_fail(1)) SWIG_fail;
29795 {
29796 arg2 = &temp2;
29797 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29798 }
29799 {
29800 PyThreadState* __tstate = wxPyBeginAllowThreads();
29801 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29802
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 Py_INCREF(Py_None); resultobj = Py_None;
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 static PyObject *_wrap_wxWindow_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29814 PyObject *resultobj;
29815 wxWindow *arg1 = (wxWindow *) 0 ;
29816 wxColour result;
29817 PyObject * obj0 = 0 ;
29818 char *kwnames[] = {
29819 (char *) "self", NULL
29820 };
29821
29822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetBackgroundColour",kwnames,&obj0)) goto fail;
29823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29824 if (SWIG_arg_fail(1)) SWIG_fail;
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29828
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 {
29833 wxColour * resultptr;
29834 resultptr = new wxColour((wxColour &)(result));
29835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29836 }
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 static PyObject *_wrap_wxWindow_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj;
29845 wxWindow *arg1 = (wxWindow *) 0 ;
29846 wxColour result;
29847 PyObject * obj0 = 0 ;
29848 char *kwnames[] = {
29849 (char *) "self", NULL
29850 };
29851
29852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetForegroundColour",kwnames,&obj0)) goto fail;
29853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29854 if (SWIG_arg_fail(1)) SWIG_fail;
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = ((wxWindow const *)arg1)->GetForegroundColour();
29858
29859 wxPyEndAllowThreads(__tstate);
29860 if (PyErr_Occurred()) SWIG_fail;
29861 }
29862 {
29863 wxColour * resultptr;
29864 resultptr = new wxColour((wxColour &)(result));
29865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29866 }
29867 return resultobj;
29868 fail:
29869 return NULL;
29870 }
29871
29872
29873 static PyObject *_wrap_wxWindow_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29874 PyObject *resultobj;
29875 wxWindow *arg1 = (wxWindow *) 0 ;
29876 bool result;
29877 PyObject * obj0 = 0 ;
29878 char *kwnames[] = {
29879 (char *) "self", NULL
29880 };
29881
29882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29884 if (SWIG_arg_fail(1)) SWIG_fail;
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29888
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 {
29893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29894 }
29895 return resultobj;
29896 fail:
29897 return NULL;
29898 }
29899
29900
29901 static PyObject *_wrap_wxWindow_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29902 PyObject *resultobj;
29903 wxWindow *arg1 = (wxWindow *) 0 ;
29904 bool result;
29905 PyObject * obj0 = 0 ;
29906 char *kwnames[] = {
29907 (char *) "self", NULL
29908 };
29909
29910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_UseBgCol",kwnames,&obj0)) goto fail;
29911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29912 if (SWIG_arg_fail(1)) SWIG_fail;
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29916
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 {
29921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29922 }
29923 return resultobj;
29924 fail:
29925 return NULL;
29926 }
29927
29928
29929 static PyObject *_wrap_wxWindow_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29930 PyObject *resultobj;
29931 wxWindow *arg1 = (wxWindow *) 0 ;
29932 wxBackgroundStyle arg2 ;
29933 bool result;
29934 PyObject * obj0 = 0 ;
29935 PyObject * obj1 = 0 ;
29936 char *kwnames[] = {
29937 (char *) "self",(char *) "style", NULL
29938 };
29939
29940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29942 if (SWIG_arg_fail(1)) SWIG_fail;
29943 {
29944 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29945 if (SWIG_arg_fail(2)) SWIG_fail;
29946 }
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29950
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 {
29955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29956 }
29957 return resultobj;
29958 fail:
29959 return NULL;
29960 }
29961
29962
29963 static PyObject *_wrap_wxWindow_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29964 PyObject *resultobj;
29965 wxWindow *arg1 = (wxWindow *) 0 ;
29966 wxBackgroundStyle result;
29967 PyObject * obj0 = 0 ;
29968 char *kwnames[] = {
29969 (char *) "self", NULL
29970 };
29971
29972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29974 if (SWIG_arg_fail(1)) SWIG_fail;
29975 {
29976 PyThreadState* __tstate = wxPyBeginAllowThreads();
29977 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29978
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 resultobj = SWIG_From_int((result));
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 static PyObject *_wrap_wxWindow_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj;
29991 wxWindow *arg1 = (wxWindow *) 0 ;
29992 bool result;
29993 PyObject * obj0 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_HasTransparentBackground",kwnames,&obj0)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 result = (bool)(arg1)->HasTransparentBackground();
30004
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 {
30009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30010 }
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 static PyObject *_wrap_wxWindow_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj;
30019 wxWindow *arg1 = (wxWindow *) 0 ;
30020 wxCursor *arg2 = 0 ;
30021 bool result;
30022 PyObject * obj0 = 0 ;
30023 PyObject * obj1 = 0 ;
30024 char *kwnames[] = {
30025 (char *) "self",(char *) "cursor", NULL
30026 };
30027
30028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30030 if (SWIG_arg_fail(1)) SWIG_fail;
30031 {
30032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 if (arg2 == NULL) {
30035 SWIG_null_ref("wxCursor");
30036 }
30037 if (SWIG_arg_fail(2)) SWIG_fail;
30038 }
30039 {
30040 PyThreadState* __tstate = wxPyBeginAllowThreads();
30041 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30042
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 {
30047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30048 }
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 static PyObject *_wrap_wxWindow_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30056 PyObject *resultobj;
30057 wxWindow *arg1 = (wxWindow *) 0 ;
30058 wxCursor result;
30059 PyObject * obj0 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetCursor",kwnames,&obj0)) goto fail;
30065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(1)) SWIG_fail;
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 result = (arg1)->GetCursor();
30070
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 {
30075 wxCursor * resultptr;
30076 resultptr = new wxCursor((wxCursor &)(result));
30077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30078 }
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 static PyObject *_wrap_wxWindow_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30086 PyObject *resultobj;
30087 wxWindow *arg1 = (wxWindow *) 0 ;
30088 wxFont *arg2 = 0 ;
30089 bool result;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self",(char *) "font", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetFont",kwnames,&obj0,&obj1)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 if (arg2 == NULL) {
30103 SWIG_null_ref("wxFont");
30104 }
30105 if (SWIG_arg_fail(2)) SWIG_fail;
30106 }
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30110
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 {
30115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30116 }
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 static PyObject *_wrap_wxWindow_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30124 PyObject *resultobj;
30125 wxWindow *arg1 = (wxWindow *) 0 ;
30126 wxFont *arg2 = 0 ;
30127 PyObject * obj0 = 0 ;
30128 PyObject * obj1 = 0 ;
30129 char *kwnames[] = {
30130 (char *) "self",(char *) "font", NULL
30131 };
30132
30133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30135 if (SWIG_arg_fail(1)) SWIG_fail;
30136 {
30137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30138 if (SWIG_arg_fail(2)) SWIG_fail;
30139 if (arg2 == NULL) {
30140 SWIG_null_ref("wxFont");
30141 }
30142 if (SWIG_arg_fail(2)) SWIG_fail;
30143 }
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 (arg1)->SetOwnFont((wxFont const &)*arg2);
30147
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 Py_INCREF(Py_None); resultobj = Py_None;
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 static PyObject *_wrap_wxWindow_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30159 PyObject *resultobj;
30160 wxWindow *arg1 = (wxWindow *) 0 ;
30161 wxFont result;
30162 PyObject * obj0 = 0 ;
30163 char *kwnames[] = {
30164 (char *) "self", NULL
30165 };
30166
30167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetFont",kwnames,&obj0)) goto fail;
30168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30169 if (SWIG_arg_fail(1)) SWIG_fail;
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (arg1)->GetFont();
30173
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 {
30178 wxFont * resultptr;
30179 resultptr = new wxFont((wxFont &)(result));
30180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30181 }
30182 return resultobj;
30183 fail:
30184 return NULL;
30185 }
30186
30187
30188 static PyObject *_wrap_wxWindow_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30189 PyObject *resultobj;
30190 wxWindow *arg1 = (wxWindow *) 0 ;
30191 wxCaret *arg2 = (wxCaret *) 0 ;
30192 PyObject * obj0 = 0 ;
30193 PyObject * obj1 = 0 ;
30194 char *kwnames[] = {
30195 (char *) "self",(char *) "caret", NULL
30196 };
30197
30198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30200 if (SWIG_arg_fail(1)) SWIG_fail;
30201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30202 if (SWIG_arg_fail(2)) SWIG_fail;
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 (arg1)->SetCaret(arg2);
30206
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 Py_INCREF(Py_None); resultobj = Py_None;
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 static PyObject *_wrap_wxWindow_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj;
30219 wxWindow *arg1 = (wxWindow *) 0 ;
30220 wxCaret *result;
30221 PyObject * obj0 = 0 ;
30222 char *kwnames[] = {
30223 (char *) "self", NULL
30224 };
30225
30226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetCaret",kwnames,&obj0)) goto fail;
30227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30228 if (SWIG_arg_fail(1)) SWIG_fail;
30229 {
30230 PyThreadState* __tstate = wxPyBeginAllowThreads();
30231 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30232
30233 wxPyEndAllowThreads(__tstate);
30234 if (PyErr_Occurred()) SWIG_fail;
30235 }
30236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30237 return resultobj;
30238 fail:
30239 return NULL;
30240 }
30241
30242
30243 static PyObject *_wrap_wxWindow_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30244 PyObject *resultobj;
30245 wxWindow *arg1 = (wxWindow *) 0 ;
30246 int result;
30247 PyObject * obj0 = 0 ;
30248 char *kwnames[] = {
30249 (char *) "self", NULL
30250 };
30251
30252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetCharHeight",kwnames,&obj0)) goto fail;
30253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30254 if (SWIG_arg_fail(1)) SWIG_fail;
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30258
30259 wxPyEndAllowThreads(__tstate);
30260 if (PyErr_Occurred()) SWIG_fail;
30261 }
30262 {
30263 resultobj = SWIG_From_int((int)(result));
30264 }
30265 return resultobj;
30266 fail:
30267 return NULL;
30268 }
30269
30270
30271 static PyObject *_wrap_wxWindow_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30272 PyObject *resultobj;
30273 wxWindow *arg1 = (wxWindow *) 0 ;
30274 int result;
30275 PyObject * obj0 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self", NULL
30278 };
30279
30280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetCharWidth",kwnames,&obj0)) goto fail;
30281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30282 if (SWIG_arg_fail(1)) SWIG_fail;
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30286
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 {
30291 resultobj = SWIG_From_int((int)(result));
30292 }
30293 return resultobj;
30294 fail:
30295 return NULL;
30296 }
30297
30298
30299 static PyObject *_wrap_wxWindow_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30300 PyObject *resultobj;
30301 wxWindow *arg1 = (wxWindow *) 0 ;
30302 wxString *arg2 = 0 ;
30303 int *arg3 = (int *) 0 ;
30304 int *arg4 = (int *) 0 ;
30305 bool temp2 = false ;
30306 int temp3 ;
30307 int res3 = 0 ;
30308 int temp4 ;
30309 int res4 = 0 ;
30310 PyObject * obj0 = 0 ;
30311 PyObject * obj1 = 0 ;
30312 char *kwnames[] = {
30313 (char *) "self",(char *) "string", NULL
30314 };
30315
30316 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30317 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30320 if (SWIG_arg_fail(1)) SWIG_fail;
30321 {
30322 arg2 = wxString_in_helper(obj1);
30323 if (arg2 == NULL) SWIG_fail;
30324 temp2 = true;
30325 }
30326 {
30327 PyThreadState* __tstate = wxPyBeginAllowThreads();
30328 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30329
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 Py_INCREF(Py_None); resultobj = Py_None;
30334 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30335 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30336 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30337 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30338 {
30339 if (temp2)
30340 delete arg2;
30341 }
30342 return resultobj;
30343 fail:
30344 {
30345 if (temp2)
30346 delete arg2;
30347 }
30348 return NULL;
30349 }
30350
30351
30352 static PyObject *_wrap_wxWindow_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30353 PyObject *resultobj;
30354 wxWindow *arg1 = (wxWindow *) 0 ;
30355 wxString *arg2 = 0 ;
30356 int *arg3 = (int *) 0 ;
30357 int *arg4 = (int *) 0 ;
30358 int *arg5 = (int *) 0 ;
30359 int *arg6 = (int *) 0 ;
30360 wxFont *arg7 = (wxFont *) NULL ;
30361 bool temp2 = false ;
30362 int temp3 ;
30363 int res3 = 0 ;
30364 int temp4 ;
30365 int res4 = 0 ;
30366 int temp5 ;
30367 int res5 = 0 ;
30368 int temp6 ;
30369 int res6 = 0 ;
30370 PyObject * obj0 = 0 ;
30371 PyObject * obj1 = 0 ;
30372 PyObject * obj2 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self",(char *) "string",(char *) "font", NULL
30375 };
30376
30377 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30378 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30379 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30380 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30383 if (SWIG_arg_fail(1)) SWIG_fail;
30384 {
30385 arg2 = wxString_in_helper(obj1);
30386 if (arg2 == NULL) SWIG_fail;
30387 temp2 = true;
30388 }
30389 if (obj2) {
30390 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30391 if (SWIG_arg_fail(7)) SWIG_fail;
30392 }
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30396
30397 wxPyEndAllowThreads(__tstate);
30398 if (PyErr_Occurred()) SWIG_fail;
30399 }
30400 Py_INCREF(Py_None); resultobj = Py_None;
30401 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30402 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30403 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30404 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30405 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30406 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30407 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30408 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30409 {
30410 if (temp2)
30411 delete arg2;
30412 }
30413 return resultobj;
30414 fail:
30415 {
30416 if (temp2)
30417 delete arg2;
30418 }
30419 return NULL;
30420 }
30421
30422
30423 static PyObject *_wrap_wxWindow_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj;
30425 wxWindow *arg1 = (wxWindow *) 0 ;
30426 int *arg2 = (int *) 0 ;
30427 int *arg3 = (int *) 0 ;
30428 int temp2 ;
30429 int res2 = 0 ;
30430 int temp3 ;
30431 int res3 = 0 ;
30432 PyObject * obj0 = 0 ;
30433 PyObject * obj1 = 0 ;
30434 PyObject * obj2 = 0 ;
30435 char *kwnames[] = {
30436 (char *) "self",(char *) "x",(char *) "y", NULL
30437 };
30438
30439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30441 if (SWIG_arg_fail(1)) SWIG_fail;
30442 {
30443 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30444 temp2 = SWIG_As_int(obj1);
30445 if (SWIG_arg_fail(2)) SWIG_fail;
30446 arg2 = &temp2;
30447 res2 = SWIG_NEWOBJ;
30448 }
30449 }
30450 {
30451 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30452 temp3 = SWIG_As_int(obj2);
30453 if (SWIG_arg_fail(3)) SWIG_fail;
30454 arg3 = &temp3;
30455 res3 = SWIG_NEWOBJ;
30456 }
30457 }
30458 {
30459 PyThreadState* __tstate = wxPyBeginAllowThreads();
30460 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30461
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 Py_INCREF(Py_None); resultobj = Py_None;
30466 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30467 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30468 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30469 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30470 return resultobj;
30471 fail:
30472 return NULL;
30473 }
30474
30475
30476 static PyObject *_wrap_wxWindow_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30477 PyObject *resultobj;
30478 wxWindow *arg1 = (wxWindow *) 0 ;
30479 int *arg2 = (int *) 0 ;
30480 int *arg3 = (int *) 0 ;
30481 int temp2 ;
30482 int res2 = 0 ;
30483 int temp3 ;
30484 int res3 = 0 ;
30485 PyObject * obj0 = 0 ;
30486 PyObject * obj1 = 0 ;
30487 PyObject * obj2 = 0 ;
30488 char *kwnames[] = {
30489 (char *) "self",(char *) "x",(char *) "y", NULL
30490 };
30491
30492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30494 if (SWIG_arg_fail(1)) SWIG_fail;
30495 {
30496 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30497 temp2 = SWIG_As_int(obj1);
30498 if (SWIG_arg_fail(2)) SWIG_fail;
30499 arg2 = &temp2;
30500 res2 = SWIG_NEWOBJ;
30501 }
30502 }
30503 {
30504 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30505 temp3 = SWIG_As_int(obj2);
30506 if (SWIG_arg_fail(3)) SWIG_fail;
30507 arg3 = &temp3;
30508 res3 = SWIG_NEWOBJ;
30509 }
30510 }
30511 {
30512 PyThreadState* __tstate = wxPyBeginAllowThreads();
30513 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30514
30515 wxPyEndAllowThreads(__tstate);
30516 if (PyErr_Occurred()) SWIG_fail;
30517 }
30518 Py_INCREF(Py_None); resultobj = Py_None;
30519 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30520 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30521 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30522 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 static PyObject *_wrap_wxWindow_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30530 PyObject *resultobj;
30531 wxWindow *arg1 = (wxWindow *) 0 ;
30532 wxPoint *arg2 = 0 ;
30533 wxPoint result;
30534 wxPoint temp2 ;
30535 PyObject * obj0 = 0 ;
30536 PyObject * obj1 = 0 ;
30537 char *kwnames[] = {
30538 (char *) "self",(char *) "pt", NULL
30539 };
30540
30541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30543 if (SWIG_arg_fail(1)) SWIG_fail;
30544 {
30545 arg2 = &temp2;
30546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30547 }
30548 {
30549 PyThreadState* __tstate = wxPyBeginAllowThreads();
30550 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30551
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 {
30556 wxPoint * resultptr;
30557 resultptr = new wxPoint((wxPoint &)(result));
30558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30559 }
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 static PyObject *_wrap_wxWindow_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30567 PyObject *resultobj;
30568 wxWindow *arg1 = (wxWindow *) 0 ;
30569 wxPoint *arg2 = 0 ;
30570 wxPoint result;
30571 wxPoint temp2 ;
30572 PyObject * obj0 = 0 ;
30573 PyObject * obj1 = 0 ;
30574 char *kwnames[] = {
30575 (char *) "self",(char *) "pt", NULL
30576 };
30577
30578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30580 if (SWIG_arg_fail(1)) SWIG_fail;
30581 {
30582 arg2 = &temp2;
30583 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30584 }
30585 {
30586 PyThreadState* __tstate = wxPyBeginAllowThreads();
30587 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30588
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 {
30593 wxPoint * resultptr;
30594 resultptr = new wxPoint((wxPoint &)(result));
30595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30596 }
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 static PyObject *_wrap_wxWindow_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30604 PyObject *resultobj;
30605 wxWindow *arg1 = (wxWindow *) 0 ;
30606 int arg2 ;
30607 int arg3 ;
30608 wxHitTest result;
30609 PyObject * obj0 = 0 ;
30610 PyObject * obj1 = 0 ;
30611 PyObject * obj2 = 0 ;
30612 char *kwnames[] = {
30613 (char *) "self",(char *) "x",(char *) "y", NULL
30614 };
30615
30616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxWindow_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30618 if (SWIG_arg_fail(1)) SWIG_fail;
30619 {
30620 arg2 = (int)(SWIG_As_int(obj1));
30621 if (SWIG_arg_fail(2)) SWIG_fail;
30622 }
30623 {
30624 arg3 = (int)(SWIG_As_int(obj2));
30625 if (SWIG_arg_fail(3)) SWIG_fail;
30626 }
30627 {
30628 PyThreadState* __tstate = wxPyBeginAllowThreads();
30629 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30630
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 resultobj = SWIG_From_int((result));
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 static PyObject *_wrap_wxWindow_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30642 PyObject *resultobj;
30643 wxWindow *arg1 = (wxWindow *) 0 ;
30644 wxPoint *arg2 = 0 ;
30645 wxHitTest result;
30646 wxPoint temp2 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char *kwnames[] = {
30650 (char *) "self",(char *) "pt", NULL
30651 };
30652
30653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_HitTest",kwnames,&obj0,&obj1)) goto fail;
30654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30655 if (SWIG_arg_fail(1)) SWIG_fail;
30656 {
30657 arg2 = &temp2;
30658 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30659 }
30660 {
30661 PyThreadState* __tstate = wxPyBeginAllowThreads();
30662 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30663
30664 wxPyEndAllowThreads(__tstate);
30665 if (PyErr_Occurred()) SWIG_fail;
30666 }
30667 resultobj = SWIG_From_int((result));
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 static PyObject *_wrap_wxWindow_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30675 PyObject *resultobj;
30676 wxWindow *arg1 = (wxWindow *) 0 ;
30677 long arg2 ;
30678 wxBorder result;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681
30682 if(!PyArg_ParseTuple(args,(char *)"OO:wxWindow_GetBorder",&obj0,&obj1)) goto fail;
30683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30684 if (SWIG_arg_fail(1)) SWIG_fail;
30685 {
30686 arg2 = (long)(SWIG_As_long(obj1));
30687 if (SWIG_arg_fail(2)) SWIG_fail;
30688 }
30689 {
30690 PyThreadState* __tstate = wxPyBeginAllowThreads();
30691 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30692
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 resultobj = SWIG_From_int((result));
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 static PyObject *_wrap_wxWindow_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30704 PyObject *resultobj;
30705 wxWindow *arg1 = (wxWindow *) 0 ;
30706 wxBorder result;
30707 PyObject * obj0 = 0 ;
30708
30709 if(!PyArg_ParseTuple(args,(char *)"O:wxWindow_GetBorder",&obj0)) goto fail;
30710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30711 if (SWIG_arg_fail(1)) SWIG_fail;
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30715
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 resultobj = SWIG_From_int((result));
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 static PyObject *_wrap_wxWindow_GetBorder(PyObject *self, PyObject *args) {
30727 int argc;
30728 PyObject *argv[3];
30729 int ii;
30730
30731 argc = PyObject_Length(args);
30732 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30733 argv[ii] = PyTuple_GetItem(args,ii);
30734 }
30735 if (argc == 1) {
30736 int _v;
30737 {
30738 void *ptr;
30739 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30740 _v = 0;
30741 PyErr_Clear();
30742 } else {
30743 _v = 1;
30744 }
30745 }
30746 if (_v) {
30747 return _wrap_wxWindow_GetBorder__SWIG_1(self,args);
30748 }
30749 }
30750 if (argc == 2) {
30751 int _v;
30752 {
30753 void *ptr;
30754 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30755 _v = 0;
30756 PyErr_Clear();
30757 } else {
30758 _v = 1;
30759 }
30760 }
30761 if (_v) {
30762 _v = SWIG_Check_long(argv[1]);
30763 if (_v) {
30764 return _wrap_wxWindow_GetBorder__SWIG_0(self,args);
30765 }
30766 }
30767 }
30768
30769 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'wxWindow_GetBorder'");
30770 return NULL;
30771 }
30772
30773
30774 static PyObject *_wrap_wxWindow_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30775 PyObject *resultobj;
30776 wxWindow *arg1 = (wxWindow *) 0 ;
30777 long arg2 = (long) wxUPDATE_UI_NONE ;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 char *kwnames[] = {
30781 (char *) "self",(char *) "flags", NULL
30782 };
30783
30784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxWindow_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30786 if (SWIG_arg_fail(1)) SWIG_fail;
30787 if (obj1) {
30788 {
30789 arg2 = (long)(SWIG_As_long(obj1));
30790 if (SWIG_arg_fail(2)) SWIG_fail;
30791 }
30792 }
30793 {
30794 PyThreadState* __tstate = wxPyBeginAllowThreads();
30795 (arg1)->UpdateWindowUI(arg2);
30796
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 Py_INCREF(Py_None); resultobj = Py_None;
30801 return resultobj;
30802 fail:
30803 return NULL;
30804 }
30805
30806
30807 static PyObject *_wrap_wxWindow_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30808 PyObject *resultobj;
30809 wxWindow *arg1 = (wxWindow *) 0 ;
30810 wxMenu *arg2 = (wxMenu *) 0 ;
30811 int arg3 = (int) -1 ;
30812 int arg4 = (int) -1 ;
30813 bool result;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 PyObject * obj2 = 0 ;
30817 PyObject * obj3 = 0 ;
30818 char *kwnames[] = {
30819 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30820 };
30821
30822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxWindow_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(1)) SWIG_fail;
30825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30826 if (SWIG_arg_fail(2)) SWIG_fail;
30827 if (obj2) {
30828 {
30829 arg3 = (int)(SWIG_As_int(obj2));
30830 if (SWIG_arg_fail(3)) SWIG_fail;
30831 }
30832 }
30833 if (obj3) {
30834 {
30835 arg4 = (int)(SWIG_As_int(obj3));
30836 if (SWIG_arg_fail(4)) SWIG_fail;
30837 }
30838 }
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30842
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 {
30847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 static PyObject *_wrap_wxWindow_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30856 PyObject *resultobj;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 wxMenu *arg2 = (wxMenu *) 0 ;
30859 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30860 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30861 bool result;
30862 wxPoint temp3 ;
30863 PyObject * obj0 = 0 ;
30864 PyObject * obj1 = 0 ;
30865 PyObject * obj2 = 0 ;
30866 char *kwnames[] = {
30867 (char *) "self",(char *) "menu",(char *) "pos", NULL
30868 };
30869
30870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30872 if (SWIG_arg_fail(1)) SWIG_fail;
30873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30874 if (SWIG_arg_fail(2)) SWIG_fail;
30875 if (obj2) {
30876 {
30877 arg3 = &temp3;
30878 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30879 }
30880 }
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 {
30889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30890 }
30891 return resultobj;
30892 fail:
30893 return NULL;
30894 }
30895
30896
30897 static PyObject *_wrap_wxWindow_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30898 PyObject *resultobj;
30899 wxWindow *arg1 = (wxWindow *) 0 ;
30900 long result;
30901 PyObject * obj0 = 0 ;
30902 char *kwnames[] = {
30903 (char *) "self", NULL
30904 };
30905
30906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetHandle",kwnames,&obj0)) goto fail;
30907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30908 if (SWIG_arg_fail(1)) SWIG_fail;
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (long)wxWindow_GetHandle(arg1);
30912
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 {
30917 resultobj = SWIG_From_long((long)(result));
30918 }
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 static PyObject *_wrap_wxWindow_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30926 PyObject *resultobj;
30927 wxWindow *arg1 = (wxWindow *) 0 ;
30928 long arg2 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 char *kwnames[] = {
30932 (char *) "self",(char *) "handle", NULL
30933 };
30934
30935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30937 if (SWIG_arg_fail(1)) SWIG_fail;
30938 {
30939 arg2 = (long)(SWIG_As_long(obj1));
30940 if (SWIG_arg_fail(2)) SWIG_fail;
30941 }
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 wxWindow_AssociateHandle(arg1,arg2);
30945
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 Py_INCREF(Py_None); resultobj = Py_None;
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_wxWindow_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 PyObject * obj0 = 0 ;
30960 char *kwnames[] = {
30961 (char *) "self", NULL
30962 };
30963
30964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_DissociateHandle",kwnames,&obj0)) goto fail;
30965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30966 if (SWIG_arg_fail(1)) SWIG_fail;
30967 {
30968 PyThreadState* __tstate = wxPyBeginAllowThreads();
30969 (arg1)->DissociateHandle();
30970
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 Py_INCREF(Py_None); resultobj = Py_None;
30975 return resultobj;
30976 fail:
30977 return NULL;
30978 }
30979
30980
30981 static PyObject *_wrap_wxWindow_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30982 PyObject *resultobj;
30983 wxWindow *arg1 = (wxWindow *) 0 ;
30984 int arg2 ;
30985 bool result;
30986 PyObject * obj0 = 0 ;
30987 PyObject * obj1 = 0 ;
30988 char *kwnames[] = {
30989 (char *) "self",(char *) "orient", NULL
30990 };
30991
30992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30994 if (SWIG_arg_fail(1)) SWIG_fail;
30995 {
30996 arg2 = (int)(SWIG_As_int(obj1));
30997 if (SWIG_arg_fail(2)) SWIG_fail;
30998 }
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31002
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 {
31007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31008 }
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 static PyObject *_wrap_wxWindow_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31016 PyObject *resultobj;
31017 wxWindow *arg1 = (wxWindow *) 0 ;
31018 int arg2 ;
31019 int arg3 ;
31020 int arg4 ;
31021 int arg5 ;
31022 bool arg6 = (bool) true ;
31023 PyObject * obj0 = 0 ;
31024 PyObject * obj1 = 0 ;
31025 PyObject * obj2 = 0 ;
31026 PyObject * obj3 = 0 ;
31027 PyObject * obj4 = 0 ;
31028 PyObject * obj5 = 0 ;
31029 char *kwnames[] = {
31030 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31031 };
31032
31033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:wxWindow_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31035 if (SWIG_arg_fail(1)) SWIG_fail;
31036 {
31037 arg2 = (int)(SWIG_As_int(obj1));
31038 if (SWIG_arg_fail(2)) SWIG_fail;
31039 }
31040 {
31041 arg3 = (int)(SWIG_As_int(obj2));
31042 if (SWIG_arg_fail(3)) SWIG_fail;
31043 }
31044 {
31045 arg4 = (int)(SWIG_As_int(obj3));
31046 if (SWIG_arg_fail(4)) SWIG_fail;
31047 }
31048 {
31049 arg5 = (int)(SWIG_As_int(obj4));
31050 if (SWIG_arg_fail(5)) SWIG_fail;
31051 }
31052 if (obj5) {
31053 {
31054 arg6 = (bool)(SWIG_As_bool(obj5));
31055 if (SWIG_arg_fail(6)) SWIG_fail;
31056 }
31057 }
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31061
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 Py_INCREF(Py_None); resultobj = Py_None;
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 static PyObject *_wrap_wxWindow_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31073 PyObject *resultobj;
31074 wxWindow *arg1 = (wxWindow *) 0 ;
31075 int arg2 ;
31076 int arg3 ;
31077 bool arg4 = (bool) true ;
31078 PyObject * obj0 = 0 ;
31079 PyObject * obj1 = 0 ;
31080 PyObject * obj2 = 0 ;
31081 PyObject * obj3 = 0 ;
31082 char *kwnames[] = {
31083 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31084 };
31085
31086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxWindow_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31088 if (SWIG_arg_fail(1)) SWIG_fail;
31089 {
31090 arg2 = (int)(SWIG_As_int(obj1));
31091 if (SWIG_arg_fail(2)) SWIG_fail;
31092 }
31093 {
31094 arg3 = (int)(SWIG_As_int(obj2));
31095 if (SWIG_arg_fail(3)) SWIG_fail;
31096 }
31097 if (obj3) {
31098 {
31099 arg4 = (bool)(SWIG_As_bool(obj3));
31100 if (SWIG_arg_fail(4)) SWIG_fail;
31101 }
31102 }
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 (arg1)->SetScrollPos(arg2,arg3,arg4);
31106
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 Py_INCREF(Py_None); resultobj = Py_None;
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 static PyObject *_wrap_wxWindow_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31118 PyObject *resultobj;
31119 wxWindow *arg1 = (wxWindow *) 0 ;
31120 int arg2 ;
31121 int result;
31122 PyObject * obj0 = 0 ;
31123 PyObject * obj1 = 0 ;
31124 char *kwnames[] = {
31125 (char *) "self",(char *) "orientation", NULL
31126 };
31127
31128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31130 if (SWIG_arg_fail(1)) SWIG_fail;
31131 {
31132 arg2 = (int)(SWIG_As_int(obj1));
31133 if (SWIG_arg_fail(2)) SWIG_fail;
31134 }
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31138
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 {
31143 resultobj = SWIG_From_int((int)(result));
31144 }
31145 return resultobj;
31146 fail:
31147 return NULL;
31148 }
31149
31150
31151 static PyObject *_wrap_wxWindow_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31152 PyObject *resultobj;
31153 wxWindow *arg1 = (wxWindow *) 0 ;
31154 int arg2 ;
31155 int result;
31156 PyObject * obj0 = 0 ;
31157 PyObject * obj1 = 0 ;
31158 char *kwnames[] = {
31159 (char *) "self",(char *) "orientation", NULL
31160 };
31161
31162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31164 if (SWIG_arg_fail(1)) SWIG_fail;
31165 {
31166 arg2 = (int)(SWIG_As_int(obj1));
31167 if (SWIG_arg_fail(2)) SWIG_fail;
31168 }
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31172
31173 wxPyEndAllowThreads(__tstate);
31174 if (PyErr_Occurred()) SWIG_fail;
31175 }
31176 {
31177 resultobj = SWIG_From_int((int)(result));
31178 }
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 static PyObject *_wrap_wxWindow_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31186 PyObject *resultobj;
31187 wxWindow *arg1 = (wxWindow *) 0 ;
31188 int arg2 ;
31189 int result;
31190 PyObject * obj0 = 0 ;
31191 PyObject * obj1 = 0 ;
31192 char *kwnames[] = {
31193 (char *) "self",(char *) "orientation", NULL
31194 };
31195
31196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31198 if (SWIG_arg_fail(1)) SWIG_fail;
31199 {
31200 arg2 = (int)(SWIG_As_int(obj1));
31201 if (SWIG_arg_fail(2)) SWIG_fail;
31202 }
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31206
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 {
31211 resultobj = SWIG_From_int((int)(result));
31212 }
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_wxWindow_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 int arg2 ;
31223 int arg3 ;
31224 wxRect *arg4 = (wxRect *) NULL ;
31225 PyObject * obj0 = 0 ;
31226 PyObject * obj1 = 0 ;
31227 PyObject * obj2 = 0 ;
31228 PyObject * obj3 = 0 ;
31229 char *kwnames[] = {
31230 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31231 };
31232
31233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxWindow_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31235 if (SWIG_arg_fail(1)) SWIG_fail;
31236 {
31237 arg2 = (int)(SWIG_As_int(obj1));
31238 if (SWIG_arg_fail(2)) SWIG_fail;
31239 }
31240 {
31241 arg3 = (int)(SWIG_As_int(obj2));
31242 if (SWIG_arg_fail(3)) SWIG_fail;
31243 }
31244 if (obj3) {
31245 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31246 if (SWIG_arg_fail(4)) SWIG_fail;
31247 }
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31251
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 Py_INCREF(Py_None); resultobj = Py_None;
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 static PyObject *_wrap_wxWindow_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 int arg2 ;
31266 bool result;
31267 PyObject * obj0 = 0 ;
31268 PyObject * obj1 = 0 ;
31269 char *kwnames[] = {
31270 (char *) "self",(char *) "lines", NULL
31271 };
31272
31273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31275 if (SWIG_arg_fail(1)) SWIG_fail;
31276 {
31277 arg2 = (int)(SWIG_As_int(obj1));
31278 if (SWIG_arg_fail(2)) SWIG_fail;
31279 }
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 result = (bool)(arg1)->ScrollLines(arg2);
31283
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 {
31288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31289 }
31290 return resultobj;
31291 fail:
31292 return NULL;
31293 }
31294
31295
31296 static PyObject *_wrap_wxWindow_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31297 PyObject *resultobj;
31298 wxWindow *arg1 = (wxWindow *) 0 ;
31299 int arg2 ;
31300 bool result;
31301 PyObject * obj0 = 0 ;
31302 PyObject * obj1 = 0 ;
31303 char *kwnames[] = {
31304 (char *) "self",(char *) "pages", NULL
31305 };
31306
31307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31309 if (SWIG_arg_fail(1)) SWIG_fail;
31310 {
31311 arg2 = (int)(SWIG_As_int(obj1));
31312 if (SWIG_arg_fail(2)) SWIG_fail;
31313 }
31314 {
31315 PyThreadState* __tstate = wxPyBeginAllowThreads();
31316 result = (bool)(arg1)->ScrollPages(arg2);
31317
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 {
31322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31323 }
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 static PyObject *_wrap_wxWindow_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj;
31332 wxWindow *arg1 = (wxWindow *) 0 ;
31333 bool result;
31334 PyObject * obj0 = 0 ;
31335 char *kwnames[] = {
31336 (char *) "self", NULL
31337 };
31338
31339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_LineUp",kwnames,&obj0)) goto fail;
31340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31341 if (SWIG_arg_fail(1)) SWIG_fail;
31342 {
31343 PyThreadState* __tstate = wxPyBeginAllowThreads();
31344 result = (bool)(arg1)->LineUp();
31345
31346 wxPyEndAllowThreads(__tstate);
31347 if (PyErr_Occurred()) SWIG_fail;
31348 }
31349 {
31350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31351 }
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 static PyObject *_wrap_wxWindow_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj;
31360 wxWindow *arg1 = (wxWindow *) 0 ;
31361 bool result;
31362 PyObject * obj0 = 0 ;
31363 char *kwnames[] = {
31364 (char *) "self", NULL
31365 };
31366
31367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_LineDown",kwnames,&obj0)) goto fail;
31368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31369 if (SWIG_arg_fail(1)) SWIG_fail;
31370 {
31371 PyThreadState* __tstate = wxPyBeginAllowThreads();
31372 result = (bool)(arg1)->LineDown();
31373
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 {
31378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31379 }
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 static PyObject *_wrap_wxWindow_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31387 PyObject *resultobj;
31388 wxWindow *arg1 = (wxWindow *) 0 ;
31389 bool result;
31390 PyObject * obj0 = 0 ;
31391 char *kwnames[] = {
31392 (char *) "self", NULL
31393 };
31394
31395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_PageUp",kwnames,&obj0)) goto fail;
31396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31397 if (SWIG_arg_fail(1)) SWIG_fail;
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 result = (bool)(arg1)->PageUp();
31401
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 {
31406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31407 }
31408 return resultobj;
31409 fail:
31410 return NULL;
31411 }
31412
31413
31414 static PyObject *_wrap_wxWindow_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31415 PyObject *resultobj;
31416 wxWindow *arg1 = (wxWindow *) 0 ;
31417 bool result;
31418 PyObject * obj0 = 0 ;
31419 char *kwnames[] = {
31420 (char *) "self", NULL
31421 };
31422
31423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_PageDown",kwnames,&obj0)) goto fail;
31424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31425 if (SWIG_arg_fail(1)) SWIG_fail;
31426 {
31427 PyThreadState* __tstate = wxPyBeginAllowThreads();
31428 result = (bool)(arg1)->PageDown();
31429
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 {
31434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31435 }
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 static PyObject *_wrap_wxWindow_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31443 PyObject *resultobj;
31444 wxWindow *arg1 = (wxWindow *) 0 ;
31445 wxString *arg2 = 0 ;
31446 bool temp2 = false ;
31447 PyObject * obj0 = 0 ;
31448 PyObject * obj1 = 0 ;
31449 char *kwnames[] = {
31450 (char *) "self",(char *) "text", NULL
31451 };
31452
31453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31455 if (SWIG_arg_fail(1)) SWIG_fail;
31456 {
31457 arg2 = wxString_in_helper(obj1);
31458 if (arg2 == NULL) SWIG_fail;
31459 temp2 = true;
31460 }
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 (arg1)->SetHelpText((wxString const &)*arg2);
31464
31465 wxPyEndAllowThreads(__tstate);
31466 if (PyErr_Occurred()) SWIG_fail;
31467 }
31468 Py_INCREF(Py_None); resultobj = Py_None;
31469 {
31470 if (temp2)
31471 delete arg2;
31472 }
31473 return resultobj;
31474 fail:
31475 {
31476 if (temp2)
31477 delete arg2;
31478 }
31479 return NULL;
31480 }
31481
31482
31483 static PyObject *_wrap_wxWindow_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31484 PyObject *resultobj;
31485 wxWindow *arg1 = (wxWindow *) 0 ;
31486 wxString *arg2 = 0 ;
31487 bool temp2 = false ;
31488 PyObject * obj0 = 0 ;
31489 PyObject * obj1 = 0 ;
31490 char *kwnames[] = {
31491 (char *) "self",(char *) "text", NULL
31492 };
31493
31494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31496 if (SWIG_arg_fail(1)) SWIG_fail;
31497 {
31498 arg2 = wxString_in_helper(obj1);
31499 if (arg2 == NULL) SWIG_fail;
31500 temp2 = true;
31501 }
31502 {
31503 PyThreadState* __tstate = wxPyBeginAllowThreads();
31504 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31505
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 Py_INCREF(Py_None); resultobj = Py_None;
31510 {
31511 if (temp2)
31512 delete arg2;
31513 }
31514 return resultobj;
31515 fail:
31516 {
31517 if (temp2)
31518 delete arg2;
31519 }
31520 return NULL;
31521 }
31522
31523
31524 static PyObject *_wrap_wxWindow_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31525 PyObject *resultobj;
31526 wxWindow *arg1 = (wxWindow *) 0 ;
31527 wxString result;
31528 PyObject * obj0 = 0 ;
31529 char *kwnames[] = {
31530 (char *) "self", NULL
31531 };
31532
31533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetHelpText",kwnames,&obj0)) goto fail;
31534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31535 if (SWIG_arg_fail(1)) SWIG_fail;
31536 {
31537 PyThreadState* __tstate = wxPyBeginAllowThreads();
31538 result = ((wxWindow const *)arg1)->GetHelpText();
31539
31540 wxPyEndAllowThreads(__tstate);
31541 if (PyErr_Occurred()) SWIG_fail;
31542 }
31543 {
31544 #if wxUSE_UNICODE
31545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31546 #else
31547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31548 #endif
31549 }
31550 return resultobj;
31551 fail:
31552 return NULL;
31553 }
31554
31555
31556 static PyObject *_wrap_wxWindow_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31557 PyObject *resultobj;
31558 wxWindow *arg1 = (wxWindow *) 0 ;
31559 wxString *arg2 = 0 ;
31560 bool temp2 = false ;
31561 PyObject * obj0 = 0 ;
31562 PyObject * obj1 = 0 ;
31563 char *kwnames[] = {
31564 (char *) "self",(char *) "tip", NULL
31565 };
31566
31567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31569 if (SWIG_arg_fail(1)) SWIG_fail;
31570 {
31571 arg2 = wxString_in_helper(obj1);
31572 if (arg2 == NULL) SWIG_fail;
31573 temp2 = true;
31574 }
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 (arg1)->SetToolTip((wxString const &)*arg2);
31578
31579 wxPyEndAllowThreads(__tstate);
31580 if (PyErr_Occurred()) SWIG_fail;
31581 }
31582 Py_INCREF(Py_None); resultobj = Py_None;
31583 {
31584 if (temp2)
31585 delete arg2;
31586 }
31587 return resultobj;
31588 fail:
31589 {
31590 if (temp2)
31591 delete arg2;
31592 }
31593 return NULL;
31594 }
31595
31596
31597 static PyObject *_wrap_wxWindow_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31598 PyObject *resultobj;
31599 wxWindow *arg1 = (wxWindow *) 0 ;
31600 wxToolTip *arg2 = (wxToolTip *) 0 ;
31601 PyObject * obj0 = 0 ;
31602 PyObject * obj1 = 0 ;
31603 char *kwnames[] = {
31604 (char *) "self",(char *) "tip", NULL
31605 };
31606
31607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31609 if (SWIG_arg_fail(1)) SWIG_fail;
31610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31611 if (SWIG_arg_fail(2)) SWIG_fail;
31612 {
31613 PyThreadState* __tstate = wxPyBeginAllowThreads();
31614 (arg1)->SetToolTip(arg2);
31615
31616 wxPyEndAllowThreads(__tstate);
31617 if (PyErr_Occurred()) SWIG_fail;
31618 }
31619 Py_INCREF(Py_None); resultobj = Py_None;
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 static PyObject *_wrap_wxWindow_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj;
31628 wxWindow *arg1 = (wxWindow *) 0 ;
31629 wxToolTip *result;
31630 PyObject * obj0 = 0 ;
31631 char *kwnames[] = {
31632 (char *) "self", NULL
31633 };
31634
31635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetToolTip",kwnames,&obj0)) goto fail;
31636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31637 if (SWIG_arg_fail(1)) SWIG_fail;
31638 {
31639 PyThreadState* __tstate = wxPyBeginAllowThreads();
31640 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31641
31642 wxPyEndAllowThreads(__tstate);
31643 if (PyErr_Occurred()) SWIG_fail;
31644 }
31645 {
31646 resultobj = wxPyMake_wxObject(result, 0);
31647 }
31648 return resultobj;
31649 fail:
31650 return NULL;
31651 }
31652
31653
31654 static PyObject *_wrap_wxWindow_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31655 PyObject *resultobj;
31656 wxWindow *arg1 = (wxWindow *) 0 ;
31657 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31658 PyObject * obj0 = 0 ;
31659 PyObject * obj1 = 0 ;
31660 char *kwnames[] = {
31661 (char *) "self",(char *) "dropTarget", NULL
31662 };
31663
31664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31666 if (SWIG_arg_fail(1)) SWIG_fail;
31667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31668 if (SWIG_arg_fail(2)) SWIG_fail;
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 (arg1)->SetDropTarget(arg2);
31672
31673 wxPyEndAllowThreads(__tstate);
31674 if (PyErr_Occurred()) SWIG_fail;
31675 }
31676 Py_INCREF(Py_None); resultobj = Py_None;
31677 return resultobj;
31678 fail:
31679 return NULL;
31680 }
31681
31682
31683 static PyObject *_wrap_wxWindow_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31684 PyObject *resultobj;
31685 wxWindow *arg1 = (wxWindow *) 0 ;
31686 wxPyDropTarget *result;
31687 PyObject * obj0 = 0 ;
31688 char *kwnames[] = {
31689 (char *) "self", NULL
31690 };
31691
31692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetDropTarget",kwnames,&obj0)) goto fail;
31693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31694 if (SWIG_arg_fail(1)) SWIG_fail;
31695 {
31696 PyThreadState* __tstate = wxPyBeginAllowThreads();
31697 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31698
31699 wxPyEndAllowThreads(__tstate);
31700 if (PyErr_Occurred()) SWIG_fail;
31701 }
31702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31703 return resultobj;
31704 fail:
31705 return NULL;
31706 }
31707
31708
31709 static PyObject *_wrap_wxWindow_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31710 PyObject *resultobj;
31711 wxWindow *arg1 = (wxWindow *) 0 ;
31712 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31713 PyObject * obj0 = 0 ;
31714 PyObject * obj1 = 0 ;
31715 char *kwnames[] = {
31716 (char *) "self",(char *) "constraints", NULL
31717 };
31718
31719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31721 if (SWIG_arg_fail(1)) SWIG_fail;
31722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31723 if (SWIG_arg_fail(2)) SWIG_fail;
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 (arg1)->SetConstraints(arg2);
31727
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 Py_INCREF(Py_None); resultobj = Py_None;
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 static PyObject *_wrap_wxWindow_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31739 PyObject *resultobj;
31740 wxWindow *arg1 = (wxWindow *) 0 ;
31741 wxLayoutConstraints *result;
31742 PyObject * obj0 = 0 ;
31743 char *kwnames[] = {
31744 (char *) "self", NULL
31745 };
31746
31747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetConstraints",kwnames,&obj0)) goto fail;
31748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31749 if (SWIG_arg_fail(1)) SWIG_fail;
31750 {
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31753
31754 wxPyEndAllowThreads(__tstate);
31755 if (PyErr_Occurred()) SWIG_fail;
31756 }
31757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31758 return resultobj;
31759 fail:
31760 return NULL;
31761 }
31762
31763
31764 static PyObject *_wrap_wxWindow_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31765 PyObject *resultobj;
31766 wxWindow *arg1 = (wxWindow *) 0 ;
31767 bool arg2 ;
31768 PyObject * obj0 = 0 ;
31769 PyObject * obj1 = 0 ;
31770 char *kwnames[] = {
31771 (char *) "self",(char *) "autoLayout", NULL
31772 };
31773
31774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31776 if (SWIG_arg_fail(1)) SWIG_fail;
31777 {
31778 arg2 = (bool)(SWIG_As_bool(obj1));
31779 if (SWIG_arg_fail(2)) SWIG_fail;
31780 }
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 (arg1)->SetAutoLayout(arg2);
31784
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 Py_INCREF(Py_None); resultobj = Py_None;
31789 return resultobj;
31790 fail:
31791 return NULL;
31792 }
31793
31794
31795 static PyObject *_wrap_wxWindow_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31796 PyObject *resultobj;
31797 wxWindow *arg1 = (wxWindow *) 0 ;
31798 bool result;
31799 PyObject * obj0 = 0 ;
31800 char *kwnames[] = {
31801 (char *) "self", NULL
31802 };
31803
31804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetAutoLayout",kwnames,&obj0)) goto fail;
31805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31806 if (SWIG_arg_fail(1)) SWIG_fail;
31807 {
31808 PyThreadState* __tstate = wxPyBeginAllowThreads();
31809 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31810
31811 wxPyEndAllowThreads(__tstate);
31812 if (PyErr_Occurred()) SWIG_fail;
31813 }
31814 {
31815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31816 }
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 static PyObject *_wrap_wxWindow_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31824 PyObject *resultobj;
31825 wxWindow *arg1 = (wxWindow *) 0 ;
31826 bool result;
31827 PyObject * obj0 = 0 ;
31828 char *kwnames[] = {
31829 (char *) "self", NULL
31830 };
31831
31832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_Layout",kwnames,&obj0)) goto fail;
31833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31834 if (SWIG_arg_fail(1)) SWIG_fail;
31835 {
31836 PyThreadState* __tstate = wxPyBeginAllowThreads();
31837 result = (bool)(arg1)->Layout();
31838
31839 wxPyEndAllowThreads(__tstate);
31840 if (PyErr_Occurred()) SWIG_fail;
31841 }
31842 {
31843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31844 }
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 static PyObject *_wrap_wxWindow_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj;
31853 wxWindow *arg1 = (wxWindow *) 0 ;
31854 wxSizer *arg2 = (wxSizer *) 0 ;
31855 bool arg3 = (bool) true ;
31856 PyObject * obj0 = 0 ;
31857 PyObject * obj1 = 0 ;
31858 PyObject * obj2 = 0 ;
31859 char *kwnames[] = {
31860 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31861 };
31862
31863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31865 if (SWIG_arg_fail(1)) SWIG_fail;
31866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31867 if (SWIG_arg_fail(2)) SWIG_fail;
31868 if (obj2) {
31869 {
31870 arg3 = (bool)(SWIG_As_bool(obj2));
31871 if (SWIG_arg_fail(3)) SWIG_fail;
31872 }
31873 }
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 (arg1)->SetSizer(arg2,arg3);
31877
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 Py_INCREF(Py_None); resultobj = Py_None;
31882 return resultobj;
31883 fail:
31884 return NULL;
31885 }
31886
31887
31888 static PyObject *_wrap_wxWindow_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31889 PyObject *resultobj;
31890 wxWindow *arg1 = (wxWindow *) 0 ;
31891 wxSizer *arg2 = (wxSizer *) 0 ;
31892 bool arg3 = (bool) true ;
31893 PyObject * obj0 = 0 ;
31894 PyObject * obj1 = 0 ;
31895 PyObject * obj2 = 0 ;
31896 char *kwnames[] = {
31897 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31898 };
31899
31900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxWindow_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31902 if (SWIG_arg_fail(1)) SWIG_fail;
31903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31904 if (SWIG_arg_fail(2)) SWIG_fail;
31905 if (obj2) {
31906 {
31907 arg3 = (bool)(SWIG_As_bool(obj2));
31908 if (SWIG_arg_fail(3)) SWIG_fail;
31909 }
31910 }
31911 {
31912 PyThreadState* __tstate = wxPyBeginAllowThreads();
31913 (arg1)->SetSizerAndFit(arg2,arg3);
31914
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 Py_INCREF(Py_None); resultobj = Py_None;
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 static PyObject *_wrap_wxWindow_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31926 PyObject *resultobj;
31927 wxWindow *arg1 = (wxWindow *) 0 ;
31928 wxSizer *result;
31929 PyObject * obj0 = 0 ;
31930 char *kwnames[] = {
31931 (char *) "self", NULL
31932 };
31933
31934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetSizer",kwnames,&obj0)) goto fail;
31935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31936 if (SWIG_arg_fail(1)) SWIG_fail;
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31940
31941 wxPyEndAllowThreads(__tstate);
31942 if (PyErr_Occurred()) SWIG_fail;
31943 }
31944 {
31945 resultobj = wxPyMake_wxSizer(result, 0);
31946 }
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 static PyObject *_wrap_wxWindow_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31954 PyObject *resultobj;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 wxSizer *arg2 = (wxSizer *) 0 ;
31957 PyObject * obj0 = 0 ;
31958 PyObject * obj1 = 0 ;
31959 char *kwnames[] = {
31960 (char *) "self",(char *) "sizer", NULL
31961 };
31962
31963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31965 if (SWIG_arg_fail(1)) SWIG_fail;
31966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31967 if (SWIG_arg_fail(2)) SWIG_fail;
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 (arg1)->SetContainingSizer(arg2);
31971
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 Py_INCREF(Py_None); resultobj = Py_None;
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 static PyObject *_wrap_wxWindow_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31983 PyObject *resultobj;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 wxSizer *result;
31986 PyObject * obj0 = 0 ;
31987 char *kwnames[] = {
31988 (char *) "self", NULL
31989 };
31990
31991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_GetContainingSizer",kwnames,&obj0)) goto fail;
31992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31993 if (SWIG_arg_fail(1)) SWIG_fail;
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31997
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 {
32002 resultobj = wxPyMake_wxSizer(result, 0);
32003 }
32004 return resultobj;
32005 fail:
32006 return NULL;
32007 }
32008
32009
32010 static PyObject *_wrap_wxWindow_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32011 PyObject *resultobj;
32012 wxWindow *arg1 = (wxWindow *) 0 ;
32013 PyObject * obj0 = 0 ;
32014 char *kwnames[] = {
32015 (char *) "self", NULL
32016 };
32017
32018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_InheritAttributes",kwnames,&obj0)) goto fail;
32019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32020 if (SWIG_arg_fail(1)) SWIG_fail;
32021 {
32022 PyThreadState* __tstate = wxPyBeginAllowThreads();
32023 (arg1)->InheritAttributes();
32024
32025 wxPyEndAllowThreads(__tstate);
32026 if (PyErr_Occurred()) SWIG_fail;
32027 }
32028 Py_INCREF(Py_None); resultobj = Py_None;
32029 return resultobj;
32030 fail:
32031 return NULL;
32032 }
32033
32034
32035 static PyObject *_wrap_wxWindow_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32036 PyObject *resultobj;
32037 wxWindow *arg1 = (wxWindow *) 0 ;
32038 bool result;
32039 PyObject * obj0 = 0 ;
32040 char *kwnames[] = {
32041 (char *) "self", NULL
32042 };
32043
32044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxWindow_ShouldInheritColours",kwnames,&obj0)) goto fail;
32045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32046 if (SWIG_arg_fail(1)) SWIG_fail;
32047 {
32048 PyThreadState* __tstate = wxPyBeginAllowThreads();
32049 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32050
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 {
32055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32056 }
32057 return resultobj;
32058 fail:
32059 return NULL;
32060 }
32061
32062
32063 static PyObject * wxWindow_swigregister(PyObject *, PyObject *args) {
32064 PyObject *obj;
32065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32066 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32067 Py_INCREF(obj);
32068 return Py_BuildValue((char *)"");
32069 }
32070 static PyObject *_wrap_wxFindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32071 PyObject *resultobj;
32072 long arg1 ;
32073 wxWindow *arg2 = (wxWindow *) NULL ;
32074 wxWindow *result;
32075 PyObject * obj0 = 0 ;
32076 PyObject * obj1 = 0 ;
32077 char *kwnames[] = {
32078 (char *) "id",(char *) "parent", NULL
32079 };
32080
32081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxFindWindowById",kwnames,&obj0,&obj1)) goto fail;
32082 {
32083 arg1 = (long)(SWIG_As_long(obj0));
32084 if (SWIG_arg_fail(1)) SWIG_fail;
32085 }
32086 if (obj1) {
32087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32088 if (SWIG_arg_fail(2)) SWIG_fail;
32089 }
32090 {
32091 if (!wxPyCheckForApp()) SWIG_fail;
32092 PyThreadState* __tstate = wxPyBeginAllowThreads();
32093 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32094
32095 wxPyEndAllowThreads(__tstate);
32096 if (PyErr_Occurred()) SWIG_fail;
32097 }
32098 {
32099 resultobj = wxPyMake_wxObject(result, 0);
32100 }
32101 return resultobj;
32102 fail:
32103 return NULL;
32104 }
32105
32106
32107 static PyObject *_wrap_wxFindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32108 PyObject *resultobj;
32109 wxString *arg1 = 0 ;
32110 wxWindow *arg2 = (wxWindow *) NULL ;
32111 wxWindow *result;
32112 bool temp1 = false ;
32113 PyObject * obj0 = 0 ;
32114 PyObject * obj1 = 0 ;
32115 char *kwnames[] = {
32116 (char *) "name",(char *) "parent", NULL
32117 };
32118
32119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxFindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32120 {
32121 arg1 = wxString_in_helper(obj0);
32122 if (arg1 == NULL) SWIG_fail;
32123 temp1 = true;
32124 }
32125 if (obj1) {
32126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32127 if (SWIG_arg_fail(2)) SWIG_fail;
32128 }
32129 {
32130 if (!wxPyCheckForApp()) SWIG_fail;
32131 PyThreadState* __tstate = wxPyBeginAllowThreads();
32132 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32133
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 {
32138 resultobj = wxPyMake_wxObject(result, 0);
32139 }
32140 {
32141 if (temp1)
32142 delete arg1;
32143 }
32144 return resultobj;
32145 fail:
32146 {
32147 if (temp1)
32148 delete arg1;
32149 }
32150 return NULL;
32151 }
32152
32153
32154 static PyObject *_wrap_wxFindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32155 PyObject *resultobj;
32156 wxString *arg1 = 0 ;
32157 wxWindow *arg2 = (wxWindow *) NULL ;
32158 wxWindow *result;
32159 bool temp1 = false ;
32160 PyObject * obj0 = 0 ;
32161 PyObject * obj1 = 0 ;
32162 char *kwnames[] = {
32163 (char *) "label",(char *) "parent", NULL
32164 };
32165
32166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxFindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32167 {
32168 arg1 = wxString_in_helper(obj0);
32169 if (arg1 == NULL) SWIG_fail;
32170 temp1 = true;
32171 }
32172 if (obj1) {
32173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32174 if (SWIG_arg_fail(2)) SWIG_fail;
32175 }
32176 {
32177 if (!wxPyCheckForApp()) SWIG_fail;
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32180
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 {
32185 resultobj = wxPyMake_wxObject(result, 0);
32186 }
32187 {
32188 if (temp1)
32189 delete arg1;
32190 }
32191 return resultobj;
32192 fail:
32193 {
32194 if (temp1)
32195 delete arg1;
32196 }
32197 return NULL;
32198 }
32199
32200
32201 static PyObject *_wrap_wxWindow_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32202 PyObject *resultobj;
32203 wxWindow *arg1 = (wxWindow *) 0 ;
32204 unsigned long arg2 ;
32205 wxWindow *result;
32206 PyObject * obj0 = 0 ;
32207 PyObject * obj1 = 0 ;
32208 char *kwnames[] = {
32209 (char *) "parent",(char *) "_hWnd", NULL
32210 };
32211
32212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxWindow_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32214 if (SWIG_arg_fail(1)) SWIG_fail;
32215 {
32216 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32217 if (SWIG_arg_fail(2)) SWIG_fail;
32218 }
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32222
32223 wxPyEndAllowThreads(__tstate);
32224 if (PyErr_Occurred()) SWIG_fail;
32225 }
32226 {
32227 resultobj = wxPyMake_wxObject(result, 0);
32228 }
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 static PyObject *_wrap_new_wxValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32236 PyObject *resultobj;
32237 wxValidator *result;
32238 char *kwnames[] = {
32239 NULL
32240 };
32241
32242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxValidator",kwnames)) goto fail;
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 result = (wxValidator *)new wxValidator();
32246
32247 wxPyEndAllowThreads(__tstate);
32248 if (PyErr_Occurred()) SWIG_fail;
32249 }
32250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 static PyObject *_wrap_wxValidator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32258 PyObject *resultobj;
32259 wxValidator *arg1 = (wxValidator *) 0 ;
32260 wxValidator *result;
32261 PyObject * obj0 = 0 ;
32262 char *kwnames[] = {
32263 (char *) "self", NULL
32264 };
32265
32266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxValidator_Clone",kwnames,&obj0)) goto fail;
32267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32268 if (SWIG_arg_fail(1)) SWIG_fail;
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 result = (wxValidator *)(arg1)->Clone();
32272
32273 wxPyEndAllowThreads(__tstate);
32274 if (PyErr_Occurred()) SWIG_fail;
32275 }
32276 {
32277 resultobj = wxPyMake_wxObject(result, 0);
32278 }
32279 return resultobj;
32280 fail:
32281 return NULL;
32282 }
32283
32284
32285 static PyObject *_wrap_wxValidator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32286 PyObject *resultobj;
32287 wxValidator *arg1 = (wxValidator *) 0 ;
32288 wxWindow *arg2 = (wxWindow *) 0 ;
32289 bool result;
32290 PyObject * obj0 = 0 ;
32291 PyObject * obj1 = 0 ;
32292 char *kwnames[] = {
32293 (char *) "self",(char *) "parent", NULL
32294 };
32295
32296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxValidator_Validate",kwnames,&obj0,&obj1)) goto fail;
32297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32298 if (SWIG_arg_fail(1)) SWIG_fail;
32299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32300 if (SWIG_arg_fail(2)) SWIG_fail;
32301 {
32302 PyThreadState* __tstate = wxPyBeginAllowThreads();
32303 result = (bool)(arg1)->Validate(arg2);
32304
32305 wxPyEndAllowThreads(__tstate);
32306 if (PyErr_Occurred()) SWIG_fail;
32307 }
32308 {
32309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32310 }
32311 return resultobj;
32312 fail:
32313 return NULL;
32314 }
32315
32316
32317 static PyObject *_wrap_wxValidator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32318 PyObject *resultobj;
32319 wxValidator *arg1 = (wxValidator *) 0 ;
32320 bool result;
32321 PyObject * obj0 = 0 ;
32322 char *kwnames[] = {
32323 (char *) "self", NULL
32324 };
32325
32326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxValidator_TransferToWindow",kwnames,&obj0)) goto fail;
32327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32328 if (SWIG_arg_fail(1)) SWIG_fail;
32329 {
32330 PyThreadState* __tstate = wxPyBeginAllowThreads();
32331 result = (bool)(arg1)->TransferToWindow();
32332
32333 wxPyEndAllowThreads(__tstate);
32334 if (PyErr_Occurred()) SWIG_fail;
32335 }
32336 {
32337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32338 }
32339 return resultobj;
32340 fail:
32341 return NULL;
32342 }
32343
32344
32345 static PyObject *_wrap_wxValidator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32346 PyObject *resultobj;
32347 wxValidator *arg1 = (wxValidator *) 0 ;
32348 bool result;
32349 PyObject * obj0 = 0 ;
32350 char *kwnames[] = {
32351 (char *) "self", NULL
32352 };
32353
32354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxValidator_TransferFromWindow",kwnames,&obj0)) goto fail;
32355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32356 if (SWIG_arg_fail(1)) SWIG_fail;
32357 {
32358 PyThreadState* __tstate = wxPyBeginAllowThreads();
32359 result = (bool)(arg1)->TransferFromWindow();
32360
32361 wxPyEndAllowThreads(__tstate);
32362 if (PyErr_Occurred()) SWIG_fail;
32363 }
32364 {
32365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32366 }
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 static PyObject *_wrap_wxValidator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32374 PyObject *resultobj;
32375 wxValidator *arg1 = (wxValidator *) 0 ;
32376 wxWindow *result;
32377 PyObject * obj0 = 0 ;
32378 char *kwnames[] = {
32379 (char *) "self", NULL
32380 };
32381
32382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxValidator_GetWindow",kwnames,&obj0)) goto fail;
32383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32384 if (SWIG_arg_fail(1)) SWIG_fail;
32385 {
32386 PyThreadState* __tstate = wxPyBeginAllowThreads();
32387 result = (wxWindow *)(arg1)->GetWindow();
32388
32389 wxPyEndAllowThreads(__tstate);
32390 if (PyErr_Occurred()) SWIG_fail;
32391 }
32392 {
32393 resultobj = wxPyMake_wxObject(result, 0);
32394 }
32395 return resultobj;
32396 fail:
32397 return NULL;
32398 }
32399
32400
32401 static PyObject *_wrap_wxValidator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32402 PyObject *resultobj;
32403 wxValidator *arg1 = (wxValidator *) 0 ;
32404 wxWindow *arg2 = (wxWindow *) 0 ;
32405 PyObject * obj0 = 0 ;
32406 PyObject * obj1 = 0 ;
32407 char *kwnames[] = {
32408 (char *) "self",(char *) "window", NULL
32409 };
32410
32411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxValidator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32413 if (SWIG_arg_fail(1)) SWIG_fail;
32414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32415 if (SWIG_arg_fail(2)) SWIG_fail;
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 (arg1)->SetWindow(arg2);
32419
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 Py_INCREF(Py_None); resultobj = Py_None;
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 static PyObject *_wrap_wxValidator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj;
32432 bool result;
32433 char *kwnames[] = {
32434 NULL
32435 };
32436
32437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxValidator_IsSilent",kwnames)) goto fail;
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 result = (bool)wxValidator::IsSilent();
32441
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 {
32446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32447 }
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 static PyObject *_wrap_wxValidator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32455 PyObject *resultobj;
32456 int arg1 = (int) true ;
32457 PyObject * obj0 = 0 ;
32458 char *kwnames[] = {
32459 (char *) "doIt", NULL
32460 };
32461
32462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:wxValidator_SetBellOnError",kwnames,&obj0)) goto fail;
32463 if (obj0) {
32464 {
32465 arg1 = (int)(SWIG_As_int(obj0));
32466 if (SWIG_arg_fail(1)) SWIG_fail;
32467 }
32468 }
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 wxValidator::SetBellOnError(arg1);
32472
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 Py_INCREF(Py_None); resultobj = Py_None;
32477 return resultobj;
32478 fail:
32479 return NULL;
32480 }
32481
32482
32483 static PyObject * wxValidator_swigregister(PyObject *, PyObject *args) {
32484 PyObject *obj;
32485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32486 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32487 Py_INCREF(obj);
32488 return Py_BuildValue((char *)"");
32489 }
32490 static PyObject *_wrap_new_wxPyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32491 PyObject *resultobj;
32492 wxPyValidator *result;
32493 char *kwnames[] = {
32494 NULL
32495 };
32496
32497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxPyValidator",kwnames)) goto fail;
32498 {
32499 PyThreadState* __tstate = wxPyBeginAllowThreads();
32500 result = (wxPyValidator *)new wxPyValidator();
32501
32502 wxPyEndAllowThreads(__tstate);
32503 if (PyErr_Occurred()) SWIG_fail;
32504 }
32505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 static PyObject *_wrap_wxPyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32513 PyObject *resultobj;
32514 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32515 PyObject *arg2 = (PyObject *) 0 ;
32516 PyObject *arg3 = (PyObject *) 0 ;
32517 int arg4 = (int) true ;
32518 PyObject * obj0 = 0 ;
32519 PyObject * obj1 = 0 ;
32520 PyObject * obj2 = 0 ;
32521 PyObject * obj3 = 0 ;
32522 char *kwnames[] = {
32523 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32524 };
32525
32526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxPyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32528 if (SWIG_arg_fail(1)) SWIG_fail;
32529 arg2 = obj1;
32530 arg3 = obj2;
32531 if (obj3) {
32532 {
32533 arg4 = (int)(SWIG_As_int(obj3));
32534 if (SWIG_arg_fail(4)) SWIG_fail;
32535 }
32536 }
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32540
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 Py_INCREF(Py_None); resultobj = Py_None;
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 static PyObject * wxPyValidator_swigregister(PyObject *, PyObject *args) {
32552 PyObject *obj;
32553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32554 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32555 Py_INCREF(obj);
32556 return Py_BuildValue((char *)"");
32557 }
32558 static int _wrap_wxDefaultValidator_set(PyObject *) {
32559 PyErr_SetString(PyExc_TypeError,"Variable wxDefaultValidator is read-only.");
32560 return 1;
32561 }
32562
32563
32564 static PyObject *_wrap_wxDefaultValidator_get(void) {
32565 PyObject *pyobj;
32566
32567 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32568 return pyobj;
32569 }
32570
32571
32572 static PyObject *_wrap_new_wxMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32573 PyObject *resultobj;
32574 wxString const &arg1_defvalue = wxPyEmptyString ;
32575 wxString *arg1 = (wxString *) &arg1_defvalue ;
32576 long arg2 = (long) 0 ;
32577 wxMenu *result;
32578 bool temp1 = false ;
32579 PyObject * obj0 = 0 ;
32580 PyObject * obj1 = 0 ;
32581 char *kwnames[] = {
32582 (char *) "title",(char *) "style", NULL
32583 };
32584
32585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxMenu",kwnames,&obj0,&obj1)) goto fail;
32586 if (obj0) {
32587 {
32588 arg1 = wxString_in_helper(obj0);
32589 if (arg1 == NULL) SWIG_fail;
32590 temp1 = true;
32591 }
32592 }
32593 if (obj1) {
32594 {
32595 arg2 = (long)(SWIG_As_long(obj1));
32596 if (SWIG_arg_fail(2)) SWIG_fail;
32597 }
32598 }
32599 {
32600 if (!wxPyCheckForApp()) SWIG_fail;
32601 PyThreadState* __tstate = wxPyBeginAllowThreads();
32602 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32603
32604 wxPyEndAllowThreads(__tstate);
32605 if (PyErr_Occurred()) SWIG_fail;
32606 }
32607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32608 {
32609 if (temp1)
32610 delete arg1;
32611 }
32612 return resultobj;
32613 fail:
32614 {
32615 if (temp1)
32616 delete arg1;
32617 }
32618 return NULL;
32619 }
32620
32621
32622 static PyObject *_wrap_wxMenu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32623 PyObject *resultobj;
32624 wxMenu *arg1 = (wxMenu *) 0 ;
32625 int arg2 ;
32626 wxString *arg3 = 0 ;
32627 wxString const &arg4_defvalue = wxPyEmptyString ;
32628 wxString *arg4 = (wxString *) &arg4_defvalue ;
32629 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32630 wxMenuItem *result;
32631 bool temp3 = false ;
32632 bool temp4 = false ;
32633 PyObject * obj0 = 0 ;
32634 PyObject * obj1 = 0 ;
32635 PyObject * obj2 = 0 ;
32636 PyObject * obj3 = 0 ;
32637 PyObject * obj4 = 0 ;
32638 char *kwnames[] = {
32639 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32640 };
32641
32642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:wxMenu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32644 if (SWIG_arg_fail(1)) SWIG_fail;
32645 {
32646 arg2 = (int)(SWIG_As_int(obj1));
32647 if (SWIG_arg_fail(2)) SWIG_fail;
32648 }
32649 {
32650 arg3 = wxString_in_helper(obj2);
32651 if (arg3 == NULL) SWIG_fail;
32652 temp3 = true;
32653 }
32654 if (obj3) {
32655 {
32656 arg4 = wxString_in_helper(obj3);
32657 if (arg4 == NULL) SWIG_fail;
32658 temp4 = true;
32659 }
32660 }
32661 if (obj4) {
32662 {
32663 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32664 if (SWIG_arg_fail(5)) SWIG_fail;
32665 }
32666 }
32667 {
32668 PyThreadState* __tstate = wxPyBeginAllowThreads();
32669 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32670
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 {
32675 resultobj = wxPyMake_wxObject(result, 0);
32676 }
32677 {
32678 if (temp3)
32679 delete arg3;
32680 }
32681 {
32682 if (temp4)
32683 delete arg4;
32684 }
32685 return resultobj;
32686 fail:
32687 {
32688 if (temp3)
32689 delete arg3;
32690 }
32691 {
32692 if (temp4)
32693 delete arg4;
32694 }
32695 return NULL;
32696 }
32697
32698
32699 static PyObject *_wrap_wxMenu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32700 PyObject *resultobj;
32701 wxMenu *arg1 = (wxMenu *) 0 ;
32702 wxMenuItem *result;
32703 PyObject * obj0 = 0 ;
32704 char *kwnames[] = {
32705 (char *) "self", NULL
32706 };
32707
32708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_AppendSeparator",kwnames,&obj0)) goto fail;
32709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32710 if (SWIG_arg_fail(1)) SWIG_fail;
32711 {
32712 PyThreadState* __tstate = wxPyBeginAllowThreads();
32713 result = (wxMenuItem *)(arg1)->AppendSeparator();
32714
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 {
32719 resultobj = wxPyMake_wxObject(result, 0);
32720 }
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 static PyObject *_wrap_wxMenu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32728 PyObject *resultobj;
32729 wxMenu *arg1 = (wxMenu *) 0 ;
32730 int arg2 ;
32731 wxString *arg3 = 0 ;
32732 wxString const &arg4_defvalue = wxPyEmptyString ;
32733 wxString *arg4 = (wxString *) &arg4_defvalue ;
32734 wxMenuItem *result;
32735 bool temp3 = false ;
32736 bool temp4 = false ;
32737 PyObject * obj0 = 0 ;
32738 PyObject * obj1 = 0 ;
32739 PyObject * obj2 = 0 ;
32740 PyObject * obj3 = 0 ;
32741 char *kwnames[] = {
32742 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32743 };
32744
32745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxMenu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32747 if (SWIG_arg_fail(1)) SWIG_fail;
32748 {
32749 arg2 = (int)(SWIG_As_int(obj1));
32750 if (SWIG_arg_fail(2)) SWIG_fail;
32751 }
32752 {
32753 arg3 = wxString_in_helper(obj2);
32754 if (arg3 == NULL) SWIG_fail;
32755 temp3 = true;
32756 }
32757 if (obj3) {
32758 {
32759 arg4 = wxString_in_helper(obj3);
32760 if (arg4 == NULL) SWIG_fail;
32761 temp4 = true;
32762 }
32763 }
32764 {
32765 PyThreadState* __tstate = wxPyBeginAllowThreads();
32766 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32767
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 {
32772 resultobj = wxPyMake_wxObject(result, 0);
32773 }
32774 {
32775 if (temp3)
32776 delete arg3;
32777 }
32778 {
32779 if (temp4)
32780 delete arg4;
32781 }
32782 return resultobj;
32783 fail:
32784 {
32785 if (temp3)
32786 delete arg3;
32787 }
32788 {
32789 if (temp4)
32790 delete arg4;
32791 }
32792 return NULL;
32793 }
32794
32795
32796 static PyObject *_wrap_wxMenu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32797 PyObject *resultobj;
32798 wxMenu *arg1 = (wxMenu *) 0 ;
32799 int arg2 ;
32800 wxString *arg3 = 0 ;
32801 wxString const &arg4_defvalue = wxPyEmptyString ;
32802 wxString *arg4 = (wxString *) &arg4_defvalue ;
32803 wxMenuItem *result;
32804 bool temp3 = false ;
32805 bool temp4 = false ;
32806 PyObject * obj0 = 0 ;
32807 PyObject * obj1 = 0 ;
32808 PyObject * obj2 = 0 ;
32809 PyObject * obj3 = 0 ;
32810 char *kwnames[] = {
32811 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32812 };
32813
32814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxMenu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32816 if (SWIG_arg_fail(1)) SWIG_fail;
32817 {
32818 arg2 = (int)(SWIG_As_int(obj1));
32819 if (SWIG_arg_fail(2)) SWIG_fail;
32820 }
32821 {
32822 arg3 = wxString_in_helper(obj2);
32823 if (arg3 == NULL) SWIG_fail;
32824 temp3 = true;
32825 }
32826 if (obj3) {
32827 {
32828 arg4 = wxString_in_helper(obj3);
32829 if (arg4 == NULL) SWIG_fail;
32830 temp4 = true;
32831 }
32832 }
32833 {
32834 PyThreadState* __tstate = wxPyBeginAllowThreads();
32835 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32836
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 {
32841 resultobj = wxPyMake_wxObject(result, 0);
32842 }
32843 {
32844 if (temp3)
32845 delete arg3;
32846 }
32847 {
32848 if (temp4)
32849 delete arg4;
32850 }
32851 return resultobj;
32852 fail:
32853 {
32854 if (temp3)
32855 delete arg3;
32856 }
32857 {
32858 if (temp4)
32859 delete arg4;
32860 }
32861 return NULL;
32862 }
32863
32864
32865 static PyObject *_wrap_wxMenu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj;
32867 wxMenu *arg1 = (wxMenu *) 0 ;
32868 int arg2 ;
32869 wxString *arg3 = 0 ;
32870 wxMenu *arg4 = (wxMenu *) 0 ;
32871 wxString const &arg5_defvalue = wxPyEmptyString ;
32872 wxString *arg5 = (wxString *) &arg5_defvalue ;
32873 wxMenuItem *result;
32874 bool temp3 = false ;
32875 bool temp5 = false ;
32876 PyObject * obj0 = 0 ;
32877 PyObject * obj1 = 0 ;
32878 PyObject * obj2 = 0 ;
32879 PyObject * obj3 = 0 ;
32880 PyObject * obj4 = 0 ;
32881 char *kwnames[] = {
32882 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32883 };
32884
32885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:wxMenu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32887 if (SWIG_arg_fail(1)) SWIG_fail;
32888 {
32889 arg2 = (int)(SWIG_As_int(obj1));
32890 if (SWIG_arg_fail(2)) SWIG_fail;
32891 }
32892 {
32893 arg3 = wxString_in_helper(obj2);
32894 if (arg3 == NULL) SWIG_fail;
32895 temp3 = true;
32896 }
32897 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32898 if (SWIG_arg_fail(4)) SWIG_fail;
32899 if (obj4) {
32900 {
32901 arg5 = wxString_in_helper(obj4);
32902 if (arg5 == NULL) SWIG_fail;
32903 temp5 = true;
32904 }
32905 }
32906 {
32907 PyThreadState* __tstate = wxPyBeginAllowThreads();
32908 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32909
32910 wxPyEndAllowThreads(__tstate);
32911 if (PyErr_Occurred()) SWIG_fail;
32912 }
32913 {
32914 resultobj = wxPyMake_wxObject(result, 0);
32915 }
32916 {
32917 if (temp3)
32918 delete arg3;
32919 }
32920 {
32921 if (temp5)
32922 delete arg5;
32923 }
32924 return resultobj;
32925 fail:
32926 {
32927 if (temp3)
32928 delete arg3;
32929 }
32930 {
32931 if (temp5)
32932 delete arg5;
32933 }
32934 return NULL;
32935 }
32936
32937
32938 static PyObject *_wrap_wxMenu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32939 PyObject *resultobj;
32940 wxMenu *arg1 = (wxMenu *) 0 ;
32941 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32942 wxMenuItem *result;
32943 PyObject * obj0 = 0 ;
32944 PyObject * obj1 = 0 ;
32945 char *kwnames[] = {
32946 (char *) "self",(char *) "item", NULL
32947 };
32948
32949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32951 if (SWIG_arg_fail(1)) SWIG_fail;
32952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32953 if (SWIG_arg_fail(2)) SWIG_fail;
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = (wxMenuItem *)(arg1)->Append(arg2);
32957
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 {
32962 resultobj = wxPyMake_wxObject(result, 0);
32963 }
32964 return resultobj;
32965 fail:
32966 return NULL;
32967 }
32968
32969
32970 static PyObject *_wrap_wxMenu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32971 PyObject *resultobj;
32972 wxMenu *arg1 = (wxMenu *) 0 ;
32973 PyObject * obj0 = 0 ;
32974 char *kwnames[] = {
32975 (char *) "self", NULL
32976 };
32977
32978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_Break",kwnames,&obj0)) goto fail;
32979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32980 if (SWIG_arg_fail(1)) SWIG_fail;
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 (arg1)->Break();
32984
32985 wxPyEndAllowThreads(__tstate);
32986 if (PyErr_Occurred()) SWIG_fail;
32987 }
32988 Py_INCREF(Py_None); resultobj = Py_None;
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 static PyObject *_wrap_wxMenu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj;
32997 wxMenu *arg1 = (wxMenu *) 0 ;
32998 size_t arg2 ;
32999 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33000 wxMenuItem *result;
33001 PyObject * obj0 = 0 ;
33002 PyObject * obj1 = 0 ;
33003 PyObject * obj2 = 0 ;
33004 char *kwnames[] = {
33005 (char *) "self",(char *) "pos",(char *) "item", NULL
33006 };
33007
33008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33010 if (SWIG_arg_fail(1)) SWIG_fail;
33011 {
33012 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33013 if (SWIG_arg_fail(2)) SWIG_fail;
33014 }
33015 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33016 if (SWIG_arg_fail(3)) SWIG_fail;
33017 {
33018 PyThreadState* __tstate = wxPyBeginAllowThreads();
33019 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33020
33021 wxPyEndAllowThreads(__tstate);
33022 if (PyErr_Occurred()) SWIG_fail;
33023 }
33024 {
33025 resultobj = wxPyMake_wxObject(result, 0);
33026 }
33027 return resultobj;
33028 fail:
33029 return NULL;
33030 }
33031
33032
33033 static PyObject *_wrap_wxMenu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33034 PyObject *resultobj;
33035 wxMenu *arg1 = (wxMenu *) 0 ;
33036 size_t arg2 ;
33037 int arg3 ;
33038 wxString *arg4 = 0 ;
33039 wxString const &arg5_defvalue = wxPyEmptyString ;
33040 wxString *arg5 = (wxString *) &arg5_defvalue ;
33041 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33042 wxMenuItem *result;
33043 bool temp4 = false ;
33044 bool temp5 = false ;
33045 PyObject * obj0 = 0 ;
33046 PyObject * obj1 = 0 ;
33047 PyObject * obj2 = 0 ;
33048 PyObject * obj3 = 0 ;
33049 PyObject * obj4 = 0 ;
33050 PyObject * obj5 = 0 ;
33051 char *kwnames[] = {
33052 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33053 };
33054
33055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:wxMenu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33057 if (SWIG_arg_fail(1)) SWIG_fail;
33058 {
33059 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33060 if (SWIG_arg_fail(2)) SWIG_fail;
33061 }
33062 {
33063 arg3 = (int)(SWIG_As_int(obj2));
33064 if (SWIG_arg_fail(3)) SWIG_fail;
33065 }
33066 {
33067 arg4 = wxString_in_helper(obj3);
33068 if (arg4 == NULL) SWIG_fail;
33069 temp4 = true;
33070 }
33071 if (obj4) {
33072 {
33073 arg5 = wxString_in_helper(obj4);
33074 if (arg5 == NULL) SWIG_fail;
33075 temp5 = true;
33076 }
33077 }
33078 if (obj5) {
33079 {
33080 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33081 if (SWIG_arg_fail(6)) SWIG_fail;
33082 }
33083 }
33084 {
33085 PyThreadState* __tstate = wxPyBeginAllowThreads();
33086 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33087
33088 wxPyEndAllowThreads(__tstate);
33089 if (PyErr_Occurred()) SWIG_fail;
33090 }
33091 {
33092 resultobj = wxPyMake_wxObject(result, 0);
33093 }
33094 {
33095 if (temp4)
33096 delete arg4;
33097 }
33098 {
33099 if (temp5)
33100 delete arg5;
33101 }
33102 return resultobj;
33103 fail:
33104 {
33105 if (temp4)
33106 delete arg4;
33107 }
33108 {
33109 if (temp5)
33110 delete arg5;
33111 }
33112 return NULL;
33113 }
33114
33115
33116 static PyObject *_wrap_wxMenu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33117 PyObject *resultobj;
33118 wxMenu *arg1 = (wxMenu *) 0 ;
33119 size_t arg2 ;
33120 wxMenuItem *result;
33121 PyObject * obj0 = 0 ;
33122 PyObject * obj1 = 0 ;
33123 char *kwnames[] = {
33124 (char *) "self",(char *) "pos", NULL
33125 };
33126
33127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33129 if (SWIG_arg_fail(1)) SWIG_fail;
33130 {
33131 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33132 if (SWIG_arg_fail(2)) SWIG_fail;
33133 }
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33137
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 {
33142 resultobj = wxPyMake_wxObject(result, 0);
33143 }
33144 return resultobj;
33145 fail:
33146 return NULL;
33147 }
33148
33149
33150 static PyObject *_wrap_wxMenu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33151 PyObject *resultobj;
33152 wxMenu *arg1 = (wxMenu *) 0 ;
33153 size_t arg2 ;
33154 int arg3 ;
33155 wxString *arg4 = 0 ;
33156 wxString const &arg5_defvalue = wxPyEmptyString ;
33157 wxString *arg5 = (wxString *) &arg5_defvalue ;
33158 wxMenuItem *result;
33159 bool temp4 = false ;
33160 bool temp5 = false ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 PyObject * obj2 = 0 ;
33164 PyObject * obj3 = 0 ;
33165 PyObject * obj4 = 0 ;
33166 char *kwnames[] = {
33167 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33168 };
33169
33170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:wxMenu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33172 if (SWIG_arg_fail(1)) SWIG_fail;
33173 {
33174 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33175 if (SWIG_arg_fail(2)) SWIG_fail;
33176 }
33177 {
33178 arg3 = (int)(SWIG_As_int(obj2));
33179 if (SWIG_arg_fail(3)) SWIG_fail;
33180 }
33181 {
33182 arg4 = wxString_in_helper(obj3);
33183 if (arg4 == NULL) SWIG_fail;
33184 temp4 = true;
33185 }
33186 if (obj4) {
33187 {
33188 arg5 = wxString_in_helper(obj4);
33189 if (arg5 == NULL) SWIG_fail;
33190 temp5 = true;
33191 }
33192 }
33193 {
33194 PyThreadState* __tstate = wxPyBeginAllowThreads();
33195 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33196
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 {
33201 resultobj = wxPyMake_wxObject(result, 0);
33202 }
33203 {
33204 if (temp4)
33205 delete arg4;
33206 }
33207 {
33208 if (temp5)
33209 delete arg5;
33210 }
33211 return resultobj;
33212 fail:
33213 {
33214 if (temp4)
33215 delete arg4;
33216 }
33217 {
33218 if (temp5)
33219 delete arg5;
33220 }
33221 return NULL;
33222 }
33223
33224
33225 static PyObject *_wrap_wxMenu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33226 PyObject *resultobj;
33227 wxMenu *arg1 = (wxMenu *) 0 ;
33228 size_t arg2 ;
33229 int arg3 ;
33230 wxString *arg4 = 0 ;
33231 wxString const &arg5_defvalue = wxPyEmptyString ;
33232 wxString *arg5 = (wxString *) &arg5_defvalue ;
33233 wxMenuItem *result;
33234 bool temp4 = false ;
33235 bool temp5 = false ;
33236 PyObject * obj0 = 0 ;
33237 PyObject * obj1 = 0 ;
33238 PyObject * obj2 = 0 ;
33239 PyObject * obj3 = 0 ;
33240 PyObject * obj4 = 0 ;
33241 char *kwnames[] = {
33242 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33243 };
33244
33245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:wxMenu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33247 if (SWIG_arg_fail(1)) SWIG_fail;
33248 {
33249 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33250 if (SWIG_arg_fail(2)) SWIG_fail;
33251 }
33252 {
33253 arg3 = (int)(SWIG_As_int(obj2));
33254 if (SWIG_arg_fail(3)) SWIG_fail;
33255 }
33256 {
33257 arg4 = wxString_in_helper(obj3);
33258 if (arg4 == NULL) SWIG_fail;
33259 temp4 = true;
33260 }
33261 if (obj4) {
33262 {
33263 arg5 = wxString_in_helper(obj4);
33264 if (arg5 == NULL) SWIG_fail;
33265 temp5 = true;
33266 }
33267 }
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33271
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 {
33276 resultobj = wxPyMake_wxObject(result, 0);
33277 }
33278 {
33279 if (temp4)
33280 delete arg4;
33281 }
33282 {
33283 if (temp5)
33284 delete arg5;
33285 }
33286 return resultobj;
33287 fail:
33288 {
33289 if (temp4)
33290 delete arg4;
33291 }
33292 {
33293 if (temp5)
33294 delete arg5;
33295 }
33296 return NULL;
33297 }
33298
33299
33300 static PyObject *_wrap_wxMenu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33301 PyObject *resultobj;
33302 wxMenu *arg1 = (wxMenu *) 0 ;
33303 size_t arg2 ;
33304 int arg3 ;
33305 wxString *arg4 = 0 ;
33306 wxMenu *arg5 = (wxMenu *) 0 ;
33307 wxString const &arg6_defvalue = wxPyEmptyString ;
33308 wxString *arg6 = (wxString *) &arg6_defvalue ;
33309 wxMenuItem *result;
33310 bool temp4 = false ;
33311 bool temp6 = false ;
33312 PyObject * obj0 = 0 ;
33313 PyObject * obj1 = 0 ;
33314 PyObject * obj2 = 0 ;
33315 PyObject * obj3 = 0 ;
33316 PyObject * obj4 = 0 ;
33317 PyObject * obj5 = 0 ;
33318 char *kwnames[] = {
33319 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33320 };
33321
33322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:wxMenu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33324 if (SWIG_arg_fail(1)) SWIG_fail;
33325 {
33326 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33327 if (SWIG_arg_fail(2)) SWIG_fail;
33328 }
33329 {
33330 arg3 = (int)(SWIG_As_int(obj2));
33331 if (SWIG_arg_fail(3)) SWIG_fail;
33332 }
33333 {
33334 arg4 = wxString_in_helper(obj3);
33335 if (arg4 == NULL) SWIG_fail;
33336 temp4 = true;
33337 }
33338 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33339 if (SWIG_arg_fail(5)) SWIG_fail;
33340 if (obj5) {
33341 {
33342 arg6 = wxString_in_helper(obj5);
33343 if (arg6 == NULL) SWIG_fail;
33344 temp6 = true;
33345 }
33346 }
33347 {
33348 PyThreadState* __tstate = wxPyBeginAllowThreads();
33349 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33350
33351 wxPyEndAllowThreads(__tstate);
33352 if (PyErr_Occurred()) SWIG_fail;
33353 }
33354 {
33355 resultobj = wxPyMake_wxObject(result, 0);
33356 }
33357 {
33358 if (temp4)
33359 delete arg4;
33360 }
33361 {
33362 if (temp6)
33363 delete arg6;
33364 }
33365 return resultobj;
33366 fail:
33367 {
33368 if (temp4)
33369 delete arg4;
33370 }
33371 {
33372 if (temp6)
33373 delete arg6;
33374 }
33375 return NULL;
33376 }
33377
33378
33379 static PyObject *_wrap_wxMenu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33380 PyObject *resultobj;
33381 wxMenu *arg1 = (wxMenu *) 0 ;
33382 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33383 wxMenuItem *result;
33384 PyObject * obj0 = 0 ;
33385 PyObject * obj1 = 0 ;
33386 char *kwnames[] = {
33387 (char *) "self",(char *) "item", NULL
33388 };
33389
33390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33392 if (SWIG_arg_fail(1)) SWIG_fail;
33393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33394 if (SWIG_arg_fail(2)) SWIG_fail;
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33398
33399 wxPyEndAllowThreads(__tstate);
33400 if (PyErr_Occurred()) SWIG_fail;
33401 }
33402 {
33403 resultobj = wxPyMake_wxObject(result, 0);
33404 }
33405 return resultobj;
33406 fail:
33407 return NULL;
33408 }
33409
33410
33411 static PyObject *_wrap_wxMenu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33412 PyObject *resultobj;
33413 wxMenu *arg1 = (wxMenu *) 0 ;
33414 int arg2 ;
33415 wxString *arg3 = 0 ;
33416 wxString const &arg4_defvalue = wxPyEmptyString ;
33417 wxString *arg4 = (wxString *) &arg4_defvalue ;
33418 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33419 wxMenuItem *result;
33420 bool temp3 = false ;
33421 bool temp4 = false ;
33422 PyObject * obj0 = 0 ;
33423 PyObject * obj1 = 0 ;
33424 PyObject * obj2 = 0 ;
33425 PyObject * obj3 = 0 ;
33426 PyObject * obj4 = 0 ;
33427 char *kwnames[] = {
33428 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33429 };
33430
33431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:wxMenu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33433 if (SWIG_arg_fail(1)) SWIG_fail;
33434 {
33435 arg2 = (int)(SWIG_As_int(obj1));
33436 if (SWIG_arg_fail(2)) SWIG_fail;
33437 }
33438 {
33439 arg3 = wxString_in_helper(obj2);
33440 if (arg3 == NULL) SWIG_fail;
33441 temp3 = true;
33442 }
33443 if (obj3) {
33444 {
33445 arg4 = wxString_in_helper(obj3);
33446 if (arg4 == NULL) SWIG_fail;
33447 temp4 = true;
33448 }
33449 }
33450 if (obj4) {
33451 {
33452 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33453 if (SWIG_arg_fail(5)) SWIG_fail;
33454 }
33455 }
33456 {
33457 PyThreadState* __tstate = wxPyBeginAllowThreads();
33458 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33459
33460 wxPyEndAllowThreads(__tstate);
33461 if (PyErr_Occurred()) SWIG_fail;
33462 }
33463 {
33464 resultobj = wxPyMake_wxObject(result, 0);
33465 }
33466 {
33467 if (temp3)
33468 delete arg3;
33469 }
33470 {
33471 if (temp4)
33472 delete arg4;
33473 }
33474 return resultobj;
33475 fail:
33476 {
33477 if (temp3)
33478 delete arg3;
33479 }
33480 {
33481 if (temp4)
33482 delete arg4;
33483 }
33484 return NULL;
33485 }
33486
33487
33488 static PyObject *_wrap_wxMenu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33489 PyObject *resultobj;
33490 wxMenu *arg1 = (wxMenu *) 0 ;
33491 wxMenuItem *result;
33492 PyObject * obj0 = 0 ;
33493 char *kwnames[] = {
33494 (char *) "self", NULL
33495 };
33496
33497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_PrependSeparator",kwnames,&obj0)) goto fail;
33498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33499 if (SWIG_arg_fail(1)) SWIG_fail;
33500 {
33501 PyThreadState* __tstate = wxPyBeginAllowThreads();
33502 result = (wxMenuItem *)(arg1)->PrependSeparator();
33503
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 {
33508 resultobj = wxPyMake_wxObject(result, 0);
33509 }
33510 return resultobj;
33511 fail:
33512 return NULL;
33513 }
33514
33515
33516 static PyObject *_wrap_wxMenu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33517 PyObject *resultobj;
33518 wxMenu *arg1 = (wxMenu *) 0 ;
33519 int arg2 ;
33520 wxString *arg3 = 0 ;
33521 wxString const &arg4_defvalue = wxPyEmptyString ;
33522 wxString *arg4 = (wxString *) &arg4_defvalue ;
33523 wxMenuItem *result;
33524 bool temp3 = false ;
33525 bool temp4 = false ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 PyObject * obj2 = 0 ;
33529 PyObject * obj3 = 0 ;
33530 char *kwnames[] = {
33531 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33532 };
33533
33534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxMenu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33536 if (SWIG_arg_fail(1)) SWIG_fail;
33537 {
33538 arg2 = (int)(SWIG_As_int(obj1));
33539 if (SWIG_arg_fail(2)) SWIG_fail;
33540 }
33541 {
33542 arg3 = wxString_in_helper(obj2);
33543 if (arg3 == NULL) SWIG_fail;
33544 temp3 = true;
33545 }
33546 if (obj3) {
33547 {
33548 arg4 = wxString_in_helper(obj3);
33549 if (arg4 == NULL) SWIG_fail;
33550 temp4 = true;
33551 }
33552 }
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33556
33557 wxPyEndAllowThreads(__tstate);
33558 if (PyErr_Occurred()) SWIG_fail;
33559 }
33560 {
33561 resultobj = wxPyMake_wxObject(result, 0);
33562 }
33563 {
33564 if (temp3)
33565 delete arg3;
33566 }
33567 {
33568 if (temp4)
33569 delete arg4;
33570 }
33571 return resultobj;
33572 fail:
33573 {
33574 if (temp3)
33575 delete arg3;
33576 }
33577 {
33578 if (temp4)
33579 delete arg4;
33580 }
33581 return NULL;
33582 }
33583
33584
33585 static PyObject *_wrap_wxMenu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33586 PyObject *resultobj;
33587 wxMenu *arg1 = (wxMenu *) 0 ;
33588 int arg2 ;
33589 wxString *arg3 = 0 ;
33590 wxString const &arg4_defvalue = wxPyEmptyString ;
33591 wxString *arg4 = (wxString *) &arg4_defvalue ;
33592 wxMenuItem *result;
33593 bool temp3 = false ;
33594 bool temp4 = false ;
33595 PyObject * obj0 = 0 ;
33596 PyObject * obj1 = 0 ;
33597 PyObject * obj2 = 0 ;
33598 PyObject * obj3 = 0 ;
33599 char *kwnames[] = {
33600 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33601 };
33602
33603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxMenu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33605 if (SWIG_arg_fail(1)) SWIG_fail;
33606 {
33607 arg2 = (int)(SWIG_As_int(obj1));
33608 if (SWIG_arg_fail(2)) SWIG_fail;
33609 }
33610 {
33611 arg3 = wxString_in_helper(obj2);
33612 if (arg3 == NULL) SWIG_fail;
33613 temp3 = true;
33614 }
33615 if (obj3) {
33616 {
33617 arg4 = wxString_in_helper(obj3);
33618 if (arg4 == NULL) SWIG_fail;
33619 temp4 = true;
33620 }
33621 }
33622 {
33623 PyThreadState* __tstate = wxPyBeginAllowThreads();
33624 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33625
33626 wxPyEndAllowThreads(__tstate);
33627 if (PyErr_Occurred()) SWIG_fail;
33628 }
33629 {
33630 resultobj = wxPyMake_wxObject(result, 0);
33631 }
33632 {
33633 if (temp3)
33634 delete arg3;
33635 }
33636 {
33637 if (temp4)
33638 delete arg4;
33639 }
33640 return resultobj;
33641 fail:
33642 {
33643 if (temp3)
33644 delete arg3;
33645 }
33646 {
33647 if (temp4)
33648 delete arg4;
33649 }
33650 return NULL;
33651 }
33652
33653
33654 static PyObject *_wrap_wxMenu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33655 PyObject *resultobj;
33656 wxMenu *arg1 = (wxMenu *) 0 ;
33657 int arg2 ;
33658 wxString *arg3 = 0 ;
33659 wxMenu *arg4 = (wxMenu *) 0 ;
33660 wxString const &arg5_defvalue = wxPyEmptyString ;
33661 wxString *arg5 = (wxString *) &arg5_defvalue ;
33662 wxMenuItem *result;
33663 bool temp3 = false ;
33664 bool temp5 = false ;
33665 PyObject * obj0 = 0 ;
33666 PyObject * obj1 = 0 ;
33667 PyObject * obj2 = 0 ;
33668 PyObject * obj3 = 0 ;
33669 PyObject * obj4 = 0 ;
33670 char *kwnames[] = {
33671 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33672 };
33673
33674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:wxMenu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33676 if (SWIG_arg_fail(1)) SWIG_fail;
33677 {
33678 arg2 = (int)(SWIG_As_int(obj1));
33679 if (SWIG_arg_fail(2)) SWIG_fail;
33680 }
33681 {
33682 arg3 = wxString_in_helper(obj2);
33683 if (arg3 == NULL) SWIG_fail;
33684 temp3 = true;
33685 }
33686 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33687 if (SWIG_arg_fail(4)) SWIG_fail;
33688 if (obj4) {
33689 {
33690 arg5 = wxString_in_helper(obj4);
33691 if (arg5 == NULL) SWIG_fail;
33692 temp5 = true;
33693 }
33694 }
33695 {
33696 PyThreadState* __tstate = wxPyBeginAllowThreads();
33697 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33698
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 {
33703 resultobj = wxPyMake_wxObject(result, 0);
33704 }
33705 {
33706 if (temp3)
33707 delete arg3;
33708 }
33709 {
33710 if (temp5)
33711 delete arg5;
33712 }
33713 return resultobj;
33714 fail:
33715 {
33716 if (temp3)
33717 delete arg3;
33718 }
33719 {
33720 if (temp5)
33721 delete arg5;
33722 }
33723 return NULL;
33724 }
33725
33726
33727 static PyObject *_wrap_wxMenu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33728 PyObject *resultobj;
33729 wxMenu *arg1 = (wxMenu *) 0 ;
33730 int arg2 ;
33731 wxMenuItem *result;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char *kwnames[] = {
33735 (char *) "self",(char *) "id", NULL
33736 };
33737
33738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_Remove",kwnames,&obj0,&obj1)) goto fail;
33739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33740 if (SWIG_arg_fail(1)) SWIG_fail;
33741 {
33742 arg2 = (int)(SWIG_As_int(obj1));
33743 if (SWIG_arg_fail(2)) SWIG_fail;
33744 }
33745 {
33746 PyThreadState* __tstate = wxPyBeginAllowThreads();
33747 result = (wxMenuItem *)(arg1)->Remove(arg2);
33748
33749 wxPyEndAllowThreads(__tstate);
33750 if (PyErr_Occurred()) SWIG_fail;
33751 }
33752 {
33753 resultobj = wxPyMake_wxObject(result, 0);
33754 }
33755 return resultobj;
33756 fail:
33757 return NULL;
33758 }
33759
33760
33761 static PyObject *_wrap_wxMenu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33762 PyObject *resultobj;
33763 wxMenu *arg1 = (wxMenu *) 0 ;
33764 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33765 wxMenuItem *result;
33766 PyObject * obj0 = 0 ;
33767 PyObject * obj1 = 0 ;
33768 char *kwnames[] = {
33769 (char *) "self",(char *) "item", NULL
33770 };
33771
33772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33774 if (SWIG_arg_fail(1)) SWIG_fail;
33775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33776 if (SWIG_arg_fail(2)) SWIG_fail;
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 result = (wxMenuItem *)(arg1)->Remove(arg2);
33780
33781 wxPyEndAllowThreads(__tstate);
33782 if (PyErr_Occurred()) SWIG_fail;
33783 }
33784 {
33785 resultobj = wxPyMake_wxObject(result, 0);
33786 }
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 static PyObject *_wrap_wxMenu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33794 PyObject *resultobj;
33795 wxMenu *arg1 = (wxMenu *) 0 ;
33796 int arg2 ;
33797 bool result;
33798 PyObject * obj0 = 0 ;
33799 PyObject * obj1 = 0 ;
33800 char *kwnames[] = {
33801 (char *) "self",(char *) "id", NULL
33802 };
33803
33804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_Delete",kwnames,&obj0,&obj1)) goto fail;
33805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33806 if (SWIG_arg_fail(1)) SWIG_fail;
33807 {
33808 arg2 = (int)(SWIG_As_int(obj1));
33809 if (SWIG_arg_fail(2)) SWIG_fail;
33810 }
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 result = (bool)(arg1)->Delete(arg2);
33814
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 {
33819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33820 }
33821 return resultobj;
33822 fail:
33823 return NULL;
33824 }
33825
33826
33827 static PyObject *_wrap_wxMenu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33828 PyObject *resultobj;
33829 wxMenu *arg1 = (wxMenu *) 0 ;
33830 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33831 bool result;
33832 PyObject * obj0 = 0 ;
33833 PyObject * obj1 = 0 ;
33834 char *kwnames[] = {
33835 (char *) "self",(char *) "item", NULL
33836 };
33837
33838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33840 if (SWIG_arg_fail(1)) SWIG_fail;
33841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33842 if (SWIG_arg_fail(2)) SWIG_fail;
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 result = (bool)(arg1)->Delete(arg2);
33846
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 {
33851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33852 }
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 static PyObject *_wrap_wxMenu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj;
33861 wxMenu *arg1 = (wxMenu *) 0 ;
33862 PyObject * obj0 = 0 ;
33863 char *kwnames[] = {
33864 (char *) "self", NULL
33865 };
33866
33867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_Destroy",kwnames,&obj0)) goto fail;
33868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33869 if (SWIG_arg_fail(1)) SWIG_fail;
33870 {
33871 PyThreadState* __tstate = wxPyBeginAllowThreads();
33872 wxMenu_Destroy(arg1);
33873
33874 wxPyEndAllowThreads(__tstate);
33875 if (PyErr_Occurred()) SWIG_fail;
33876 }
33877 Py_INCREF(Py_None); resultobj = Py_None;
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 static PyObject *_wrap_wxMenu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33885 PyObject *resultobj;
33886 wxMenu *arg1 = (wxMenu *) 0 ;
33887 int arg2 ;
33888 bool result;
33889 PyObject * obj0 = 0 ;
33890 PyObject * obj1 = 0 ;
33891 char *kwnames[] = {
33892 (char *) "self",(char *) "id", NULL
33893 };
33894
33895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(1)) SWIG_fail;
33898 {
33899 arg2 = (int)(SWIG_As_int(obj1));
33900 if (SWIG_arg_fail(2)) SWIG_fail;
33901 }
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 result = (bool)(arg1)->Destroy(arg2);
33905
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 {
33910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33911 }
33912 return resultobj;
33913 fail:
33914 return NULL;
33915 }
33916
33917
33918 static PyObject *_wrap_wxMenu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33919 PyObject *resultobj;
33920 wxMenu *arg1 = (wxMenu *) 0 ;
33921 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33922 bool result;
33923 PyObject * obj0 = 0 ;
33924 PyObject * obj1 = 0 ;
33925 char *kwnames[] = {
33926 (char *) "self",(char *) "item", NULL
33927 };
33928
33929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(1)) SWIG_fail;
33932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33933 if (SWIG_arg_fail(2)) SWIG_fail;
33934 {
33935 PyThreadState* __tstate = wxPyBeginAllowThreads();
33936 result = (bool)(arg1)->Destroy(arg2);
33937
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 {
33942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33943 }
33944 return resultobj;
33945 fail:
33946 return NULL;
33947 }
33948
33949
33950 static PyObject *_wrap_wxMenu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj;
33952 wxMenu *arg1 = (wxMenu *) 0 ;
33953 size_t result;
33954 PyObject * obj0 = 0 ;
33955 char *kwnames[] = {
33956 (char *) "self", NULL
33957 };
33958
33959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33961 if (SWIG_arg_fail(1)) SWIG_fail;
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33965
33966 wxPyEndAllowThreads(__tstate);
33967 if (PyErr_Occurred()) SWIG_fail;
33968 }
33969 {
33970 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33971 }
33972 return resultobj;
33973 fail:
33974 return NULL;
33975 }
33976
33977
33978 static PyObject *_wrap_wxMenu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33979 PyObject *resultobj;
33980 wxMenu *arg1 = (wxMenu *) 0 ;
33981 PyObject *result;
33982 PyObject * obj0 = 0 ;
33983 char *kwnames[] = {
33984 (char *) "self", NULL
33985 };
33986
33987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetMenuItems",kwnames,&obj0)) goto fail;
33988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33989 if (SWIG_arg_fail(1)) SWIG_fail;
33990 {
33991 PyThreadState* __tstate = wxPyBeginAllowThreads();
33992 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33993
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 resultobj = result;
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 static PyObject *_wrap_wxMenu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj;
34006 wxMenu *arg1 = (wxMenu *) 0 ;
34007 wxString *arg2 = 0 ;
34008 int result;
34009 bool temp2 = false ;
34010 PyObject * obj0 = 0 ;
34011 PyObject * obj1 = 0 ;
34012 char *kwnames[] = {
34013 (char *) "self",(char *) "item", NULL
34014 };
34015
34016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34018 if (SWIG_arg_fail(1)) SWIG_fail;
34019 {
34020 arg2 = wxString_in_helper(obj1);
34021 if (arg2 == NULL) SWIG_fail;
34022 temp2 = true;
34023 }
34024 {
34025 PyThreadState* __tstate = wxPyBeginAllowThreads();
34026 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34027
34028 wxPyEndAllowThreads(__tstate);
34029 if (PyErr_Occurred()) SWIG_fail;
34030 }
34031 {
34032 resultobj = SWIG_From_int((int)(result));
34033 }
34034 {
34035 if (temp2)
34036 delete arg2;
34037 }
34038 return resultobj;
34039 fail:
34040 {
34041 if (temp2)
34042 delete arg2;
34043 }
34044 return NULL;
34045 }
34046
34047
34048 static PyObject *_wrap_wxMenu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj;
34050 wxMenu *arg1 = (wxMenu *) 0 ;
34051 int arg2 ;
34052 wxMenuItem *result;
34053 PyObject * obj0 = 0 ;
34054 PyObject * obj1 = 0 ;
34055 char *kwnames[] = {
34056 (char *) "self",(char *) "id", NULL
34057 };
34058
34059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34061 if (SWIG_arg_fail(1)) SWIG_fail;
34062 {
34063 arg2 = (int)(SWIG_As_int(obj1));
34064 if (SWIG_arg_fail(2)) SWIG_fail;
34065 }
34066 {
34067 PyThreadState* __tstate = wxPyBeginAllowThreads();
34068 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34069
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 {
34074 resultobj = wxPyMake_wxObject(result, 0);
34075 }
34076 return resultobj;
34077 fail:
34078 return NULL;
34079 }
34080
34081
34082 static PyObject *_wrap_wxMenu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34083 PyObject *resultobj;
34084 wxMenu *arg1 = (wxMenu *) 0 ;
34085 size_t arg2 ;
34086 wxMenuItem *result;
34087 PyObject * obj0 = 0 ;
34088 PyObject * obj1 = 0 ;
34089 char *kwnames[] = {
34090 (char *) "self",(char *) "position", NULL
34091 };
34092
34093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34095 if (SWIG_arg_fail(1)) SWIG_fail;
34096 {
34097 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34098 if (SWIG_arg_fail(2)) SWIG_fail;
34099 }
34100 {
34101 PyThreadState* __tstate = wxPyBeginAllowThreads();
34102 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34103
34104 wxPyEndAllowThreads(__tstate);
34105 if (PyErr_Occurred()) SWIG_fail;
34106 }
34107 {
34108 resultobj = wxPyMake_wxObject(result, 0);
34109 }
34110 return resultobj;
34111 fail:
34112 return NULL;
34113 }
34114
34115
34116 static PyObject *_wrap_wxMenu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34117 PyObject *resultobj;
34118 wxMenu *arg1 = (wxMenu *) 0 ;
34119 int arg2 ;
34120 bool arg3 ;
34121 PyObject * obj0 = 0 ;
34122 PyObject * obj1 = 0 ;
34123 PyObject * obj2 = 0 ;
34124 char *kwnames[] = {
34125 (char *) "self",(char *) "id",(char *) "enable", NULL
34126 };
34127
34128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34130 if (SWIG_arg_fail(1)) SWIG_fail;
34131 {
34132 arg2 = (int)(SWIG_As_int(obj1));
34133 if (SWIG_arg_fail(2)) SWIG_fail;
34134 }
34135 {
34136 arg3 = (bool)(SWIG_As_bool(obj2));
34137 if (SWIG_arg_fail(3)) SWIG_fail;
34138 }
34139 {
34140 PyThreadState* __tstate = wxPyBeginAllowThreads();
34141 (arg1)->Enable(arg2,arg3);
34142
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 Py_INCREF(Py_None); resultobj = Py_None;
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 static PyObject *_wrap_wxMenu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj;
34155 wxMenu *arg1 = (wxMenu *) 0 ;
34156 int arg2 ;
34157 bool result;
34158 PyObject * obj0 = 0 ;
34159 PyObject * obj1 = 0 ;
34160 char *kwnames[] = {
34161 (char *) "self",(char *) "id", NULL
34162 };
34163
34164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34166 if (SWIG_arg_fail(1)) SWIG_fail;
34167 {
34168 arg2 = (int)(SWIG_As_int(obj1));
34169 if (SWIG_arg_fail(2)) SWIG_fail;
34170 }
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34174
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 {
34179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34180 }
34181 return resultobj;
34182 fail:
34183 return NULL;
34184 }
34185
34186
34187 static PyObject *_wrap_wxMenu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34188 PyObject *resultobj;
34189 wxMenu *arg1 = (wxMenu *) 0 ;
34190 int arg2 ;
34191 bool arg3 ;
34192 PyObject * obj0 = 0 ;
34193 PyObject * obj1 = 0 ;
34194 PyObject * obj2 = 0 ;
34195 char *kwnames[] = {
34196 (char *) "self",(char *) "id",(char *) "check", NULL
34197 };
34198
34199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34201 if (SWIG_arg_fail(1)) SWIG_fail;
34202 {
34203 arg2 = (int)(SWIG_As_int(obj1));
34204 if (SWIG_arg_fail(2)) SWIG_fail;
34205 }
34206 {
34207 arg3 = (bool)(SWIG_As_bool(obj2));
34208 if (SWIG_arg_fail(3)) SWIG_fail;
34209 }
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 (arg1)->Check(arg2,arg3);
34213
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 Py_INCREF(Py_None); resultobj = Py_None;
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 static PyObject *_wrap_wxMenu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34225 PyObject *resultobj;
34226 wxMenu *arg1 = (wxMenu *) 0 ;
34227 int arg2 ;
34228 bool result;
34229 PyObject * obj0 = 0 ;
34230 PyObject * obj1 = 0 ;
34231 char *kwnames[] = {
34232 (char *) "self",(char *) "id", NULL
34233 };
34234
34235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34237 if (SWIG_arg_fail(1)) SWIG_fail;
34238 {
34239 arg2 = (int)(SWIG_As_int(obj1));
34240 if (SWIG_arg_fail(2)) SWIG_fail;
34241 }
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34245
34246 wxPyEndAllowThreads(__tstate);
34247 if (PyErr_Occurred()) SWIG_fail;
34248 }
34249 {
34250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34251 }
34252 return resultobj;
34253 fail:
34254 return NULL;
34255 }
34256
34257
34258 static PyObject *_wrap_wxMenu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34259 PyObject *resultobj;
34260 wxMenu *arg1 = (wxMenu *) 0 ;
34261 int arg2 ;
34262 wxString *arg3 = 0 ;
34263 bool temp3 = false ;
34264 PyObject * obj0 = 0 ;
34265 PyObject * obj1 = 0 ;
34266 PyObject * obj2 = 0 ;
34267 char *kwnames[] = {
34268 (char *) "self",(char *) "id",(char *) "label", NULL
34269 };
34270
34271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34273 if (SWIG_arg_fail(1)) SWIG_fail;
34274 {
34275 arg2 = (int)(SWIG_As_int(obj1));
34276 if (SWIG_arg_fail(2)) SWIG_fail;
34277 }
34278 {
34279 arg3 = wxString_in_helper(obj2);
34280 if (arg3 == NULL) SWIG_fail;
34281 temp3 = true;
34282 }
34283 {
34284 PyThreadState* __tstate = wxPyBeginAllowThreads();
34285 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34286
34287 wxPyEndAllowThreads(__tstate);
34288 if (PyErr_Occurred()) SWIG_fail;
34289 }
34290 Py_INCREF(Py_None); resultobj = Py_None;
34291 {
34292 if (temp3)
34293 delete arg3;
34294 }
34295 return resultobj;
34296 fail:
34297 {
34298 if (temp3)
34299 delete arg3;
34300 }
34301 return NULL;
34302 }
34303
34304
34305 static PyObject *_wrap_wxMenu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34306 PyObject *resultobj;
34307 wxMenu *arg1 = (wxMenu *) 0 ;
34308 int arg2 ;
34309 wxString result;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 char *kwnames[] = {
34313 (char *) "self",(char *) "id", NULL
34314 };
34315
34316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34318 if (SWIG_arg_fail(1)) SWIG_fail;
34319 {
34320 arg2 = (int)(SWIG_As_int(obj1));
34321 if (SWIG_arg_fail(2)) SWIG_fail;
34322 }
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34326
34327 wxPyEndAllowThreads(__tstate);
34328 if (PyErr_Occurred()) SWIG_fail;
34329 }
34330 {
34331 #if wxUSE_UNICODE
34332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34333 #else
34334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34335 #endif
34336 }
34337 return resultobj;
34338 fail:
34339 return NULL;
34340 }
34341
34342
34343 static PyObject *_wrap_wxMenu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34344 PyObject *resultobj;
34345 wxMenu *arg1 = (wxMenu *) 0 ;
34346 int arg2 ;
34347 wxString *arg3 = 0 ;
34348 bool temp3 = false ;
34349 PyObject * obj0 = 0 ;
34350 PyObject * obj1 = 0 ;
34351 PyObject * obj2 = 0 ;
34352 char *kwnames[] = {
34353 (char *) "self",(char *) "id",(char *) "helpString", NULL
34354 };
34355
34356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34358 if (SWIG_arg_fail(1)) SWIG_fail;
34359 {
34360 arg2 = (int)(SWIG_As_int(obj1));
34361 if (SWIG_arg_fail(2)) SWIG_fail;
34362 }
34363 {
34364 arg3 = wxString_in_helper(obj2);
34365 if (arg3 == NULL) SWIG_fail;
34366 temp3 = true;
34367 }
34368 {
34369 PyThreadState* __tstate = wxPyBeginAllowThreads();
34370 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34371
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 Py_INCREF(Py_None); resultobj = Py_None;
34376 {
34377 if (temp3)
34378 delete arg3;
34379 }
34380 return resultobj;
34381 fail:
34382 {
34383 if (temp3)
34384 delete arg3;
34385 }
34386 return NULL;
34387 }
34388
34389
34390 static PyObject *_wrap_wxMenu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34391 PyObject *resultobj;
34392 wxMenu *arg1 = (wxMenu *) 0 ;
34393 int arg2 ;
34394 wxString result;
34395 PyObject * obj0 = 0 ;
34396 PyObject * obj1 = 0 ;
34397 char *kwnames[] = {
34398 (char *) "self",(char *) "id", NULL
34399 };
34400
34401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34403 if (SWIG_arg_fail(1)) SWIG_fail;
34404 {
34405 arg2 = (int)(SWIG_As_int(obj1));
34406 if (SWIG_arg_fail(2)) SWIG_fail;
34407 }
34408 {
34409 PyThreadState* __tstate = wxPyBeginAllowThreads();
34410 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34411
34412 wxPyEndAllowThreads(__tstate);
34413 if (PyErr_Occurred()) SWIG_fail;
34414 }
34415 {
34416 #if wxUSE_UNICODE
34417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34418 #else
34419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34420 #endif
34421 }
34422 return resultobj;
34423 fail:
34424 return NULL;
34425 }
34426
34427
34428 static PyObject *_wrap_wxMenu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34429 PyObject *resultobj;
34430 wxMenu *arg1 = (wxMenu *) 0 ;
34431 wxString *arg2 = 0 ;
34432 bool temp2 = false ;
34433 PyObject * obj0 = 0 ;
34434 PyObject * obj1 = 0 ;
34435 char *kwnames[] = {
34436 (char *) "self",(char *) "title", NULL
34437 };
34438
34439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34441 if (SWIG_arg_fail(1)) SWIG_fail;
34442 {
34443 arg2 = wxString_in_helper(obj1);
34444 if (arg2 == NULL) SWIG_fail;
34445 temp2 = true;
34446 }
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 (arg1)->SetTitle((wxString const &)*arg2);
34450
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 Py_INCREF(Py_None); resultobj = Py_None;
34455 {
34456 if (temp2)
34457 delete arg2;
34458 }
34459 return resultobj;
34460 fail:
34461 {
34462 if (temp2)
34463 delete arg2;
34464 }
34465 return NULL;
34466 }
34467
34468
34469 static PyObject *_wrap_wxMenu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34470 PyObject *resultobj;
34471 wxMenu *arg1 = (wxMenu *) 0 ;
34472 wxString result;
34473 PyObject * obj0 = 0 ;
34474 char *kwnames[] = {
34475 (char *) "self", NULL
34476 };
34477
34478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetTitle",kwnames,&obj0)) goto fail;
34479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34480 if (SWIG_arg_fail(1)) SWIG_fail;
34481 {
34482 PyThreadState* __tstate = wxPyBeginAllowThreads();
34483 result = ((wxMenu const *)arg1)->GetTitle();
34484
34485 wxPyEndAllowThreads(__tstate);
34486 if (PyErr_Occurred()) SWIG_fail;
34487 }
34488 {
34489 #if wxUSE_UNICODE
34490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34491 #else
34492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34493 #endif
34494 }
34495 return resultobj;
34496 fail:
34497 return NULL;
34498 }
34499
34500
34501 static PyObject *_wrap_wxMenu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34502 PyObject *resultobj;
34503 wxMenu *arg1 = (wxMenu *) 0 ;
34504 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34505 PyObject * obj0 = 0 ;
34506 PyObject * obj1 = 0 ;
34507 char *kwnames[] = {
34508 (char *) "self",(char *) "handler", NULL
34509 };
34510
34511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34513 if (SWIG_arg_fail(1)) SWIG_fail;
34514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34515 if (SWIG_arg_fail(2)) SWIG_fail;
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 (arg1)->SetEventHandler(arg2);
34519
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 Py_INCREF(Py_None); resultobj = Py_None;
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 static PyObject *_wrap_wxMenu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34531 PyObject *resultobj;
34532 wxMenu *arg1 = (wxMenu *) 0 ;
34533 wxEvtHandler *result;
34534 PyObject * obj0 = 0 ;
34535 char *kwnames[] = {
34536 (char *) "self", NULL
34537 };
34538
34539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetEventHandler",kwnames,&obj0)) goto fail;
34540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34541 if (SWIG_arg_fail(1)) SWIG_fail;
34542 {
34543 PyThreadState* __tstate = wxPyBeginAllowThreads();
34544 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34545
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 {
34550 resultobj = wxPyMake_wxObject(result, 0);
34551 }
34552 return resultobj;
34553 fail:
34554 return NULL;
34555 }
34556
34557
34558 static PyObject *_wrap_wxMenu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj;
34560 wxMenu *arg1 = (wxMenu *) 0 ;
34561 wxWindow *arg2 = (wxWindow *) 0 ;
34562 PyObject * obj0 = 0 ;
34563 PyObject * obj1 = 0 ;
34564 char *kwnames[] = {
34565 (char *) "self",(char *) "win", NULL
34566 };
34567
34568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34570 if (SWIG_arg_fail(1)) SWIG_fail;
34571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34572 if (SWIG_arg_fail(2)) SWIG_fail;
34573 {
34574 PyThreadState* __tstate = wxPyBeginAllowThreads();
34575 (arg1)->SetInvokingWindow(arg2);
34576
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 Py_INCREF(Py_None); resultobj = Py_None;
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 static PyObject *_wrap_wxMenu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34588 PyObject *resultobj;
34589 wxMenu *arg1 = (wxMenu *) 0 ;
34590 wxWindow *result;
34591 PyObject * obj0 = 0 ;
34592 char *kwnames[] = {
34593 (char *) "self", NULL
34594 };
34595
34596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34598 if (SWIG_arg_fail(1)) SWIG_fail;
34599 {
34600 PyThreadState* __tstate = wxPyBeginAllowThreads();
34601 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34602
34603 wxPyEndAllowThreads(__tstate);
34604 if (PyErr_Occurred()) SWIG_fail;
34605 }
34606 {
34607 resultobj = wxPyMake_wxObject(result, 0);
34608 }
34609 return resultobj;
34610 fail:
34611 return NULL;
34612 }
34613
34614
34615 static PyObject *_wrap_wxMenu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34616 PyObject *resultobj;
34617 wxMenu *arg1 = (wxMenu *) 0 ;
34618 long result;
34619 PyObject * obj0 = 0 ;
34620 char *kwnames[] = {
34621 (char *) "self", NULL
34622 };
34623
34624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetStyle",kwnames,&obj0)) goto fail;
34625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34626 if (SWIG_arg_fail(1)) SWIG_fail;
34627 {
34628 PyThreadState* __tstate = wxPyBeginAllowThreads();
34629 result = (long)((wxMenu const *)arg1)->GetStyle();
34630
34631 wxPyEndAllowThreads(__tstate);
34632 if (PyErr_Occurred()) SWIG_fail;
34633 }
34634 {
34635 resultobj = SWIG_From_long((long)(result));
34636 }
34637 return resultobj;
34638 fail:
34639 return NULL;
34640 }
34641
34642
34643 static PyObject *_wrap_wxMenu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34644 PyObject *resultobj;
34645 wxMenu *arg1 = (wxMenu *) 0 ;
34646 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34647 PyObject * obj0 = 0 ;
34648 PyObject * obj1 = 0 ;
34649 char *kwnames[] = {
34650 (char *) "self",(char *) "source", NULL
34651 };
34652
34653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMenu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34655 if (SWIG_arg_fail(1)) SWIG_fail;
34656 if (obj1) {
34657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34658 if (SWIG_arg_fail(2)) SWIG_fail;
34659 }
34660 {
34661 PyThreadState* __tstate = wxPyBeginAllowThreads();
34662 (arg1)->UpdateUI(arg2);
34663
34664 wxPyEndAllowThreads(__tstate);
34665 if (PyErr_Occurred()) SWIG_fail;
34666 }
34667 Py_INCREF(Py_None); resultobj = Py_None;
34668 return resultobj;
34669 fail:
34670 return NULL;
34671 }
34672
34673
34674 static PyObject *_wrap_wxMenu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34675 PyObject *resultobj;
34676 wxMenu *arg1 = (wxMenu *) 0 ;
34677 wxMenuBar *result;
34678 PyObject * obj0 = 0 ;
34679 char *kwnames[] = {
34680 (char *) "self", NULL
34681 };
34682
34683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetMenuBar",kwnames,&obj0)) goto fail;
34684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34685 if (SWIG_arg_fail(1)) SWIG_fail;
34686 {
34687 PyThreadState* __tstate = wxPyBeginAllowThreads();
34688 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34689
34690 wxPyEndAllowThreads(__tstate);
34691 if (PyErr_Occurred()) SWIG_fail;
34692 }
34693 {
34694 resultobj = wxPyMake_wxObject(result, 0);
34695 }
34696 return resultobj;
34697 fail:
34698 return NULL;
34699 }
34700
34701
34702 static PyObject *_wrap_wxMenu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34703 PyObject *resultobj;
34704 wxMenu *arg1 = (wxMenu *) 0 ;
34705 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34706 PyObject * obj0 = 0 ;
34707 PyObject * obj1 = 0 ;
34708 char *kwnames[] = {
34709 (char *) "self",(char *) "menubar", NULL
34710 };
34711
34712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_Attach",kwnames,&obj0,&obj1)) goto fail;
34713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34714 if (SWIG_arg_fail(1)) SWIG_fail;
34715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34716 if (SWIG_arg_fail(2)) SWIG_fail;
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->Attach(arg2);
34720
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 Py_INCREF(Py_None); resultobj = Py_None;
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 static PyObject *_wrap_wxMenu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34732 PyObject *resultobj;
34733 wxMenu *arg1 = (wxMenu *) 0 ;
34734 PyObject * obj0 = 0 ;
34735 char *kwnames[] = {
34736 (char *) "self", NULL
34737 };
34738
34739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_Detach",kwnames,&obj0)) goto fail;
34740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34741 if (SWIG_arg_fail(1)) SWIG_fail;
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 (arg1)->Detach();
34745
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 Py_INCREF(Py_None); resultobj = Py_None;
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 static PyObject *_wrap_wxMenu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34757 PyObject *resultobj;
34758 wxMenu *arg1 = (wxMenu *) 0 ;
34759 bool result;
34760 PyObject * obj0 = 0 ;
34761 char *kwnames[] = {
34762 (char *) "self", NULL
34763 };
34764
34765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_IsAttached",kwnames,&obj0)) goto fail;
34766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34767 if (SWIG_arg_fail(1)) SWIG_fail;
34768 {
34769 PyThreadState* __tstate = wxPyBeginAllowThreads();
34770 result = (bool)((wxMenu const *)arg1)->IsAttached();
34771
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 static PyObject *_wrap_wxMenu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34785 PyObject *resultobj;
34786 wxMenu *arg1 = (wxMenu *) 0 ;
34787 wxMenu *arg2 = (wxMenu *) 0 ;
34788 PyObject * obj0 = 0 ;
34789 PyObject * obj1 = 0 ;
34790 char *kwnames[] = {
34791 (char *) "self",(char *) "parent", NULL
34792 };
34793
34794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34796 if (SWIG_arg_fail(1)) SWIG_fail;
34797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34798 if (SWIG_arg_fail(2)) SWIG_fail;
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 (arg1)->SetParent(arg2);
34802
34803 wxPyEndAllowThreads(__tstate);
34804 if (PyErr_Occurred()) SWIG_fail;
34805 }
34806 Py_INCREF(Py_None); resultobj = Py_None;
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 static PyObject *_wrap_wxMenu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34814 PyObject *resultobj;
34815 wxMenu *arg1 = (wxMenu *) 0 ;
34816 wxMenu *result;
34817 PyObject * obj0 = 0 ;
34818 char *kwnames[] = {
34819 (char *) "self", NULL
34820 };
34821
34822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenu_GetParent",kwnames,&obj0)) goto fail;
34823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34824 if (SWIG_arg_fail(1)) SWIG_fail;
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34828
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 {
34833 resultobj = wxPyMake_wxObject(result, 0);
34834 }
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 static PyObject * wxMenu_swigregister(PyObject *, PyObject *args) {
34842 PyObject *obj;
34843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34844 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34845 Py_INCREF(obj);
34846 return Py_BuildValue((char *)"");
34847 }
34848 static PyObject *_wrap_new_wxMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj;
34850 long arg1 = (long) 0 ;
34851 wxMenuBar *result;
34852 PyObject * obj0 = 0 ;
34853 char *kwnames[] = {
34854 (char *) "style", NULL
34855 };
34856
34857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxMenuBar",kwnames,&obj0)) goto fail;
34858 if (obj0) {
34859 {
34860 arg1 = (long)(SWIG_As_long(obj0));
34861 if (SWIG_arg_fail(1)) SWIG_fail;
34862 }
34863 }
34864 {
34865 if (!wxPyCheckForApp()) SWIG_fail;
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = (wxMenuBar *)new wxMenuBar(arg1);
34868
34869 wxPyEndAllowThreads(__tstate);
34870 if (PyErr_Occurred()) SWIG_fail;
34871 }
34872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 static PyObject *_wrap_wxMenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34880 PyObject *resultobj;
34881 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34882 wxMenu *arg2 = (wxMenu *) 0 ;
34883 wxString *arg3 = 0 ;
34884 bool result;
34885 bool temp3 = false ;
34886 PyObject * obj0 = 0 ;
34887 PyObject * obj1 = 0 ;
34888 PyObject * obj2 = 0 ;
34889 char *kwnames[] = {
34890 (char *) "self",(char *) "menu",(char *) "title", NULL
34891 };
34892
34893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34895 if (SWIG_arg_fail(1)) SWIG_fail;
34896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34897 if (SWIG_arg_fail(2)) SWIG_fail;
34898 {
34899 arg3 = wxString_in_helper(obj2);
34900 if (arg3 == NULL) SWIG_fail;
34901 temp3 = true;
34902 }
34903 {
34904 PyThreadState* __tstate = wxPyBeginAllowThreads();
34905 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34906
34907 wxPyEndAllowThreads(__tstate);
34908 if (PyErr_Occurred()) SWIG_fail;
34909 }
34910 {
34911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34912 }
34913 {
34914 if (temp3)
34915 delete arg3;
34916 }
34917 return resultobj;
34918 fail:
34919 {
34920 if (temp3)
34921 delete arg3;
34922 }
34923 return NULL;
34924 }
34925
34926
34927 static PyObject *_wrap_wxMenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34928 PyObject *resultobj;
34929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34930 size_t arg2 ;
34931 wxMenu *arg3 = (wxMenu *) 0 ;
34932 wxString *arg4 = 0 ;
34933 bool result;
34934 bool temp4 = false ;
34935 PyObject * obj0 = 0 ;
34936 PyObject * obj1 = 0 ;
34937 PyObject * obj2 = 0 ;
34938 PyObject * obj3 = 0 ;
34939 char *kwnames[] = {
34940 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34941 };
34942
34943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxMenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34945 if (SWIG_arg_fail(1)) SWIG_fail;
34946 {
34947 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34948 if (SWIG_arg_fail(2)) SWIG_fail;
34949 }
34950 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34951 if (SWIG_arg_fail(3)) SWIG_fail;
34952 {
34953 arg4 = wxString_in_helper(obj3);
34954 if (arg4 == NULL) SWIG_fail;
34955 temp4 = true;
34956 }
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34960
34961 wxPyEndAllowThreads(__tstate);
34962 if (PyErr_Occurred()) SWIG_fail;
34963 }
34964 {
34965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34966 }
34967 {
34968 if (temp4)
34969 delete arg4;
34970 }
34971 return resultobj;
34972 fail:
34973 {
34974 if (temp4)
34975 delete arg4;
34976 }
34977 return NULL;
34978 }
34979
34980
34981 static PyObject *_wrap_wxMenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34982 PyObject *resultobj;
34983 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34984 size_t result;
34985 PyObject * obj0 = 0 ;
34986 char *kwnames[] = {
34987 (char *) "self", NULL
34988 };
34989
34990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34992 if (SWIG_arg_fail(1)) SWIG_fail;
34993 {
34994 PyThreadState* __tstate = wxPyBeginAllowThreads();
34995 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34996
34997 wxPyEndAllowThreads(__tstate);
34998 if (PyErr_Occurred()) SWIG_fail;
34999 }
35000 {
35001 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35002 }
35003 return resultobj;
35004 fail:
35005 return NULL;
35006 }
35007
35008
35009 static PyObject *_wrap_wxMenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35010 PyObject *resultobj;
35011 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35012 size_t arg2 ;
35013 wxMenu *result;
35014 PyObject * obj0 = 0 ;
35015 PyObject * obj1 = 0 ;
35016 char *kwnames[] = {
35017 (char *) "self",(char *) "pos", NULL
35018 };
35019
35020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35022 if (SWIG_arg_fail(1)) SWIG_fail;
35023 {
35024 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35025 if (SWIG_arg_fail(2)) SWIG_fail;
35026 }
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35030
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 {
35035 resultobj = wxPyMake_wxObject(result, 0);
35036 }
35037 return resultobj;
35038 fail:
35039 return NULL;
35040 }
35041
35042
35043 static PyObject *_wrap_wxMenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35044 PyObject *resultobj;
35045 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35046 size_t arg2 ;
35047 wxMenu *arg3 = (wxMenu *) 0 ;
35048 wxString *arg4 = 0 ;
35049 wxMenu *result;
35050 bool temp4 = false ;
35051 PyObject * obj0 = 0 ;
35052 PyObject * obj1 = 0 ;
35053 PyObject * obj2 = 0 ;
35054 PyObject * obj3 = 0 ;
35055 char *kwnames[] = {
35056 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35057 };
35058
35059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxMenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35061 if (SWIG_arg_fail(1)) SWIG_fail;
35062 {
35063 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35064 if (SWIG_arg_fail(2)) SWIG_fail;
35065 }
35066 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35067 if (SWIG_arg_fail(3)) SWIG_fail;
35068 {
35069 arg4 = wxString_in_helper(obj3);
35070 if (arg4 == NULL) SWIG_fail;
35071 temp4 = true;
35072 }
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35076
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 {
35081 resultobj = wxPyMake_wxObject(result, 0);
35082 }
35083 {
35084 if (temp4)
35085 delete arg4;
35086 }
35087 return resultobj;
35088 fail:
35089 {
35090 if (temp4)
35091 delete arg4;
35092 }
35093 return NULL;
35094 }
35095
35096
35097 static PyObject *_wrap_wxMenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35098 PyObject *resultobj;
35099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35100 size_t arg2 ;
35101 wxMenu *result;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 char *kwnames[] = {
35105 (char *) "self",(char *) "pos", NULL
35106 };
35107
35108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35110 if (SWIG_arg_fail(1)) SWIG_fail;
35111 {
35112 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35113 if (SWIG_arg_fail(2)) SWIG_fail;
35114 }
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (wxMenu *)(arg1)->Remove(arg2);
35118
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 {
35123 resultobj = wxPyMake_wxObject(result, 0);
35124 }
35125 return resultobj;
35126 fail:
35127 return NULL;
35128 }
35129
35130
35131 static PyObject *_wrap_wxMenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35132 PyObject *resultobj;
35133 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35134 size_t arg2 ;
35135 bool arg3 ;
35136 PyObject * obj0 = 0 ;
35137 PyObject * obj1 = 0 ;
35138 PyObject * obj2 = 0 ;
35139 char *kwnames[] = {
35140 (char *) "self",(char *) "pos",(char *) "enable", NULL
35141 };
35142
35143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35145 if (SWIG_arg_fail(1)) SWIG_fail;
35146 {
35147 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35148 if (SWIG_arg_fail(2)) SWIG_fail;
35149 }
35150 {
35151 arg3 = (bool)(SWIG_As_bool(obj2));
35152 if (SWIG_arg_fail(3)) SWIG_fail;
35153 }
35154 {
35155 PyThreadState* __tstate = wxPyBeginAllowThreads();
35156 (arg1)->EnableTop(arg2,arg3);
35157
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 Py_INCREF(Py_None); resultobj = Py_None;
35162 return resultobj;
35163 fail:
35164 return NULL;
35165 }
35166
35167
35168 static PyObject *_wrap_wxMenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35169 PyObject *resultobj;
35170 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35171 size_t arg2 ;
35172 bool result;
35173 PyObject * obj0 = 0 ;
35174 PyObject * obj1 = 0 ;
35175 char *kwnames[] = {
35176 (char *) "self",(char *) "pos", NULL
35177 };
35178
35179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35181 if (SWIG_arg_fail(1)) SWIG_fail;
35182 {
35183 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35184 if (SWIG_arg_fail(2)) SWIG_fail;
35185 }
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35189
35190 wxPyEndAllowThreads(__tstate);
35191 if (PyErr_Occurred()) SWIG_fail;
35192 }
35193 {
35194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35195 }
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 static PyObject *_wrap_wxMenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj;
35204 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35205 size_t arg2 ;
35206 wxString *arg3 = 0 ;
35207 bool temp3 = false ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 PyObject * obj2 = 0 ;
35211 char *kwnames[] = {
35212 (char *) "self",(char *) "pos",(char *) "label", NULL
35213 };
35214
35215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35217 if (SWIG_arg_fail(1)) SWIG_fail;
35218 {
35219 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35220 if (SWIG_arg_fail(2)) SWIG_fail;
35221 }
35222 {
35223 arg3 = wxString_in_helper(obj2);
35224 if (arg3 == NULL) SWIG_fail;
35225 temp3 = true;
35226 }
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35230
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 Py_INCREF(Py_None); resultobj = Py_None;
35235 {
35236 if (temp3)
35237 delete arg3;
35238 }
35239 return resultobj;
35240 fail:
35241 {
35242 if (temp3)
35243 delete arg3;
35244 }
35245 return NULL;
35246 }
35247
35248
35249 static PyObject *_wrap_wxMenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35250 PyObject *resultobj;
35251 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35252 size_t arg2 ;
35253 wxString result;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 char *kwnames[] = {
35257 (char *) "self",(char *) "pos", NULL
35258 };
35259
35260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35262 if (SWIG_arg_fail(1)) SWIG_fail;
35263 {
35264 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35265 if (SWIG_arg_fail(2)) SWIG_fail;
35266 }
35267 {
35268 PyThreadState* __tstate = wxPyBeginAllowThreads();
35269 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35270
35271 wxPyEndAllowThreads(__tstate);
35272 if (PyErr_Occurred()) SWIG_fail;
35273 }
35274 {
35275 #if wxUSE_UNICODE
35276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35277 #else
35278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35279 #endif
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 static PyObject *_wrap_wxMenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj;
35289 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35290 wxString *arg2 = 0 ;
35291 wxString *arg3 = 0 ;
35292 int result;
35293 bool temp2 = false ;
35294 bool temp3 = false ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 PyObject * obj2 = 0 ;
35298 char *kwnames[] = {
35299 (char *) "self",(char *) "menu",(char *) "item", NULL
35300 };
35301
35302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35304 if (SWIG_arg_fail(1)) SWIG_fail;
35305 {
35306 arg2 = wxString_in_helper(obj1);
35307 if (arg2 == NULL) SWIG_fail;
35308 temp2 = true;
35309 }
35310 {
35311 arg3 = wxString_in_helper(obj2);
35312 if (arg3 == NULL) SWIG_fail;
35313 temp3 = true;
35314 }
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35318
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 {
35323 resultobj = SWIG_From_int((int)(result));
35324 }
35325 {
35326 if (temp2)
35327 delete arg2;
35328 }
35329 {
35330 if (temp3)
35331 delete arg3;
35332 }
35333 return resultobj;
35334 fail:
35335 {
35336 if (temp2)
35337 delete arg2;
35338 }
35339 {
35340 if (temp3)
35341 delete arg3;
35342 }
35343 return NULL;
35344 }
35345
35346
35347 static PyObject *_wrap_wxMenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35348 PyObject *resultobj;
35349 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35350 int arg2 ;
35351 wxMenuItem *result;
35352 PyObject * obj0 = 0 ;
35353 PyObject * obj1 = 0 ;
35354 char *kwnames[] = {
35355 (char *) "self",(char *) "id", NULL
35356 };
35357
35358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35360 if (SWIG_arg_fail(1)) SWIG_fail;
35361 {
35362 arg2 = (int)(SWIG_As_int(obj1));
35363 if (SWIG_arg_fail(2)) SWIG_fail;
35364 }
35365 {
35366 PyThreadState* __tstate = wxPyBeginAllowThreads();
35367 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35368
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 {
35373 resultobj = wxPyMake_wxObject(result, 0);
35374 }
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 static PyObject *_wrap_wxMenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35382 PyObject *resultobj;
35383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35384 wxString *arg2 = 0 ;
35385 int result;
35386 bool temp2 = false ;
35387 PyObject * obj0 = 0 ;
35388 PyObject * obj1 = 0 ;
35389 char *kwnames[] = {
35390 (char *) "self",(char *) "title", NULL
35391 };
35392
35393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35395 if (SWIG_arg_fail(1)) SWIG_fail;
35396 {
35397 arg2 = wxString_in_helper(obj1);
35398 if (arg2 == NULL) SWIG_fail;
35399 temp2 = true;
35400 }
35401 {
35402 PyThreadState* __tstate = wxPyBeginAllowThreads();
35403 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35404
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 {
35409 resultobj = SWIG_From_int((int)(result));
35410 }
35411 {
35412 if (temp2)
35413 delete arg2;
35414 }
35415 return resultobj;
35416 fail:
35417 {
35418 if (temp2)
35419 delete arg2;
35420 }
35421 return NULL;
35422 }
35423
35424
35425 static PyObject *_wrap_wxMenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35426 PyObject *resultobj;
35427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35428 int arg2 ;
35429 bool arg3 ;
35430 PyObject * obj0 = 0 ;
35431 PyObject * obj1 = 0 ;
35432 PyObject * obj2 = 0 ;
35433 char *kwnames[] = {
35434 (char *) "self",(char *) "id",(char *) "enable", NULL
35435 };
35436
35437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35439 if (SWIG_arg_fail(1)) SWIG_fail;
35440 {
35441 arg2 = (int)(SWIG_As_int(obj1));
35442 if (SWIG_arg_fail(2)) SWIG_fail;
35443 }
35444 {
35445 arg3 = (bool)(SWIG_As_bool(obj2));
35446 if (SWIG_arg_fail(3)) SWIG_fail;
35447 }
35448 {
35449 PyThreadState* __tstate = wxPyBeginAllowThreads();
35450 (arg1)->Enable(arg2,arg3);
35451
35452 wxPyEndAllowThreads(__tstate);
35453 if (PyErr_Occurred()) SWIG_fail;
35454 }
35455 Py_INCREF(Py_None); resultobj = Py_None;
35456 return resultobj;
35457 fail:
35458 return NULL;
35459 }
35460
35461
35462 static PyObject *_wrap_wxMenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35463 PyObject *resultobj;
35464 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35465 int arg2 ;
35466 bool arg3 ;
35467 PyObject * obj0 = 0 ;
35468 PyObject * obj1 = 0 ;
35469 PyObject * obj2 = 0 ;
35470 char *kwnames[] = {
35471 (char *) "self",(char *) "id",(char *) "check", NULL
35472 };
35473
35474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35476 if (SWIG_arg_fail(1)) SWIG_fail;
35477 {
35478 arg2 = (int)(SWIG_As_int(obj1));
35479 if (SWIG_arg_fail(2)) SWIG_fail;
35480 }
35481 {
35482 arg3 = (bool)(SWIG_As_bool(obj2));
35483 if (SWIG_arg_fail(3)) SWIG_fail;
35484 }
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 (arg1)->Check(arg2,arg3);
35488
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 Py_INCREF(Py_None); resultobj = Py_None;
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 static PyObject *_wrap_wxMenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35500 PyObject *resultobj;
35501 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35502 int arg2 ;
35503 bool result;
35504 PyObject * obj0 = 0 ;
35505 PyObject * obj1 = 0 ;
35506 char *kwnames[] = {
35507 (char *) "self",(char *) "id", NULL
35508 };
35509
35510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35512 if (SWIG_arg_fail(1)) SWIG_fail;
35513 {
35514 arg2 = (int)(SWIG_As_int(obj1));
35515 if (SWIG_arg_fail(2)) SWIG_fail;
35516 }
35517 {
35518 PyThreadState* __tstate = wxPyBeginAllowThreads();
35519 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35520
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 {
35525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35526 }
35527 return resultobj;
35528 fail:
35529 return NULL;
35530 }
35531
35532
35533 static PyObject *_wrap_wxMenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35534 PyObject *resultobj;
35535 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35536 int arg2 ;
35537 bool result;
35538 PyObject * obj0 = 0 ;
35539 PyObject * obj1 = 0 ;
35540 char *kwnames[] = {
35541 (char *) "self",(char *) "id", NULL
35542 };
35543
35544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35546 if (SWIG_arg_fail(1)) SWIG_fail;
35547 {
35548 arg2 = (int)(SWIG_As_int(obj1));
35549 if (SWIG_arg_fail(2)) SWIG_fail;
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35554
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 {
35559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35560 }
35561 return resultobj;
35562 fail:
35563 return NULL;
35564 }
35565
35566
35567 static PyObject *_wrap_wxMenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35568 PyObject *resultobj;
35569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35570 int arg2 ;
35571 wxString *arg3 = 0 ;
35572 bool temp3 = false ;
35573 PyObject * obj0 = 0 ;
35574 PyObject * obj1 = 0 ;
35575 PyObject * obj2 = 0 ;
35576 char *kwnames[] = {
35577 (char *) "self",(char *) "id",(char *) "label", NULL
35578 };
35579
35580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35582 if (SWIG_arg_fail(1)) SWIG_fail;
35583 {
35584 arg2 = (int)(SWIG_As_int(obj1));
35585 if (SWIG_arg_fail(2)) SWIG_fail;
35586 }
35587 {
35588 arg3 = wxString_in_helper(obj2);
35589 if (arg3 == NULL) SWIG_fail;
35590 temp3 = true;
35591 }
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35595
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 Py_INCREF(Py_None); resultobj = Py_None;
35600 {
35601 if (temp3)
35602 delete arg3;
35603 }
35604 return resultobj;
35605 fail:
35606 {
35607 if (temp3)
35608 delete arg3;
35609 }
35610 return NULL;
35611 }
35612
35613
35614 static PyObject *_wrap_wxMenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35615 PyObject *resultobj;
35616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35617 int arg2 ;
35618 wxString result;
35619 PyObject * obj0 = 0 ;
35620 PyObject * obj1 = 0 ;
35621 char *kwnames[] = {
35622 (char *) "self",(char *) "id", NULL
35623 };
35624
35625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35627 if (SWIG_arg_fail(1)) SWIG_fail;
35628 {
35629 arg2 = (int)(SWIG_As_int(obj1));
35630 if (SWIG_arg_fail(2)) SWIG_fail;
35631 }
35632 {
35633 PyThreadState* __tstate = wxPyBeginAllowThreads();
35634 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35635
35636 wxPyEndAllowThreads(__tstate);
35637 if (PyErr_Occurred()) SWIG_fail;
35638 }
35639 {
35640 #if wxUSE_UNICODE
35641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35642 #else
35643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35644 #endif
35645 }
35646 return resultobj;
35647 fail:
35648 return NULL;
35649 }
35650
35651
35652 static PyObject *_wrap_wxMenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35653 PyObject *resultobj;
35654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35655 int arg2 ;
35656 wxString *arg3 = 0 ;
35657 bool temp3 = false ;
35658 PyObject * obj0 = 0 ;
35659 PyObject * obj1 = 0 ;
35660 PyObject * obj2 = 0 ;
35661 char *kwnames[] = {
35662 (char *) "self",(char *) "id",(char *) "helpString", NULL
35663 };
35664
35665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxMenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35667 if (SWIG_arg_fail(1)) SWIG_fail;
35668 {
35669 arg2 = (int)(SWIG_As_int(obj1));
35670 if (SWIG_arg_fail(2)) SWIG_fail;
35671 }
35672 {
35673 arg3 = wxString_in_helper(obj2);
35674 if (arg3 == NULL) SWIG_fail;
35675 temp3 = true;
35676 }
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35680
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 Py_INCREF(Py_None); resultobj = Py_None;
35685 {
35686 if (temp3)
35687 delete arg3;
35688 }
35689 return resultobj;
35690 fail:
35691 {
35692 if (temp3)
35693 delete arg3;
35694 }
35695 return NULL;
35696 }
35697
35698
35699 static PyObject *_wrap_wxMenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35700 PyObject *resultobj;
35701 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35702 int arg2 ;
35703 wxString result;
35704 PyObject * obj0 = 0 ;
35705 PyObject * obj1 = 0 ;
35706 char *kwnames[] = {
35707 (char *) "self",(char *) "id", NULL
35708 };
35709
35710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35712 if (SWIG_arg_fail(1)) SWIG_fail;
35713 {
35714 arg2 = (int)(SWIG_As_int(obj1));
35715 if (SWIG_arg_fail(2)) SWIG_fail;
35716 }
35717 {
35718 PyThreadState* __tstate = wxPyBeginAllowThreads();
35719 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35720
35721 wxPyEndAllowThreads(__tstate);
35722 if (PyErr_Occurred()) SWIG_fail;
35723 }
35724 {
35725 #if wxUSE_UNICODE
35726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35727 #else
35728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35729 #endif
35730 }
35731 return resultobj;
35732 fail:
35733 return NULL;
35734 }
35735
35736
35737 static PyObject *_wrap_wxMenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35738 PyObject *resultobj;
35739 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35740 wxFrame *result;
35741 PyObject * obj0 = 0 ;
35742 char *kwnames[] = {
35743 (char *) "self", NULL
35744 };
35745
35746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuBar_GetFrame",kwnames,&obj0)) goto fail;
35747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35748 if (SWIG_arg_fail(1)) SWIG_fail;
35749 {
35750 PyThreadState* __tstate = wxPyBeginAllowThreads();
35751 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35752
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 {
35757 resultobj = wxPyMake_wxObject(result, 0);
35758 }
35759 return resultobj;
35760 fail:
35761 return NULL;
35762 }
35763
35764
35765 static PyObject *_wrap_wxMenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35766 PyObject *resultobj;
35767 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35768 bool result;
35769 PyObject * obj0 = 0 ;
35770 char *kwnames[] = {
35771 (char *) "self", NULL
35772 };
35773
35774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuBar_IsAttached",kwnames,&obj0)) goto fail;
35775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35776 if (SWIG_arg_fail(1)) SWIG_fail;
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35780
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 {
35785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35786 }
35787 return resultobj;
35788 fail:
35789 return NULL;
35790 }
35791
35792
35793 static PyObject *_wrap_wxMenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35794 PyObject *resultobj;
35795 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35796 wxFrame *arg2 = (wxFrame *) 0 ;
35797 PyObject * obj0 = 0 ;
35798 PyObject * obj1 = 0 ;
35799 char *kwnames[] = {
35800 (char *) "self",(char *) "frame", NULL
35801 };
35802
35803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35805 if (SWIG_arg_fail(1)) SWIG_fail;
35806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35807 if (SWIG_arg_fail(2)) SWIG_fail;
35808 {
35809 PyThreadState* __tstate = wxPyBeginAllowThreads();
35810 (arg1)->Attach(arg2);
35811
35812 wxPyEndAllowThreads(__tstate);
35813 if (PyErr_Occurred()) SWIG_fail;
35814 }
35815 Py_INCREF(Py_None); resultobj = Py_None;
35816 return resultobj;
35817 fail:
35818 return NULL;
35819 }
35820
35821
35822 static PyObject *_wrap_wxMenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35823 PyObject *resultobj;
35824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35825 PyObject * obj0 = 0 ;
35826 char *kwnames[] = {
35827 (char *) "self", NULL
35828 };
35829
35830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuBar_Detach",kwnames,&obj0)) goto fail;
35831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35832 if (SWIG_arg_fail(1)) SWIG_fail;
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 (arg1)->Detach();
35836
35837 wxPyEndAllowThreads(__tstate);
35838 if (PyErr_Occurred()) SWIG_fail;
35839 }
35840 Py_INCREF(Py_None); resultobj = Py_None;
35841 return resultobj;
35842 fail:
35843 return NULL;
35844 }
35845
35846
35847 static PyObject * wxMenuBar_swigregister(PyObject *, PyObject *args) {
35848 PyObject *obj;
35849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35850 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35851 Py_INCREF(obj);
35852 return Py_BuildValue((char *)"");
35853 }
35854 static PyObject *_wrap_new_wxMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj;
35856 wxMenu *arg1 = (wxMenu *) NULL ;
35857 int arg2 = (int) wxID_ANY ;
35858 wxString const &arg3_defvalue = wxPyEmptyString ;
35859 wxString *arg3 = (wxString *) &arg3_defvalue ;
35860 wxString const &arg4_defvalue = wxPyEmptyString ;
35861 wxString *arg4 = (wxString *) &arg4_defvalue ;
35862 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35863 wxMenu *arg6 = (wxMenu *) NULL ;
35864 wxMenuItem *result;
35865 bool temp3 = false ;
35866 bool temp4 = false ;
35867 PyObject * obj0 = 0 ;
35868 PyObject * obj1 = 0 ;
35869 PyObject * obj2 = 0 ;
35870 PyObject * obj3 = 0 ;
35871 PyObject * obj4 = 0 ;
35872 PyObject * obj5 = 0 ;
35873 char *kwnames[] = {
35874 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35875 };
35876
35877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_wxMenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35878 if (obj0) {
35879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35880 if (SWIG_arg_fail(1)) SWIG_fail;
35881 }
35882 if (obj1) {
35883 {
35884 arg2 = (int)(SWIG_As_int(obj1));
35885 if (SWIG_arg_fail(2)) SWIG_fail;
35886 }
35887 }
35888 if (obj2) {
35889 {
35890 arg3 = wxString_in_helper(obj2);
35891 if (arg3 == NULL) SWIG_fail;
35892 temp3 = true;
35893 }
35894 }
35895 if (obj3) {
35896 {
35897 arg4 = wxString_in_helper(obj3);
35898 if (arg4 == NULL) SWIG_fail;
35899 temp4 = true;
35900 }
35901 }
35902 if (obj4) {
35903 {
35904 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35905 if (SWIG_arg_fail(5)) SWIG_fail;
35906 }
35907 }
35908 if (obj5) {
35909 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35910 if (SWIG_arg_fail(6)) SWIG_fail;
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35915
35916 wxPyEndAllowThreads(__tstate);
35917 if (PyErr_Occurred()) SWIG_fail;
35918 }
35919 {
35920 resultobj = wxPyMake_wxObject(result, 1);
35921 }
35922 {
35923 if (temp3)
35924 delete arg3;
35925 }
35926 {
35927 if (temp4)
35928 delete arg4;
35929 }
35930 return resultobj;
35931 fail:
35932 {
35933 if (temp3)
35934 delete arg3;
35935 }
35936 {
35937 if (temp4)
35938 delete arg4;
35939 }
35940 return NULL;
35941 }
35942
35943
35944 static PyObject *_wrap_wxMenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35945 PyObject *resultobj;
35946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35947 wxMenu *result;
35948 PyObject * obj0 = 0 ;
35949 char *kwnames[] = {
35950 (char *) "self", NULL
35951 };
35952
35953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetMenu",kwnames,&obj0)) goto fail;
35954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(1)) SWIG_fail;
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35959
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 {
35964 resultobj = wxPyMake_wxObject(result, 0);
35965 }
35966 return resultobj;
35967 fail:
35968 return NULL;
35969 }
35970
35971
35972 static PyObject *_wrap_wxMenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj;
35974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35975 wxMenu *arg2 = (wxMenu *) 0 ;
35976 PyObject * obj0 = 0 ;
35977 PyObject * obj1 = 0 ;
35978 char *kwnames[] = {
35979 (char *) "self",(char *) "menu", NULL
35980 };
35981
35982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35984 if (SWIG_arg_fail(1)) SWIG_fail;
35985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35986 if (SWIG_arg_fail(2)) SWIG_fail;
35987 {
35988 PyThreadState* __tstate = wxPyBeginAllowThreads();
35989 (arg1)->SetMenu(arg2);
35990
35991 wxPyEndAllowThreads(__tstate);
35992 if (PyErr_Occurred()) SWIG_fail;
35993 }
35994 Py_INCREF(Py_None); resultobj = Py_None;
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 static PyObject *_wrap_wxMenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36002 PyObject *resultobj;
36003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36004 int arg2 ;
36005 PyObject * obj0 = 0 ;
36006 PyObject * obj1 = 0 ;
36007 char *kwnames[] = {
36008 (char *) "self",(char *) "id", NULL
36009 };
36010
36011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36013 if (SWIG_arg_fail(1)) SWIG_fail;
36014 {
36015 arg2 = (int)(SWIG_As_int(obj1));
36016 if (SWIG_arg_fail(2)) SWIG_fail;
36017 }
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 (arg1)->SetId(arg2);
36021
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 Py_INCREF(Py_None); resultobj = Py_None;
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 static PyObject *_wrap_wxMenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36033 PyObject *resultobj;
36034 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36035 int result;
36036 PyObject * obj0 = 0 ;
36037 char *kwnames[] = {
36038 (char *) "self", NULL
36039 };
36040
36041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetId",kwnames,&obj0)) goto fail;
36042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36043 if (SWIG_arg_fail(1)) SWIG_fail;
36044 {
36045 PyThreadState* __tstate = wxPyBeginAllowThreads();
36046 result = (int)((wxMenuItem const *)arg1)->GetId();
36047
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 {
36052 resultobj = SWIG_From_int((int)(result));
36053 }
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 static PyObject *_wrap_wxMenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36061 PyObject *resultobj;
36062 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36063 bool result;
36064 PyObject * obj0 = 0 ;
36065 char *kwnames[] = {
36066 (char *) "self", NULL
36067 };
36068
36069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36071 if (SWIG_arg_fail(1)) SWIG_fail;
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36075
36076 wxPyEndAllowThreads(__tstate);
36077 if (PyErr_Occurred()) SWIG_fail;
36078 }
36079 {
36080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36081 }
36082 return resultobj;
36083 fail:
36084 return NULL;
36085 }
36086
36087
36088 static PyObject *_wrap_wxMenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36089 PyObject *resultobj;
36090 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36091 wxString *arg2 = 0 ;
36092 bool temp2 = false ;
36093 PyObject * obj0 = 0 ;
36094 PyObject * obj1 = 0 ;
36095 char *kwnames[] = {
36096 (char *) "self",(char *) "str", NULL
36097 };
36098
36099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36101 if (SWIG_arg_fail(1)) SWIG_fail;
36102 {
36103 arg2 = wxString_in_helper(obj1);
36104 if (arg2 == NULL) SWIG_fail;
36105 temp2 = true;
36106 }
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 (arg1)->SetText((wxString const &)*arg2);
36110
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 Py_INCREF(Py_None); resultobj = Py_None;
36115 {
36116 if (temp2)
36117 delete arg2;
36118 }
36119 return resultobj;
36120 fail:
36121 {
36122 if (temp2)
36123 delete arg2;
36124 }
36125 return NULL;
36126 }
36127
36128
36129 static PyObject *_wrap_wxMenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36130 PyObject *resultobj;
36131 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36132 wxString result;
36133 PyObject * obj0 = 0 ;
36134 char *kwnames[] = {
36135 (char *) "self", NULL
36136 };
36137
36138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetLabel",kwnames,&obj0)) goto fail;
36139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36140 if (SWIG_arg_fail(1)) SWIG_fail;
36141 {
36142 PyThreadState* __tstate = wxPyBeginAllowThreads();
36143 result = ((wxMenuItem const *)arg1)->GetLabel();
36144
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 {
36149 #if wxUSE_UNICODE
36150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36151 #else
36152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36153 #endif
36154 }
36155 return resultobj;
36156 fail:
36157 return NULL;
36158 }
36159
36160
36161 static PyObject *_wrap_wxMenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36162 PyObject *resultobj;
36163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36164 wxString *result;
36165 PyObject * obj0 = 0 ;
36166 char *kwnames[] = {
36167 (char *) "self", NULL
36168 };
36169
36170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetText",kwnames,&obj0)) goto fail;
36171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36172 if (SWIG_arg_fail(1)) SWIG_fail;
36173 {
36174 PyThreadState* __tstate = wxPyBeginAllowThreads();
36175 {
36176 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36177 result = (wxString *) &_result_ref;
36178 }
36179
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 {
36184 #if wxUSE_UNICODE
36185 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36186 #else
36187 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36188 #endif
36189 }
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 static PyObject *_wrap_wxMenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36197 PyObject *resultobj;
36198 wxString *arg1 = 0 ;
36199 wxString result;
36200 bool temp1 = false ;
36201 PyObject * obj0 = 0 ;
36202 char *kwnames[] = {
36203 (char *) "text", NULL
36204 };
36205
36206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36207 {
36208 arg1 = wxString_in_helper(obj0);
36209 if (arg1 == NULL) SWIG_fail;
36210 temp1 = true;
36211 }
36212 {
36213 PyThreadState* __tstate = wxPyBeginAllowThreads();
36214 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36215
36216 wxPyEndAllowThreads(__tstate);
36217 if (PyErr_Occurred()) SWIG_fail;
36218 }
36219 {
36220 #if wxUSE_UNICODE
36221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36222 #else
36223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36224 #endif
36225 }
36226 {
36227 if (temp1)
36228 delete arg1;
36229 }
36230 return resultobj;
36231 fail:
36232 {
36233 if (temp1)
36234 delete arg1;
36235 }
36236 return NULL;
36237 }
36238
36239
36240 static PyObject *_wrap_wxMenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36241 PyObject *resultobj;
36242 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36243 wxItemKind result;
36244 PyObject * obj0 = 0 ;
36245 char *kwnames[] = {
36246 (char *) "self", NULL
36247 };
36248
36249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetKind",kwnames,&obj0)) goto fail;
36250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36251 if (SWIG_arg_fail(1)) SWIG_fail;
36252 {
36253 PyThreadState* __tstate = wxPyBeginAllowThreads();
36254 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36255
36256 wxPyEndAllowThreads(__tstate);
36257 if (PyErr_Occurred()) SWIG_fail;
36258 }
36259 resultobj = SWIG_From_int((result));
36260 return resultobj;
36261 fail:
36262 return NULL;
36263 }
36264
36265
36266 static PyObject *_wrap_wxMenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36267 PyObject *resultobj;
36268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36269 wxItemKind arg2 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 char *kwnames[] = {
36273 (char *) "self",(char *) "kind", NULL
36274 };
36275
36276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36278 if (SWIG_arg_fail(1)) SWIG_fail;
36279 {
36280 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36281 if (SWIG_arg_fail(2)) SWIG_fail;
36282 }
36283 {
36284 PyThreadState* __tstate = wxPyBeginAllowThreads();
36285 (arg1)->SetKind((wxItemKind )arg2);
36286
36287 wxPyEndAllowThreads(__tstate);
36288 if (PyErr_Occurred()) SWIG_fail;
36289 }
36290 Py_INCREF(Py_None); resultobj = Py_None;
36291 return resultobj;
36292 fail:
36293 return NULL;
36294 }
36295
36296
36297 static PyObject *_wrap_wxMenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36298 PyObject *resultobj;
36299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36300 bool arg2 ;
36301 PyObject * obj0 = 0 ;
36302 PyObject * obj1 = 0 ;
36303 char *kwnames[] = {
36304 (char *) "self",(char *) "checkable", NULL
36305 };
36306
36307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36309 if (SWIG_arg_fail(1)) SWIG_fail;
36310 {
36311 arg2 = (bool)(SWIG_As_bool(obj1));
36312 if (SWIG_arg_fail(2)) SWIG_fail;
36313 }
36314 {
36315 PyThreadState* __tstate = wxPyBeginAllowThreads();
36316 (arg1)->SetCheckable(arg2);
36317
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 Py_INCREF(Py_None); resultobj = Py_None;
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 static PyObject *_wrap_wxMenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36329 PyObject *resultobj;
36330 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36331 bool result;
36332 PyObject * obj0 = 0 ;
36333 char *kwnames[] = {
36334 (char *) "self", NULL
36335 };
36336
36337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36339 if (SWIG_arg_fail(1)) SWIG_fail;
36340 {
36341 PyThreadState* __tstate = wxPyBeginAllowThreads();
36342 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36343
36344 wxPyEndAllowThreads(__tstate);
36345 if (PyErr_Occurred()) SWIG_fail;
36346 }
36347 {
36348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36349 }
36350 return resultobj;
36351 fail:
36352 return NULL;
36353 }
36354
36355
36356 static PyObject *_wrap_wxMenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36357 PyObject *resultobj;
36358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36359 bool result;
36360 PyObject * obj0 = 0 ;
36361 char *kwnames[] = {
36362 (char *) "self", NULL
36363 };
36364
36365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36367 if (SWIG_arg_fail(1)) SWIG_fail;
36368 {
36369 PyThreadState* __tstate = wxPyBeginAllowThreads();
36370 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36371
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 {
36376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36377 }
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 static PyObject *_wrap_wxMenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36385 PyObject *resultobj;
36386 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36387 wxMenu *arg2 = (wxMenu *) 0 ;
36388 PyObject * obj0 = 0 ;
36389 PyObject * obj1 = 0 ;
36390 char *kwnames[] = {
36391 (char *) "self",(char *) "menu", NULL
36392 };
36393
36394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36396 if (SWIG_arg_fail(1)) SWIG_fail;
36397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36398 if (SWIG_arg_fail(2)) SWIG_fail;
36399 {
36400 PyThreadState* __tstate = wxPyBeginAllowThreads();
36401 (arg1)->SetSubMenu(arg2);
36402
36403 wxPyEndAllowThreads(__tstate);
36404 if (PyErr_Occurred()) SWIG_fail;
36405 }
36406 Py_INCREF(Py_None); resultobj = Py_None;
36407 return resultobj;
36408 fail:
36409 return NULL;
36410 }
36411
36412
36413 static PyObject *_wrap_wxMenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36414 PyObject *resultobj;
36415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36416 wxMenu *result;
36417 PyObject * obj0 = 0 ;
36418 char *kwnames[] = {
36419 (char *) "self", NULL
36420 };
36421
36422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36424 if (SWIG_arg_fail(1)) SWIG_fail;
36425 {
36426 PyThreadState* __tstate = wxPyBeginAllowThreads();
36427 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36428
36429 wxPyEndAllowThreads(__tstate);
36430 if (PyErr_Occurred()) SWIG_fail;
36431 }
36432 {
36433 resultobj = wxPyMake_wxObject(result, 0);
36434 }
36435 return resultobj;
36436 fail:
36437 return NULL;
36438 }
36439
36440
36441 static PyObject *_wrap_wxMenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36442 PyObject *resultobj;
36443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36444 bool arg2 = (bool) true ;
36445 PyObject * obj0 = 0 ;
36446 PyObject * obj1 = 0 ;
36447 char *kwnames[] = {
36448 (char *) "self",(char *) "enable", NULL
36449 };
36450
36451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36453 if (SWIG_arg_fail(1)) SWIG_fail;
36454 if (obj1) {
36455 {
36456 arg2 = (bool)(SWIG_As_bool(obj1));
36457 if (SWIG_arg_fail(2)) SWIG_fail;
36458 }
36459 }
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 (arg1)->Enable(arg2);
36463
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 Py_INCREF(Py_None); resultobj = Py_None;
36468 return resultobj;
36469 fail:
36470 return NULL;
36471 }
36472
36473
36474 static PyObject *_wrap_wxMenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36475 PyObject *resultobj;
36476 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36477 bool result;
36478 PyObject * obj0 = 0 ;
36479 char *kwnames[] = {
36480 (char *) "self", NULL
36481 };
36482
36483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36485 if (SWIG_arg_fail(1)) SWIG_fail;
36486 {
36487 PyThreadState* __tstate = wxPyBeginAllowThreads();
36488 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36489
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 {
36494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36495 }
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 static PyObject *_wrap_wxMenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj;
36504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36505 bool arg2 = (bool) true ;
36506 PyObject * obj0 = 0 ;
36507 PyObject * obj1 = 0 ;
36508 char *kwnames[] = {
36509 (char *) "self",(char *) "check", NULL
36510 };
36511
36512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36514 if (SWIG_arg_fail(1)) SWIG_fail;
36515 if (obj1) {
36516 {
36517 arg2 = (bool)(SWIG_As_bool(obj1));
36518 if (SWIG_arg_fail(2)) SWIG_fail;
36519 }
36520 }
36521 {
36522 PyThreadState* __tstate = wxPyBeginAllowThreads();
36523 (arg1)->Check(arg2);
36524
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 Py_INCREF(Py_None); resultobj = Py_None;
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 static PyObject *_wrap_wxMenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj;
36537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36538 bool result;
36539 PyObject * obj0 = 0 ;
36540 char *kwnames[] = {
36541 (char *) "self", NULL
36542 };
36543
36544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_IsChecked",kwnames,&obj0)) goto fail;
36545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36546 if (SWIG_arg_fail(1)) SWIG_fail;
36547 {
36548 PyThreadState* __tstate = wxPyBeginAllowThreads();
36549 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36550
36551 wxPyEndAllowThreads(__tstate);
36552 if (PyErr_Occurred()) SWIG_fail;
36553 }
36554 {
36555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36556 }
36557 return resultobj;
36558 fail:
36559 return NULL;
36560 }
36561
36562
36563 static PyObject *_wrap_wxMenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36564 PyObject *resultobj;
36565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36566 PyObject * obj0 = 0 ;
36567 char *kwnames[] = {
36568 (char *) "self", NULL
36569 };
36570
36571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_Toggle",kwnames,&obj0)) goto fail;
36572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36573 if (SWIG_arg_fail(1)) SWIG_fail;
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 (arg1)->Toggle();
36577
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 Py_INCREF(Py_None); resultobj = Py_None;
36582 return resultobj;
36583 fail:
36584 return NULL;
36585 }
36586
36587
36588 static PyObject *_wrap_wxMenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36589 PyObject *resultobj;
36590 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36591 wxString *arg2 = 0 ;
36592 bool temp2 = false ;
36593 PyObject * obj0 = 0 ;
36594 PyObject * obj1 = 0 ;
36595 char *kwnames[] = {
36596 (char *) "self",(char *) "str", NULL
36597 };
36598
36599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36601 if (SWIG_arg_fail(1)) SWIG_fail;
36602 {
36603 arg2 = wxString_in_helper(obj1);
36604 if (arg2 == NULL) SWIG_fail;
36605 temp2 = true;
36606 }
36607 {
36608 PyThreadState* __tstate = wxPyBeginAllowThreads();
36609 (arg1)->SetHelp((wxString const &)*arg2);
36610
36611 wxPyEndAllowThreads(__tstate);
36612 if (PyErr_Occurred()) SWIG_fail;
36613 }
36614 Py_INCREF(Py_None); resultobj = Py_None;
36615 {
36616 if (temp2)
36617 delete arg2;
36618 }
36619 return resultobj;
36620 fail:
36621 {
36622 if (temp2)
36623 delete arg2;
36624 }
36625 return NULL;
36626 }
36627
36628
36629 static PyObject *_wrap_wxMenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj;
36631 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36632 wxString *result;
36633 PyObject * obj0 = 0 ;
36634 char *kwnames[] = {
36635 (char *) "self", NULL
36636 };
36637
36638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetHelp",kwnames,&obj0)) goto fail;
36639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36640 if (SWIG_arg_fail(1)) SWIG_fail;
36641 {
36642 PyThreadState* __tstate = wxPyBeginAllowThreads();
36643 {
36644 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36645 result = (wxString *) &_result_ref;
36646 }
36647
36648 wxPyEndAllowThreads(__tstate);
36649 if (PyErr_Occurred()) SWIG_fail;
36650 }
36651 {
36652 #if wxUSE_UNICODE
36653 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36654 #else
36655 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36656 #endif
36657 }
36658 return resultobj;
36659 fail:
36660 return NULL;
36661 }
36662
36663
36664 static PyObject *_wrap_wxMenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36665 PyObject *resultobj;
36666 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36667 wxAcceleratorEntry *result;
36668 PyObject * obj0 = 0 ;
36669 char *kwnames[] = {
36670 (char *) "self", NULL
36671 };
36672
36673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetAccel",kwnames,&obj0)) goto fail;
36674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36675 if (SWIG_arg_fail(1)) SWIG_fail;
36676 {
36677 PyThreadState* __tstate = wxPyBeginAllowThreads();
36678 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36679
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36684 return resultobj;
36685 fail:
36686 return NULL;
36687 }
36688
36689
36690 static PyObject *_wrap_wxMenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36691 PyObject *resultobj;
36692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36693 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36694 PyObject * obj0 = 0 ;
36695 PyObject * obj1 = 0 ;
36696 char *kwnames[] = {
36697 (char *) "self",(char *) "accel", NULL
36698 };
36699
36700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36702 if (SWIG_arg_fail(1)) SWIG_fail;
36703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36704 if (SWIG_arg_fail(2)) SWIG_fail;
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 (arg1)->SetAccel(arg2);
36708
36709 wxPyEndAllowThreads(__tstate);
36710 if (PyErr_Occurred()) SWIG_fail;
36711 }
36712 Py_INCREF(Py_None); resultobj = Py_None;
36713 return resultobj;
36714 fail:
36715 return NULL;
36716 }
36717
36718
36719 static PyObject *_wrap_wxMenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36720 PyObject *resultobj;
36721 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36722 wxFont *arg2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char *kwnames[] = {
36726 (char *) "self",(char *) "font", NULL
36727 };
36728
36729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36731 if (SWIG_arg_fail(1)) SWIG_fail;
36732 {
36733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36734 if (SWIG_arg_fail(2)) SWIG_fail;
36735 if (arg2 == NULL) {
36736 SWIG_null_ref("wxFont");
36737 }
36738 if (SWIG_arg_fail(2)) SWIG_fail;
36739 }
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36743
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 Py_INCREF(Py_None); resultobj = Py_None;
36748 return resultobj;
36749 fail:
36750 return NULL;
36751 }
36752
36753
36754 static PyObject *_wrap_wxMenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36755 PyObject *resultobj;
36756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36757 wxFont result;
36758 PyObject * obj0 = 0 ;
36759 char *kwnames[] = {
36760 (char *) "self", NULL
36761 };
36762
36763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetFont",kwnames,&obj0)) goto fail;
36764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36765 if (SWIG_arg_fail(1)) SWIG_fail;
36766 {
36767 PyThreadState* __tstate = wxPyBeginAllowThreads();
36768 result = wxMenuItem_GetFont(arg1);
36769
36770 wxPyEndAllowThreads(__tstate);
36771 if (PyErr_Occurred()) SWIG_fail;
36772 }
36773 {
36774 wxFont * resultptr;
36775 resultptr = new wxFont((wxFont &)(result));
36776 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36777 }
36778 return resultobj;
36779 fail:
36780 return NULL;
36781 }
36782
36783
36784 static PyObject *_wrap_wxMenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36785 PyObject *resultobj;
36786 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36787 wxColour *arg2 = 0 ;
36788 wxColour temp2 ;
36789 PyObject * obj0 = 0 ;
36790 PyObject * obj1 = 0 ;
36791 char *kwnames[] = {
36792 (char *) "self",(char *) "colText", NULL
36793 };
36794
36795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36797 if (SWIG_arg_fail(1)) SWIG_fail;
36798 {
36799 arg2 = &temp2;
36800 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36801 }
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36805
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 Py_INCREF(Py_None); resultobj = Py_None;
36810 return resultobj;
36811 fail:
36812 return NULL;
36813 }
36814
36815
36816 static PyObject *_wrap_wxMenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36817 PyObject *resultobj;
36818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36819 wxColour result;
36820 PyObject * obj0 = 0 ;
36821 char *kwnames[] = {
36822 (char *) "self", NULL
36823 };
36824
36825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36827 if (SWIG_arg_fail(1)) SWIG_fail;
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 result = wxMenuItem_GetTextColour(arg1);
36831
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 {
36836 wxColour * resultptr;
36837 resultptr = new wxColour((wxColour &)(result));
36838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36839 }
36840 return resultobj;
36841 fail:
36842 return NULL;
36843 }
36844
36845
36846 static PyObject *_wrap_wxMenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36847 PyObject *resultobj;
36848 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36849 wxColour *arg2 = 0 ;
36850 wxColour temp2 ;
36851 PyObject * obj0 = 0 ;
36852 PyObject * obj1 = 0 ;
36853 char *kwnames[] = {
36854 (char *) "self",(char *) "colBack", NULL
36855 };
36856
36857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36859 if (SWIG_arg_fail(1)) SWIG_fail;
36860 {
36861 arg2 = &temp2;
36862 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36863 }
36864 {
36865 PyThreadState* __tstate = wxPyBeginAllowThreads();
36866 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36867
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 Py_INCREF(Py_None); resultobj = Py_None;
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 static PyObject *_wrap_wxMenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36879 PyObject *resultobj;
36880 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36881 wxColour result;
36882 PyObject * obj0 = 0 ;
36883 char *kwnames[] = {
36884 (char *) "self", NULL
36885 };
36886
36887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36889 if (SWIG_arg_fail(1)) SWIG_fail;
36890 {
36891 PyThreadState* __tstate = wxPyBeginAllowThreads();
36892 result = wxMenuItem_GetBackgroundColour(arg1);
36893
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 {
36898 wxColour * resultptr;
36899 resultptr = new wxColour((wxColour &)(result));
36900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36901 }
36902 return resultobj;
36903 fail:
36904 return NULL;
36905 }
36906
36907
36908 static PyObject *_wrap_wxMenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36909 PyObject *resultobj;
36910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36911 wxBitmap *arg2 = 0 ;
36912 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36913 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36914 PyObject * obj0 = 0 ;
36915 PyObject * obj1 = 0 ;
36916 PyObject * obj2 = 0 ;
36917 char *kwnames[] = {
36918 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36919 };
36920
36921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxMenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36923 if (SWIG_arg_fail(1)) SWIG_fail;
36924 {
36925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36926 if (SWIG_arg_fail(2)) SWIG_fail;
36927 if (arg2 == NULL) {
36928 SWIG_null_ref("wxBitmap");
36929 }
36930 if (SWIG_arg_fail(2)) SWIG_fail;
36931 }
36932 if (obj2) {
36933 {
36934 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36935 if (SWIG_arg_fail(3)) SWIG_fail;
36936 if (arg3 == NULL) {
36937 SWIG_null_ref("wxBitmap");
36938 }
36939 if (SWIG_arg_fail(3)) SWIG_fail;
36940 }
36941 }
36942 {
36943 PyThreadState* __tstate = wxPyBeginAllowThreads();
36944 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36945
36946 wxPyEndAllowThreads(__tstate);
36947 if (PyErr_Occurred()) SWIG_fail;
36948 }
36949 Py_INCREF(Py_None); resultobj = Py_None;
36950 return resultobj;
36951 fail:
36952 return NULL;
36953 }
36954
36955
36956 static PyObject *_wrap_wxMenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36957 PyObject *resultobj;
36958 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36959 wxBitmap *arg2 = 0 ;
36960 PyObject * obj0 = 0 ;
36961 PyObject * obj1 = 0 ;
36962 char *kwnames[] = {
36963 (char *) "self",(char *) "bmpDisabled", NULL
36964 };
36965
36966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36968 if (SWIG_arg_fail(1)) SWIG_fail;
36969 {
36970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(2)) SWIG_fail;
36972 if (arg2 == NULL) {
36973 SWIG_null_ref("wxBitmap");
36974 }
36975 if (SWIG_arg_fail(2)) SWIG_fail;
36976 }
36977 {
36978 PyThreadState* __tstate = wxPyBeginAllowThreads();
36979 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36980
36981 wxPyEndAllowThreads(__tstate);
36982 if (PyErr_Occurred()) SWIG_fail;
36983 }
36984 Py_INCREF(Py_None); resultobj = Py_None;
36985 return resultobj;
36986 fail:
36987 return NULL;
36988 }
36989
36990
36991 static PyObject *_wrap_wxMenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36992 PyObject *resultobj;
36993 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36994 wxBitmap *result;
36995 PyObject * obj0 = 0 ;
36996 char *kwnames[] = {
36997 (char *) "self", NULL
36998 };
36999
37000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37002 if (SWIG_arg_fail(1)) SWIG_fail;
37003 {
37004 PyThreadState* __tstate = wxPyBeginAllowThreads();
37005 {
37006 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37007 result = (wxBitmap *) &_result_ref;
37008 }
37009
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 {
37014 wxBitmap* resultptr = new wxBitmap(*result);
37015 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37016 }
37017 return resultobj;
37018 fail:
37019 return NULL;
37020 }
37021
37022
37023 static PyObject *_wrap_wxMenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37024 PyObject *resultobj;
37025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37026 int arg2 ;
37027 PyObject * obj0 = 0 ;
37028 PyObject * obj1 = 0 ;
37029 char *kwnames[] = {
37030 (char *) "self",(char *) "nWidth", NULL
37031 };
37032
37033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37035 if (SWIG_arg_fail(1)) SWIG_fail;
37036 {
37037 arg2 = (int)(SWIG_As_int(obj1));
37038 if (SWIG_arg_fail(2)) SWIG_fail;
37039 }
37040 {
37041 PyThreadState* __tstate = wxPyBeginAllowThreads();
37042 wxMenuItem_SetMarginWidth(arg1,arg2);
37043
37044 wxPyEndAllowThreads(__tstate);
37045 if (PyErr_Occurred()) SWIG_fail;
37046 }
37047 Py_INCREF(Py_None); resultobj = Py_None;
37048 return resultobj;
37049 fail:
37050 return NULL;
37051 }
37052
37053
37054 static PyObject *_wrap_wxMenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37055 PyObject *resultobj;
37056 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37057 int result;
37058 PyObject * obj0 = 0 ;
37059 char *kwnames[] = {
37060 (char *) "self", NULL
37061 };
37062
37063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37065 if (SWIG_arg_fail(1)) SWIG_fail;
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 result = (int)wxMenuItem_GetMarginWidth(arg1);
37069
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 {
37074 resultobj = SWIG_From_int((int)(result));
37075 }
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 static PyObject *_wrap_wxMenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37083 PyObject *resultobj;
37084 int result;
37085 char *kwnames[] = {
37086 NULL
37087 };
37088
37089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":wxMenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37090 {
37091 PyThreadState* __tstate = wxPyBeginAllowThreads();
37092 result = (int)wxMenuItem_GetDefaultMarginWidth();
37093
37094 wxPyEndAllowThreads(__tstate);
37095 if (PyErr_Occurred()) SWIG_fail;
37096 }
37097 {
37098 resultobj = SWIG_From_int((int)(result));
37099 }
37100 return resultobj;
37101 fail:
37102 return NULL;
37103 }
37104
37105
37106 static PyObject *_wrap_wxMenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37107 PyObject *resultobj;
37108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37109 bool result;
37110 PyObject * obj0 = 0 ;
37111 char *kwnames[] = {
37112 (char *) "self", NULL
37113 };
37114
37115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37117 if (SWIG_arg_fail(1)) SWIG_fail;
37118 {
37119 PyThreadState* __tstate = wxPyBeginAllowThreads();
37120 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37121
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 {
37126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37127 }
37128 return resultobj;
37129 fail:
37130 return NULL;
37131 }
37132
37133
37134 static PyObject *_wrap_wxMenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37135 PyObject *resultobj;
37136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37137 bool arg2 = (bool) true ;
37138 PyObject * obj0 = 0 ;
37139 PyObject * obj1 = 0 ;
37140 char *kwnames[] = {
37141 (char *) "self",(char *) "ownerDrawn", NULL
37142 };
37143
37144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxMenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37146 if (SWIG_arg_fail(1)) SWIG_fail;
37147 if (obj1) {
37148 {
37149 arg2 = (bool)(SWIG_As_bool(obj1));
37150 if (SWIG_arg_fail(2)) SWIG_fail;
37151 }
37152 }
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37156
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 Py_INCREF(Py_None); resultobj = Py_None;
37161 return resultobj;
37162 fail:
37163 return NULL;
37164 }
37165
37166
37167 static PyObject *_wrap_wxMenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37168 PyObject *resultobj;
37169 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37170 PyObject * obj0 = 0 ;
37171 char *kwnames[] = {
37172 (char *) "self", NULL
37173 };
37174
37175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37177 if (SWIG_arg_fail(1)) SWIG_fail;
37178 {
37179 PyThreadState* __tstate = wxPyBeginAllowThreads();
37180 wxMenuItem_ResetOwnerDrawn(arg1);
37181
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 Py_INCREF(Py_None); resultobj = Py_None;
37186 return resultobj;
37187 fail:
37188 return NULL;
37189 }
37190
37191
37192 static PyObject *_wrap_wxMenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37193 PyObject *resultobj;
37194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37195 wxBitmap *arg2 = 0 ;
37196 PyObject * obj0 = 0 ;
37197 PyObject * obj1 = 0 ;
37198 char *kwnames[] = {
37199 (char *) "self",(char *) "bitmap", NULL
37200 };
37201
37202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxMenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37204 if (SWIG_arg_fail(1)) SWIG_fail;
37205 {
37206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37207 if (SWIG_arg_fail(2)) SWIG_fail;
37208 if (arg2 == NULL) {
37209 SWIG_null_ref("wxBitmap");
37210 }
37211 if (SWIG_arg_fail(2)) SWIG_fail;
37212 }
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37216
37217 wxPyEndAllowThreads(__tstate);
37218 if (PyErr_Occurred()) SWIG_fail;
37219 }
37220 Py_INCREF(Py_None); resultobj = Py_None;
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 static PyObject *_wrap_wxMenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37228 PyObject *resultobj;
37229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37230 wxBitmap *result;
37231 PyObject * obj0 = 0 ;
37232 char *kwnames[] = {
37233 (char *) "self", NULL
37234 };
37235
37236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxMenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37238 if (SWIG_arg_fail(1)) SWIG_fail;
37239 {
37240 PyThreadState* __tstate = wxPyBeginAllowThreads();
37241 {
37242 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37243 result = (wxBitmap *) &_result_ref;
37244 }
37245
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 {
37250 wxBitmap* resultptr = new wxBitmap(*result);
37251 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37252 }
37253 return resultobj;
37254 fail:
37255 return NULL;
37256 }
37257
37258
37259 static PyObject * wxMenuItem_swigregister(PyObject *, PyObject *args) {
37260 PyObject *obj;
37261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37262 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37263 Py_INCREF(obj);
37264 return Py_BuildValue((char *)"");
37265 }
37266 static int _wrap_ControlNameStr_set(PyObject *) {
37267 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37268 return 1;
37269 }
37270
37271
37272 static PyObject *_wrap_ControlNameStr_get(void) {
37273 PyObject *pyobj;
37274
37275 {
37276 #if wxUSE_UNICODE
37277 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37278 #else
37279 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37280 #endif
37281 }
37282 return pyobj;
37283 }
37284
37285
37286 static PyObject *_wrap_new_wxControl(PyObject *, PyObject *args, PyObject *kwargs) {
37287 PyObject *resultobj;
37288 wxWindow *arg1 = (wxWindow *) 0 ;
37289 int arg2 = (int) -1 ;
37290 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37291 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37292 wxSize const &arg4_defvalue = wxDefaultSize ;
37293 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37294 long arg5 = (long) 0 ;
37295 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37296 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37297 wxString const &arg7_defvalue = wxPyControlNameStr ;
37298 wxString *arg7 = (wxString *) &arg7_defvalue ;
37299 wxControl *result;
37300 wxPoint temp3 ;
37301 wxSize temp4 ;
37302 bool temp7 = false ;
37303 PyObject * obj0 = 0 ;
37304 PyObject * obj1 = 0 ;
37305 PyObject * obj2 = 0 ;
37306 PyObject * obj3 = 0 ;
37307 PyObject * obj4 = 0 ;
37308 PyObject * obj5 = 0 ;
37309 PyObject * obj6 = 0 ;
37310 char *kwnames[] = {
37311 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37312 };
37313
37314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_wxControl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37316 if (SWIG_arg_fail(1)) SWIG_fail;
37317 if (obj1) {
37318 {
37319 arg2 = (int)(SWIG_As_int(obj1));
37320 if (SWIG_arg_fail(2)) SWIG_fail;
37321 }
37322 }
37323 if (obj2) {
37324 {
37325 arg3 = &temp3;
37326 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37327 }
37328 }
37329 if (obj3) {
37330 {
37331 arg4 = &temp4;
37332 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37333 }
37334 }
37335 if (obj4) {
37336 {
37337 arg5 = (long)(SWIG_As_long(obj4));
37338 if (SWIG_arg_fail(5)) SWIG_fail;
37339 }
37340 }
37341 if (obj5) {
37342 {
37343 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37344 if (SWIG_arg_fail(6)) SWIG_fail;
37345 if (arg6 == NULL) {
37346 SWIG_null_ref("wxValidator");
37347 }
37348 if (SWIG_arg_fail(6)) SWIG_fail;
37349 }
37350 }
37351 if (obj6) {
37352 {
37353 arg7 = wxString_in_helper(obj6);
37354 if (arg7 == NULL) SWIG_fail;
37355 temp7 = true;
37356 }
37357 }
37358 {
37359 if (!wxPyCheckForApp()) SWIG_fail;
37360 PyThreadState* __tstate = wxPyBeginAllowThreads();
37361 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37362
37363 wxPyEndAllowThreads(__tstate);
37364 if (PyErr_Occurred()) SWIG_fail;
37365 }
37366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37367 {
37368 if (temp7)
37369 delete arg7;
37370 }
37371 return resultobj;
37372 fail:
37373 {
37374 if (temp7)
37375 delete arg7;
37376 }
37377 return NULL;
37378 }
37379
37380
37381 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37382 PyObject *resultobj;
37383 wxControl *result;
37384 char *kwnames[] = {
37385 NULL
37386 };
37387
37388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37389 {
37390 if (!wxPyCheckForApp()) SWIG_fail;
37391 PyThreadState* __tstate = wxPyBeginAllowThreads();
37392 result = (wxControl *)new wxControl();
37393
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 static PyObject *_wrap_wxControl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37405 PyObject *resultobj;
37406 wxControl *arg1 = (wxControl *) 0 ;
37407 wxWindow *arg2 = (wxWindow *) 0 ;
37408 int arg3 = (int) -1 ;
37409 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37410 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37411 wxSize const &arg5_defvalue = wxDefaultSize ;
37412 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37413 long arg6 = (long) 0 ;
37414 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37415 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37416 wxString const &arg8_defvalue = wxPyControlNameStr ;
37417 wxString *arg8 = (wxString *) &arg8_defvalue ;
37418 bool result;
37419 wxPoint temp4 ;
37420 wxSize temp5 ;
37421 bool temp8 = false ;
37422 PyObject * obj0 = 0 ;
37423 PyObject * obj1 = 0 ;
37424 PyObject * obj2 = 0 ;
37425 PyObject * obj3 = 0 ;
37426 PyObject * obj4 = 0 ;
37427 PyObject * obj5 = 0 ;
37428 PyObject * obj6 = 0 ;
37429 PyObject * obj7 = 0 ;
37430 char *kwnames[] = {
37431 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37432 };
37433
37434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:wxControl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37436 if (SWIG_arg_fail(1)) SWIG_fail;
37437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37438 if (SWIG_arg_fail(2)) SWIG_fail;
37439 if (obj2) {
37440 {
37441 arg3 = (int)(SWIG_As_int(obj2));
37442 if (SWIG_arg_fail(3)) SWIG_fail;
37443 }
37444 }
37445 if (obj3) {
37446 {
37447 arg4 = &temp4;
37448 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37449 }
37450 }
37451 if (obj4) {
37452 {
37453 arg5 = &temp5;
37454 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37455 }
37456 }
37457 if (obj5) {
37458 {
37459 arg6 = (long)(SWIG_As_long(obj5));
37460 if (SWIG_arg_fail(6)) SWIG_fail;
37461 }
37462 }
37463 if (obj6) {
37464 {
37465 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37466 if (SWIG_arg_fail(7)) SWIG_fail;
37467 if (arg7 == NULL) {
37468 SWIG_null_ref("wxValidator");
37469 }
37470 if (SWIG_arg_fail(7)) SWIG_fail;
37471 }
37472 }
37473 if (obj7) {
37474 {
37475 arg8 = wxString_in_helper(obj7);
37476 if (arg8 == NULL) SWIG_fail;
37477 temp8 = true;
37478 }
37479 }
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37483
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 {
37488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37489 }
37490 {
37491 if (temp8)
37492 delete arg8;
37493 }
37494 return resultobj;
37495 fail:
37496 {
37497 if (temp8)
37498 delete arg8;
37499 }
37500 return NULL;
37501 }
37502
37503
37504 static PyObject *_wrap_wxControl_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37505 PyObject *resultobj;
37506 wxControl *arg1 = (wxControl *) 0 ;
37507 wxCommandEvent *arg2 = 0 ;
37508 PyObject * obj0 = 0 ;
37509 PyObject * obj1 = 0 ;
37510 char *kwnames[] = {
37511 (char *) "self",(char *) "event", NULL
37512 };
37513
37514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxControl_Command",kwnames,&obj0,&obj1)) goto fail;
37515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37516 if (SWIG_arg_fail(1)) SWIG_fail;
37517 {
37518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37519 if (SWIG_arg_fail(2)) SWIG_fail;
37520 if (arg2 == NULL) {
37521 SWIG_null_ref("wxCommandEvent");
37522 }
37523 if (SWIG_arg_fail(2)) SWIG_fail;
37524 }
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 (arg1)->Command(*arg2);
37528
37529 wxPyEndAllowThreads(__tstate);
37530 if (PyErr_Occurred()) SWIG_fail;
37531 }
37532 Py_INCREF(Py_None); resultobj = Py_None;
37533 return resultobj;
37534 fail:
37535 return NULL;
37536 }
37537
37538
37539 static PyObject *_wrap_wxControl_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37540 PyObject *resultobj;
37541 wxControl *arg1 = (wxControl *) 0 ;
37542 wxString result;
37543 PyObject * obj0 = 0 ;
37544 char *kwnames[] = {
37545 (char *) "self", NULL
37546 };
37547
37548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxControl_GetLabel",kwnames,&obj0)) goto fail;
37549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37550 if (SWIG_arg_fail(1)) SWIG_fail;
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 result = (arg1)->GetLabel();
37554
37555 wxPyEndAllowThreads(__tstate);
37556 if (PyErr_Occurred()) SWIG_fail;
37557 }
37558 {
37559 #if wxUSE_UNICODE
37560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37561 #else
37562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37563 #endif
37564 }
37565 return resultobj;
37566 fail:
37567 return NULL;
37568 }
37569
37570
37571 static PyObject *_wrap_wxControl_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37572 PyObject *resultobj;
37573 wxControl *arg1 = (wxControl *) 0 ;
37574 wxString *arg2 = 0 ;
37575 bool temp2 = false ;
37576 PyObject * obj0 = 0 ;
37577 PyObject * obj1 = 0 ;
37578 char *kwnames[] = {
37579 (char *) "self",(char *) "label", NULL
37580 };
37581
37582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxControl_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37584 if (SWIG_arg_fail(1)) SWIG_fail;
37585 {
37586 arg2 = wxString_in_helper(obj1);
37587 if (arg2 == NULL) SWIG_fail;
37588 temp2 = true;
37589 }
37590 {
37591 PyThreadState* __tstate = wxPyBeginAllowThreads();
37592 (arg1)->SetLabel((wxString const &)*arg2);
37593
37594 wxPyEndAllowThreads(__tstate);
37595 if (PyErr_Occurred()) SWIG_fail;
37596 }
37597 Py_INCREF(Py_None); resultobj = Py_None;
37598 {
37599 if (temp2)
37600 delete arg2;
37601 }
37602 return resultobj;
37603 fail:
37604 {
37605 if (temp2)
37606 delete arg2;
37607 }
37608 return NULL;
37609 }
37610
37611
37612 static PyObject *_wrap_wxControl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37613 PyObject *resultobj;
37614 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37615 wxVisualAttributes result;
37616 PyObject * obj0 = 0 ;
37617 char *kwnames[] = {
37618 (char *) "variant", NULL
37619 };
37620
37621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:wxControl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37622 if (obj0) {
37623 {
37624 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37625 if (SWIG_arg_fail(1)) SWIG_fail;
37626 }
37627 }
37628 {
37629 if (!wxPyCheckForApp()) SWIG_fail;
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37632
37633 wxPyEndAllowThreads(__tstate);
37634 if (PyErr_Occurred()) SWIG_fail;
37635 }
37636 {
37637 wxVisualAttributes * resultptr;
37638 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37640 }
37641 return resultobj;
37642 fail:
37643 return NULL;
37644 }
37645
37646
37647 static PyObject * wxControl_swigregister(PyObject *, PyObject *args) {
37648 PyObject *obj;
37649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37650 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37651 Py_INCREF(obj);
37652 return Py_BuildValue((char *)"");
37653 }
37654 static PyObject *_wrap_wxItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37655 PyObject *resultobj;
37656 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37657 wxString *arg2 = 0 ;
37658 PyObject *arg3 = (PyObject *) NULL ;
37659 int result;
37660 bool temp2 = false ;
37661 PyObject * obj0 = 0 ;
37662 PyObject * obj1 = 0 ;
37663 PyObject * obj2 = 0 ;
37664 char *kwnames[] = {
37665 (char *) "self",(char *) "item",(char *) "clientData", NULL
37666 };
37667
37668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37670 if (SWIG_arg_fail(1)) SWIG_fail;
37671 {
37672 arg2 = wxString_in_helper(obj1);
37673 if (arg2 == NULL) SWIG_fail;
37674 temp2 = true;
37675 }
37676 if (obj2) {
37677 arg3 = obj2;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 resultobj = SWIG_From_int((int)(result));
37688 }
37689 {
37690 if (temp2)
37691 delete arg2;
37692 }
37693 return resultobj;
37694 fail:
37695 {
37696 if (temp2)
37697 delete arg2;
37698 }
37699 return NULL;
37700 }
37701
37702
37703 static PyObject *_wrap_wxItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37704 PyObject *resultobj;
37705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37706 wxArrayString *arg2 = 0 ;
37707 bool temp2 = false ;
37708 PyObject * obj0 = 0 ;
37709 PyObject * obj1 = 0 ;
37710 char *kwnames[] = {
37711 (char *) "self",(char *) "strings", NULL
37712 };
37713
37714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37716 if (SWIG_arg_fail(1)) SWIG_fail;
37717 {
37718 if (! PySequence_Check(obj1)) {
37719 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37720 SWIG_fail;
37721 }
37722 arg2 = new wxArrayString;
37723 temp2 = true;
37724 int i, len=PySequence_Length(obj1);
37725 for (i=0; i<len; i++) {
37726 PyObject* item = PySequence_GetItem(obj1, i);
37727 #if wxUSE_UNICODE
37728 PyObject* str = PyObject_Unicode(item);
37729 #else
37730 PyObject* str = PyObject_Str(item);
37731 #endif
37732 if (PyErr_Occurred()) SWIG_fail;
37733 arg2->Add(Py2wxString(str));
37734 Py_DECREF(item);
37735 Py_DECREF(str);
37736 }
37737 }
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 (arg1)->Append((wxArrayString const &)*arg2);
37741
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 Py_INCREF(Py_None); resultobj = Py_None;
37746 {
37747 if (temp2) delete arg2;
37748 }
37749 return resultobj;
37750 fail:
37751 {
37752 if (temp2) delete arg2;
37753 }
37754 return NULL;
37755 }
37756
37757
37758 static PyObject *_wrap_wxItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37759 PyObject *resultobj;
37760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37761 wxString *arg2 = 0 ;
37762 int arg3 ;
37763 PyObject *arg4 = (PyObject *) NULL ;
37764 int result;
37765 bool temp2 = false ;
37766 PyObject * obj0 = 0 ;
37767 PyObject * obj1 = 0 ;
37768 PyObject * obj2 = 0 ;
37769 PyObject * obj3 = 0 ;
37770 char *kwnames[] = {
37771 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37772 };
37773
37774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37776 if (SWIG_arg_fail(1)) SWIG_fail;
37777 {
37778 arg2 = wxString_in_helper(obj1);
37779 if (arg2 == NULL) SWIG_fail;
37780 temp2 = true;
37781 }
37782 {
37783 arg3 = (int)(SWIG_As_int(obj2));
37784 if (SWIG_arg_fail(3)) SWIG_fail;
37785 }
37786 if (obj3) {
37787 arg4 = obj3;
37788 }
37789 {
37790 PyThreadState* __tstate = wxPyBeginAllowThreads();
37791 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37792
37793 wxPyEndAllowThreads(__tstate);
37794 if (PyErr_Occurred()) SWIG_fail;
37795 }
37796 {
37797 resultobj = SWIG_From_int((int)(result));
37798 }
37799 {
37800 if (temp2)
37801 delete arg2;
37802 }
37803 return resultobj;
37804 fail:
37805 {
37806 if (temp2)
37807 delete arg2;
37808 }
37809 return NULL;
37810 }
37811
37812
37813 static PyObject *_wrap_wxItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37814 PyObject *resultobj;
37815 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37816 PyObject * obj0 = 0 ;
37817 char *kwnames[] = {
37818 (char *) "self", NULL
37819 };
37820
37821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxItemContainer_Clear",kwnames,&obj0)) goto fail;
37822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37823 if (SWIG_arg_fail(1)) SWIG_fail;
37824 {
37825 PyThreadState* __tstate = wxPyBeginAllowThreads();
37826 (arg1)->Clear();
37827
37828 wxPyEndAllowThreads(__tstate);
37829 if (PyErr_Occurred()) SWIG_fail;
37830 }
37831 Py_INCREF(Py_None); resultobj = Py_None;
37832 return resultobj;
37833 fail:
37834 return NULL;
37835 }
37836
37837
37838 static PyObject *_wrap_wxItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37839 PyObject *resultobj;
37840 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37841 int arg2 ;
37842 PyObject * obj0 = 0 ;
37843 PyObject * obj1 = 0 ;
37844 char *kwnames[] = {
37845 (char *) "self",(char *) "n", NULL
37846 };
37847
37848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37850 if (SWIG_arg_fail(1)) SWIG_fail;
37851 {
37852 arg2 = (int)(SWIG_As_int(obj1));
37853 if (SWIG_arg_fail(2)) SWIG_fail;
37854 }
37855 {
37856 PyThreadState* __tstate = wxPyBeginAllowThreads();
37857 (arg1)->Delete(arg2);
37858
37859 wxPyEndAllowThreads(__tstate);
37860 if (PyErr_Occurred()) SWIG_fail;
37861 }
37862 Py_INCREF(Py_None); resultobj = Py_None;
37863 return resultobj;
37864 fail:
37865 return NULL;
37866 }
37867
37868
37869 static PyObject *_wrap_wxItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37870 PyObject *resultobj;
37871 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37872 int arg2 ;
37873 PyObject *result;
37874 PyObject * obj0 = 0 ;
37875 PyObject * obj1 = 0 ;
37876 char *kwnames[] = {
37877 (char *) "self",(char *) "n", NULL
37878 };
37879
37880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37882 if (SWIG_arg_fail(1)) SWIG_fail;
37883 {
37884 arg2 = (int)(SWIG_As_int(obj1));
37885 if (SWIG_arg_fail(2)) SWIG_fail;
37886 }
37887 {
37888 PyThreadState* __tstate = wxPyBeginAllowThreads();
37889 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37890
37891 wxPyEndAllowThreads(__tstate);
37892 if (PyErr_Occurred()) SWIG_fail;
37893 }
37894 resultobj = result;
37895 return resultobj;
37896 fail:
37897 return NULL;
37898 }
37899
37900
37901 static PyObject *_wrap_wxItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37902 PyObject *resultobj;
37903 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37904 int arg2 ;
37905 PyObject *arg3 = (PyObject *) 0 ;
37906 PyObject * obj0 = 0 ;
37907 PyObject * obj1 = 0 ;
37908 PyObject * obj2 = 0 ;
37909 char *kwnames[] = {
37910 (char *) "self",(char *) "n",(char *) "clientData", NULL
37911 };
37912
37913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37915 if (SWIG_arg_fail(1)) SWIG_fail;
37916 {
37917 arg2 = (int)(SWIG_As_int(obj1));
37918 if (SWIG_arg_fail(2)) SWIG_fail;
37919 }
37920 arg3 = obj2;
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 wxItemContainer_SetClientData(arg1,arg2,arg3);
37924
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 Py_INCREF(Py_None); resultobj = Py_None;
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 static PyObject *_wrap_wxItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37936 PyObject *resultobj;
37937 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37938 int result;
37939 PyObject * obj0 = 0 ;
37940 char *kwnames[] = {
37941 (char *) "self", NULL
37942 };
37943
37944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxItemContainer_GetCount",kwnames,&obj0)) goto fail;
37945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37946 if (SWIG_arg_fail(1)) SWIG_fail;
37947 {
37948 PyThreadState* __tstate = wxPyBeginAllowThreads();
37949 result = (int)((wxItemContainer const *)arg1)->GetCount();
37950
37951 wxPyEndAllowThreads(__tstate);
37952 if (PyErr_Occurred()) SWIG_fail;
37953 }
37954 {
37955 resultobj = SWIG_From_int((int)(result));
37956 }
37957 return resultobj;
37958 fail:
37959 return NULL;
37960 }
37961
37962
37963 static PyObject *_wrap_wxItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj;
37965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37966 bool result;
37967 PyObject * obj0 = 0 ;
37968 char *kwnames[] = {
37969 (char *) "self", NULL
37970 };
37971
37972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37974 if (SWIG_arg_fail(1)) SWIG_fail;
37975 {
37976 PyThreadState* __tstate = wxPyBeginAllowThreads();
37977 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37978
37979 wxPyEndAllowThreads(__tstate);
37980 if (PyErr_Occurred()) SWIG_fail;
37981 }
37982 {
37983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37984 }
37985 return resultobj;
37986 fail:
37987 return NULL;
37988 }
37989
37990
37991 static PyObject *_wrap_wxItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37992 PyObject *resultobj;
37993 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37994 int arg2 ;
37995 wxString result;
37996 PyObject * obj0 = 0 ;
37997 PyObject * obj1 = 0 ;
37998 char *kwnames[] = {
37999 (char *) "self",(char *) "n", NULL
38000 };
38001
38002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38004 if (SWIG_arg_fail(1)) SWIG_fail;
38005 {
38006 arg2 = (int)(SWIG_As_int(obj1));
38007 if (SWIG_arg_fail(2)) SWIG_fail;
38008 }
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38012
38013 wxPyEndAllowThreads(__tstate);
38014 if (PyErr_Occurred()) SWIG_fail;
38015 }
38016 {
38017 #if wxUSE_UNICODE
38018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38019 #else
38020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38021 #endif
38022 }
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 static PyObject *_wrap_wxItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj;
38031 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38032 wxArrayString result;
38033 PyObject * obj0 = 0 ;
38034 char *kwnames[] = {
38035 (char *) "self", NULL
38036 };
38037
38038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38040 if (SWIG_arg_fail(1)) SWIG_fail;
38041 {
38042 PyThreadState* __tstate = wxPyBeginAllowThreads();
38043 result = ((wxItemContainer const *)arg1)->GetStrings();
38044
38045 wxPyEndAllowThreads(__tstate);
38046 if (PyErr_Occurred()) SWIG_fail;
38047 }
38048 {
38049 resultobj = wxArrayString2PyList_helper(result);
38050 }
38051 return resultobj;
38052 fail:
38053 return NULL;
38054 }
38055
38056
38057 static PyObject *_wrap_wxItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38058 PyObject *resultobj;
38059 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38060 int arg2 ;
38061 wxString *arg3 = 0 ;
38062 bool temp3 = false ;
38063 PyObject * obj0 = 0 ;
38064 PyObject * obj1 = 0 ;
38065 PyObject * obj2 = 0 ;
38066 char *kwnames[] = {
38067 (char *) "self",(char *) "n",(char *) "s", NULL
38068 };
38069
38070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38072 if (SWIG_arg_fail(1)) SWIG_fail;
38073 {
38074 arg2 = (int)(SWIG_As_int(obj1));
38075 if (SWIG_arg_fail(2)) SWIG_fail;
38076 }
38077 {
38078 arg3 = wxString_in_helper(obj2);
38079 if (arg3 == NULL) SWIG_fail;
38080 temp3 = true;
38081 }
38082 {
38083 PyThreadState* __tstate = wxPyBeginAllowThreads();
38084 (arg1)->SetString(arg2,(wxString const &)*arg3);
38085
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 Py_INCREF(Py_None); resultobj = Py_None;
38090 {
38091 if (temp3)
38092 delete arg3;
38093 }
38094 return resultobj;
38095 fail:
38096 {
38097 if (temp3)
38098 delete arg3;
38099 }
38100 return NULL;
38101 }
38102
38103
38104 static PyObject *_wrap_wxItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj;
38106 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38107 wxString *arg2 = 0 ;
38108 int result;
38109 bool temp2 = false ;
38110 PyObject * obj0 = 0 ;
38111 PyObject * obj1 = 0 ;
38112 char *kwnames[] = {
38113 (char *) "self",(char *) "s", NULL
38114 };
38115
38116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38118 if (SWIG_arg_fail(1)) SWIG_fail;
38119 {
38120 arg2 = wxString_in_helper(obj1);
38121 if (arg2 == NULL) SWIG_fail;
38122 temp2 = true;
38123 }
38124 {
38125 PyThreadState* __tstate = wxPyBeginAllowThreads();
38126 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38127
38128 wxPyEndAllowThreads(__tstate);
38129 if (PyErr_Occurred()) SWIG_fail;
38130 }
38131 {
38132 resultobj = SWIG_From_int((int)(result));
38133 }
38134 {
38135 if (temp2)
38136 delete arg2;
38137 }
38138 return resultobj;
38139 fail:
38140 {
38141 if (temp2)
38142 delete arg2;
38143 }
38144 return NULL;
38145 }
38146
38147
38148 static PyObject *_wrap_wxItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38149 PyObject *resultobj;
38150 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38151 int arg2 ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 char *kwnames[] = {
38155 (char *) "self",(char *) "n", NULL
38156 };
38157
38158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38160 if (SWIG_arg_fail(1)) SWIG_fail;
38161 {
38162 arg2 = (int)(SWIG_As_int(obj1));
38163 if (SWIG_arg_fail(2)) SWIG_fail;
38164 }
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 (arg1)->SetSelection(arg2);
38168
38169 wxPyEndAllowThreads(__tstate);
38170 if (PyErr_Occurred()) SWIG_fail;
38171 }
38172 Py_INCREF(Py_None); resultobj = Py_None;
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 static PyObject *_wrap_wxItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38180 PyObject *resultobj;
38181 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38182 int result;
38183 PyObject * obj0 = 0 ;
38184 char *kwnames[] = {
38185 (char *) "self", NULL
38186 };
38187
38188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38190 if (SWIG_arg_fail(1)) SWIG_fail;
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38194
38195 wxPyEndAllowThreads(__tstate);
38196 if (PyErr_Occurred()) SWIG_fail;
38197 }
38198 {
38199 resultobj = SWIG_From_int((int)(result));
38200 }
38201 return resultobj;
38202 fail:
38203 return NULL;
38204 }
38205
38206
38207 static PyObject *_wrap_wxItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj;
38209 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38210 wxString *arg2 = 0 ;
38211 bool result;
38212 bool temp2 = false ;
38213 PyObject * obj0 = 0 ;
38214 PyObject * obj1 = 0 ;
38215 char *kwnames[] = {
38216 (char *) "self",(char *) "s", NULL
38217 };
38218
38219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38221 if (SWIG_arg_fail(1)) SWIG_fail;
38222 {
38223 arg2 = wxString_in_helper(obj1);
38224 if (arg2 == NULL) SWIG_fail;
38225 temp2 = true;
38226 }
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 {
38235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38236 }
38237 {
38238 if (temp2)
38239 delete arg2;
38240 }
38241 return resultobj;
38242 fail:
38243 {
38244 if (temp2)
38245 delete arg2;
38246 }
38247 return NULL;
38248 }
38249
38250
38251 static PyObject *_wrap_wxItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38252 PyObject *resultobj;
38253 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38254 wxString result;
38255 PyObject * obj0 = 0 ;
38256 char *kwnames[] = {
38257 (char *) "self", NULL
38258 };
38259
38260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38262 if (SWIG_arg_fail(1)) SWIG_fail;
38263 {
38264 PyThreadState* __tstate = wxPyBeginAllowThreads();
38265 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38266
38267 wxPyEndAllowThreads(__tstate);
38268 if (PyErr_Occurred()) SWIG_fail;
38269 }
38270 {
38271 #if wxUSE_UNICODE
38272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38273 #else
38274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38275 #endif
38276 }
38277 return resultobj;
38278 fail:
38279 return NULL;
38280 }
38281
38282
38283 static PyObject *_wrap_wxItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38284 PyObject *resultobj;
38285 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38286 int arg2 ;
38287 PyObject * obj0 = 0 ;
38288 PyObject * obj1 = 0 ;
38289 char *kwnames[] = {
38290 (char *) "self",(char *) "n", NULL
38291 };
38292
38293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38295 if (SWIG_arg_fail(1)) SWIG_fail;
38296 {
38297 arg2 = (int)(SWIG_As_int(obj1));
38298 if (SWIG_arg_fail(2)) SWIG_fail;
38299 }
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 (arg1)->Select(arg2);
38303
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 Py_INCREF(Py_None); resultobj = Py_None;
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 static PyObject * wxItemContainer_swigregister(PyObject *, PyObject *args) {
38315 PyObject *obj;
38316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38317 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38318 Py_INCREF(obj);
38319 return Py_BuildValue((char *)"");
38320 }
38321 static PyObject * wxControlWithItems_swigregister(PyObject *, PyObject *args) {
38322 PyObject *obj;
38323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38324 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38325 Py_INCREF(obj);
38326 return Py_BuildValue((char *)"");
38327 }
38328 static PyObject *_wrap_new_wxSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38329 PyObject *resultobj;
38330 wxSizerItem *result;
38331 char *kwnames[] = {
38332 NULL
38333 };
38334
38335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxSizerItem",kwnames)) goto fail;
38336 {
38337 PyThreadState* __tstate = wxPyBeginAllowThreads();
38338 result = (wxSizerItem *)new wxSizerItem();
38339
38340 wxPyEndAllowThreads(__tstate);
38341 if (PyErr_Occurred()) SWIG_fail;
38342 }
38343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38344 return resultobj;
38345 fail:
38346 return NULL;
38347 }
38348
38349
38350 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38351 PyObject *resultobj;
38352 wxWindow *arg1 = (wxWindow *) 0 ;
38353 int arg2 ;
38354 int arg3 ;
38355 int arg4 ;
38356 PyObject *arg5 = (PyObject *) NULL ;
38357 wxSizerItem *result;
38358 PyObject * obj0 = 0 ;
38359 PyObject * obj1 = 0 ;
38360 PyObject * obj2 = 0 ;
38361 PyObject * obj3 = 0 ;
38362 PyObject * obj4 = 0 ;
38363 char *kwnames[] = {
38364 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38365 };
38366
38367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38369 if (SWIG_arg_fail(1)) SWIG_fail;
38370 {
38371 arg2 = (int)(SWIG_As_int(obj1));
38372 if (SWIG_arg_fail(2)) SWIG_fail;
38373 }
38374 {
38375 arg3 = (int)(SWIG_As_int(obj2));
38376 if (SWIG_arg_fail(3)) SWIG_fail;
38377 }
38378 {
38379 arg4 = (int)(SWIG_As_int(obj3));
38380 if (SWIG_arg_fail(4)) SWIG_fail;
38381 }
38382 if (obj4) {
38383 arg5 = obj4;
38384 }
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38388
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38393 return resultobj;
38394 fail:
38395 return NULL;
38396 }
38397
38398
38399 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38400 PyObject *resultobj;
38401 int arg1 ;
38402 int arg2 ;
38403 int arg3 ;
38404 int arg4 ;
38405 int arg5 ;
38406 PyObject *arg6 = (PyObject *) NULL ;
38407 wxSizerItem *result;
38408 PyObject * obj0 = 0 ;
38409 PyObject * obj1 = 0 ;
38410 PyObject * obj2 = 0 ;
38411 PyObject * obj3 = 0 ;
38412 PyObject * obj4 = 0 ;
38413 PyObject * obj5 = 0 ;
38414 char *kwnames[] = {
38415 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38416 };
38417
38418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38419 {
38420 arg1 = (int)(SWIG_As_int(obj0));
38421 if (SWIG_arg_fail(1)) SWIG_fail;
38422 }
38423 {
38424 arg2 = (int)(SWIG_As_int(obj1));
38425 if (SWIG_arg_fail(2)) SWIG_fail;
38426 }
38427 {
38428 arg3 = (int)(SWIG_As_int(obj2));
38429 if (SWIG_arg_fail(3)) SWIG_fail;
38430 }
38431 {
38432 arg4 = (int)(SWIG_As_int(obj3));
38433 if (SWIG_arg_fail(4)) SWIG_fail;
38434 }
38435 {
38436 arg5 = (int)(SWIG_As_int(obj4));
38437 if (SWIG_arg_fail(5)) SWIG_fail;
38438 }
38439 if (obj5) {
38440 arg6 = obj5;
38441 }
38442 {
38443 PyThreadState* __tstate = wxPyBeginAllowThreads();
38444 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38445
38446 wxPyEndAllowThreads(__tstate);
38447 if (PyErr_Occurred()) SWIG_fail;
38448 }
38449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38450 return resultobj;
38451 fail:
38452 return NULL;
38453 }
38454
38455
38456 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38457 PyObject *resultobj;
38458 wxSizer *arg1 = (wxSizer *) 0 ;
38459 int arg2 ;
38460 int arg3 ;
38461 int arg4 ;
38462 PyObject *arg5 = (PyObject *) NULL ;
38463 wxSizerItem *result;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 PyObject * obj2 = 0 ;
38467 PyObject * obj3 = 0 ;
38468 PyObject * obj4 = 0 ;
38469 char *kwnames[] = {
38470 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38471 };
38472
38473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38475 if (SWIG_arg_fail(1)) SWIG_fail;
38476 {
38477 arg2 = (int)(SWIG_As_int(obj1));
38478 if (SWIG_arg_fail(2)) SWIG_fail;
38479 }
38480 {
38481 arg3 = (int)(SWIG_As_int(obj2));
38482 if (SWIG_arg_fail(3)) SWIG_fail;
38483 }
38484 {
38485 arg4 = (int)(SWIG_As_int(obj3));
38486 if (SWIG_arg_fail(4)) SWIG_fail;
38487 }
38488 if (obj4) {
38489 arg5 = obj4;
38490 }
38491 {
38492 PyThreadState* __tstate = wxPyBeginAllowThreads();
38493 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38494
38495 wxPyEndAllowThreads(__tstate);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 }
38498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38499 return resultobj;
38500 fail:
38501 return NULL;
38502 }
38503
38504
38505 static PyObject *_wrap_wxSizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38506 PyObject *resultobj;
38507 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38508 PyObject * obj0 = 0 ;
38509 char *kwnames[] = {
38510 (char *) "self", NULL
38511 };
38512
38513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38515 if (SWIG_arg_fail(1)) SWIG_fail;
38516 {
38517 PyThreadState* __tstate = wxPyBeginAllowThreads();
38518 (arg1)->DeleteWindows();
38519
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 Py_INCREF(Py_None); resultobj = Py_None;
38524 return resultobj;
38525 fail:
38526 return NULL;
38527 }
38528
38529
38530 static PyObject *_wrap_wxSizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38531 PyObject *resultobj;
38532 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38533 PyObject * obj0 = 0 ;
38534 char *kwnames[] = {
38535 (char *) "self", NULL
38536 };
38537
38538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38540 if (SWIG_arg_fail(1)) SWIG_fail;
38541 {
38542 PyThreadState* __tstate = wxPyBeginAllowThreads();
38543 (arg1)->DetachSizer();
38544
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 Py_INCREF(Py_None); resultobj = Py_None;
38549 return resultobj;
38550 fail:
38551 return NULL;
38552 }
38553
38554
38555 static PyObject *_wrap_wxSizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38556 PyObject *resultobj;
38557 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38558 wxSize result;
38559 PyObject * obj0 = 0 ;
38560 char *kwnames[] = {
38561 (char *) "self", NULL
38562 };
38563
38564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetSize",kwnames,&obj0)) goto fail;
38565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38566 if (SWIG_arg_fail(1)) SWIG_fail;
38567 {
38568 PyThreadState* __tstate = wxPyBeginAllowThreads();
38569 result = (arg1)->GetSize();
38570
38571 wxPyEndAllowThreads(__tstate);
38572 if (PyErr_Occurred()) SWIG_fail;
38573 }
38574 {
38575 wxSize * resultptr;
38576 resultptr = new wxSize((wxSize &)(result));
38577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38578 }
38579 return resultobj;
38580 fail:
38581 return NULL;
38582 }
38583
38584
38585 static PyObject *_wrap_wxSizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38586 PyObject *resultobj;
38587 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38588 wxSize result;
38589 PyObject * obj0 = 0 ;
38590 char *kwnames[] = {
38591 (char *) "self", NULL
38592 };
38593
38594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_CalcMin",kwnames,&obj0)) goto fail;
38595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38596 if (SWIG_arg_fail(1)) SWIG_fail;
38597 {
38598 PyThreadState* __tstate = wxPyBeginAllowThreads();
38599 result = (arg1)->CalcMin();
38600
38601 wxPyEndAllowThreads(__tstate);
38602 if (PyErr_Occurred()) SWIG_fail;
38603 }
38604 {
38605 wxSize * resultptr;
38606 resultptr = new wxSize((wxSize &)(result));
38607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38608 }
38609 return resultobj;
38610 fail:
38611 return NULL;
38612 }
38613
38614
38615 static PyObject *_wrap_wxSizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38616 PyObject *resultobj;
38617 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38618 wxPoint arg2 ;
38619 wxSize arg3 ;
38620 PyObject * obj0 = 0 ;
38621 PyObject * obj1 = 0 ;
38622 PyObject * obj2 = 0 ;
38623 char *kwnames[] = {
38624 (char *) "self",(char *) "pos",(char *) "size", NULL
38625 };
38626
38627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxSizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38629 if (SWIG_arg_fail(1)) SWIG_fail;
38630 {
38631 wxPoint * argp;
38632 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38633 if (SWIG_arg_fail(2)) SWIG_fail;
38634 if (argp == NULL) {
38635 SWIG_null_ref("wxPoint");
38636 }
38637 if (SWIG_arg_fail(2)) SWIG_fail;
38638 arg2 = *argp;
38639 }
38640 {
38641 wxSize * argp;
38642 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38643 if (SWIG_arg_fail(3)) SWIG_fail;
38644 if (argp == NULL) {
38645 SWIG_null_ref("wxSize");
38646 }
38647 if (SWIG_arg_fail(3)) SWIG_fail;
38648 arg3 = *argp;
38649 }
38650 {
38651 PyThreadState* __tstate = wxPyBeginAllowThreads();
38652 (arg1)->SetDimension(arg2,arg3);
38653
38654 wxPyEndAllowThreads(__tstate);
38655 if (PyErr_Occurred()) SWIG_fail;
38656 }
38657 Py_INCREF(Py_None); resultobj = Py_None;
38658 return resultobj;
38659 fail:
38660 return NULL;
38661 }
38662
38663
38664 static PyObject *_wrap_wxSizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38665 PyObject *resultobj;
38666 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38667 wxSize result;
38668 PyObject * obj0 = 0 ;
38669 char *kwnames[] = {
38670 (char *) "self", NULL
38671 };
38672
38673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38675 if (SWIG_arg_fail(1)) SWIG_fail;
38676 {
38677 PyThreadState* __tstate = wxPyBeginAllowThreads();
38678 result = (arg1)->GetMinSize();
38679
38680 wxPyEndAllowThreads(__tstate);
38681 if (PyErr_Occurred()) SWIG_fail;
38682 }
38683 {
38684 wxSize * resultptr;
38685 resultptr = new wxSize((wxSize &)(result));
38686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38687 }
38688 return resultobj;
38689 fail:
38690 return NULL;
38691 }
38692
38693
38694 static PyObject *_wrap_wxSizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38695 PyObject *resultobj;
38696 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38697 wxSize result;
38698 PyObject * obj0 = 0 ;
38699 char *kwnames[] = {
38700 (char *) "self", NULL
38701 };
38702
38703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38705 if (SWIG_arg_fail(1)) SWIG_fail;
38706 {
38707 PyThreadState* __tstate = wxPyBeginAllowThreads();
38708 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38709
38710 wxPyEndAllowThreads(__tstate);
38711 if (PyErr_Occurred()) SWIG_fail;
38712 }
38713 {
38714 wxSize * resultptr;
38715 resultptr = new wxSize((wxSize &)(result));
38716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38717 }
38718 return resultobj;
38719 fail:
38720 return NULL;
38721 }
38722
38723
38724 static PyObject *_wrap_wxSizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38725 PyObject *resultobj;
38726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38727 int arg2 ;
38728 int arg3 ;
38729 PyObject * obj0 = 0 ;
38730 PyObject * obj1 = 0 ;
38731 PyObject * obj2 = 0 ;
38732 char *kwnames[] = {
38733 (char *) "self",(char *) "x",(char *) "y", NULL
38734 };
38735
38736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxSizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38738 if (SWIG_arg_fail(1)) SWIG_fail;
38739 {
38740 arg2 = (int)(SWIG_As_int(obj1));
38741 if (SWIG_arg_fail(2)) SWIG_fail;
38742 }
38743 {
38744 arg3 = (int)(SWIG_As_int(obj2));
38745 if (SWIG_arg_fail(3)) SWIG_fail;
38746 }
38747 {
38748 PyThreadState* __tstate = wxPyBeginAllowThreads();
38749 (arg1)->SetInitSize(arg2,arg3);
38750
38751 wxPyEndAllowThreads(__tstate);
38752 if (PyErr_Occurred()) SWIG_fail;
38753 }
38754 Py_INCREF(Py_None); resultobj = Py_None;
38755 return resultobj;
38756 fail:
38757 return NULL;
38758 }
38759
38760
38761 static PyObject *_wrap_wxSizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38762 PyObject *resultobj;
38763 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38764 int arg2 ;
38765 int arg3 ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 PyObject * obj2 = 0 ;
38769 char *kwnames[] = {
38770 (char *) "self",(char *) "width",(char *) "height", NULL
38771 };
38772
38773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxSizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38775 if (SWIG_arg_fail(1)) SWIG_fail;
38776 {
38777 arg2 = (int)(SWIG_As_int(obj1));
38778 if (SWIG_arg_fail(2)) SWIG_fail;
38779 }
38780 {
38781 arg3 = (int)(SWIG_As_int(obj2));
38782 if (SWIG_arg_fail(3)) SWIG_fail;
38783 }
38784 {
38785 PyThreadState* __tstate = wxPyBeginAllowThreads();
38786 (arg1)->SetRatio(arg2,arg3);
38787
38788 wxPyEndAllowThreads(__tstate);
38789 if (PyErr_Occurred()) SWIG_fail;
38790 }
38791 Py_INCREF(Py_None); resultobj = Py_None;
38792 return resultobj;
38793 fail:
38794 return NULL;
38795 }
38796
38797
38798 static PyObject *_wrap_wxSizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38799 PyObject *resultobj;
38800 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38801 wxSize *arg2 = 0 ;
38802 wxSize temp2 ;
38803 PyObject * obj0 = 0 ;
38804 PyObject * obj1 = 0 ;
38805 char *kwnames[] = {
38806 (char *) "self",(char *) "size", NULL
38807 };
38808
38809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38811 if (SWIG_arg_fail(1)) SWIG_fail;
38812 {
38813 arg2 = &temp2;
38814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38815 }
38816 {
38817 PyThreadState* __tstate = wxPyBeginAllowThreads();
38818 (arg1)->SetRatio((wxSize const &)*arg2);
38819
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 Py_INCREF(Py_None); resultobj = Py_None;
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 static PyObject *_wrap_wxSizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj;
38832 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38833 float arg2 ;
38834 PyObject * obj0 = 0 ;
38835 PyObject * obj1 = 0 ;
38836 char *kwnames[] = {
38837 (char *) "self",(char *) "ratio", NULL
38838 };
38839
38840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38842 if (SWIG_arg_fail(1)) SWIG_fail;
38843 {
38844 arg2 = (float)(SWIG_As_float(obj1));
38845 if (SWIG_arg_fail(2)) SWIG_fail;
38846 }
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 (arg1)->SetRatio(arg2);
38850
38851 wxPyEndAllowThreads(__tstate);
38852 if (PyErr_Occurred()) SWIG_fail;
38853 }
38854 Py_INCREF(Py_None); resultobj = Py_None;
38855 return resultobj;
38856 fail:
38857 return NULL;
38858 }
38859
38860
38861 static PyObject *_wrap_wxSizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38862 PyObject *resultobj;
38863 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38864 float result;
38865 PyObject * obj0 = 0 ;
38866 char *kwnames[] = {
38867 (char *) "self", NULL
38868 };
38869
38870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetRatio",kwnames,&obj0)) goto fail;
38871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38872 if (SWIG_arg_fail(1)) SWIG_fail;
38873 {
38874 PyThreadState* __tstate = wxPyBeginAllowThreads();
38875 result = (float)(arg1)->GetRatio();
38876
38877 wxPyEndAllowThreads(__tstate);
38878 if (PyErr_Occurred()) SWIG_fail;
38879 }
38880 {
38881 resultobj = SWIG_From_float((float)(result));
38882 }
38883 return resultobj;
38884 fail:
38885 return NULL;
38886 }
38887
38888
38889 static PyObject *_wrap_wxSizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38890 PyObject *resultobj;
38891 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38892 wxRect result;
38893 PyObject * obj0 = 0 ;
38894 char *kwnames[] = {
38895 (char *) "self", NULL
38896 };
38897
38898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetRect",kwnames,&obj0)) goto fail;
38899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38900 if (SWIG_arg_fail(1)) SWIG_fail;
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 result = (arg1)->GetRect();
38904
38905 wxPyEndAllowThreads(__tstate);
38906 if (PyErr_Occurred()) SWIG_fail;
38907 }
38908 {
38909 wxRect * resultptr;
38910 resultptr = new wxRect((wxRect &)(result));
38911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38912 }
38913 return resultobj;
38914 fail:
38915 return NULL;
38916 }
38917
38918
38919 static PyObject *_wrap_wxSizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38920 PyObject *resultobj;
38921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38922 bool result;
38923 PyObject * obj0 = 0 ;
38924 char *kwnames[] = {
38925 (char *) "self", NULL
38926 };
38927
38928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_IsWindow",kwnames,&obj0)) goto fail;
38929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38930 if (SWIG_arg_fail(1)) SWIG_fail;
38931 {
38932 PyThreadState* __tstate = wxPyBeginAllowThreads();
38933 result = (bool)(arg1)->IsWindow();
38934
38935 wxPyEndAllowThreads(__tstate);
38936 if (PyErr_Occurred()) SWIG_fail;
38937 }
38938 {
38939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38940 }
38941 return resultobj;
38942 fail:
38943 return NULL;
38944 }
38945
38946
38947 static PyObject *_wrap_wxSizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38948 PyObject *resultobj;
38949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38950 bool result;
38951 PyObject * obj0 = 0 ;
38952 char *kwnames[] = {
38953 (char *) "self", NULL
38954 };
38955
38956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_IsSizer",kwnames,&obj0)) goto fail;
38957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38958 if (SWIG_arg_fail(1)) SWIG_fail;
38959 {
38960 PyThreadState* __tstate = wxPyBeginAllowThreads();
38961 result = (bool)(arg1)->IsSizer();
38962
38963 wxPyEndAllowThreads(__tstate);
38964 if (PyErr_Occurred()) SWIG_fail;
38965 }
38966 {
38967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38968 }
38969 return resultobj;
38970 fail:
38971 return NULL;
38972 }
38973
38974
38975 static PyObject *_wrap_wxSizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38976 PyObject *resultobj;
38977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38978 bool result;
38979 PyObject * obj0 = 0 ;
38980 char *kwnames[] = {
38981 (char *) "self", NULL
38982 };
38983
38984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38986 if (SWIG_arg_fail(1)) SWIG_fail;
38987 {
38988 PyThreadState* __tstate = wxPyBeginAllowThreads();
38989 result = (bool)(arg1)->IsSpacer();
38990
38991 wxPyEndAllowThreads(__tstate);
38992 if (PyErr_Occurred()) SWIG_fail;
38993 }
38994 {
38995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38996 }
38997 return resultobj;
38998 fail:
38999 return NULL;
39000 }
39001
39002
39003 static PyObject *_wrap_wxSizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39004 PyObject *resultobj;
39005 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39006 int arg2 ;
39007 PyObject * obj0 = 0 ;
39008 PyObject * obj1 = 0 ;
39009 char *kwnames[] = {
39010 (char *) "self",(char *) "proportion", NULL
39011 };
39012
39013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39015 if (SWIG_arg_fail(1)) SWIG_fail;
39016 {
39017 arg2 = (int)(SWIG_As_int(obj1));
39018 if (SWIG_arg_fail(2)) SWIG_fail;
39019 }
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 (arg1)->SetProportion(arg2);
39023
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 Py_INCREF(Py_None); resultobj = Py_None;
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 static PyObject *_wrap_wxSizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj;
39036 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39037 int result;
39038 PyObject * obj0 = 0 ;
39039 char *kwnames[] = {
39040 (char *) "self", NULL
39041 };
39042
39043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetProportion",kwnames,&obj0)) goto fail;
39044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39045 if (SWIG_arg_fail(1)) SWIG_fail;
39046 {
39047 PyThreadState* __tstate = wxPyBeginAllowThreads();
39048 result = (int)(arg1)->GetProportion();
39049
39050 wxPyEndAllowThreads(__tstate);
39051 if (PyErr_Occurred()) SWIG_fail;
39052 }
39053 {
39054 resultobj = SWIG_From_int((int)(result));
39055 }
39056 return resultobj;
39057 fail:
39058 return NULL;
39059 }
39060
39061
39062 static PyObject *_wrap_wxSizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39063 PyObject *resultobj;
39064 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39065 int arg2 ;
39066 PyObject * obj0 = 0 ;
39067 PyObject * obj1 = 0 ;
39068 char *kwnames[] = {
39069 (char *) "self",(char *) "flag", NULL
39070 };
39071
39072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39074 if (SWIG_arg_fail(1)) SWIG_fail;
39075 {
39076 arg2 = (int)(SWIG_As_int(obj1));
39077 if (SWIG_arg_fail(2)) SWIG_fail;
39078 }
39079 {
39080 PyThreadState* __tstate = wxPyBeginAllowThreads();
39081 (arg1)->SetFlag(arg2);
39082
39083 wxPyEndAllowThreads(__tstate);
39084 if (PyErr_Occurred()) SWIG_fail;
39085 }
39086 Py_INCREF(Py_None); resultobj = Py_None;
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 static PyObject *_wrap_wxSizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39094 PyObject *resultobj;
39095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39096 int result;
39097 PyObject * obj0 = 0 ;
39098 char *kwnames[] = {
39099 (char *) "self", NULL
39100 };
39101
39102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetFlag",kwnames,&obj0)) goto fail;
39103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39104 if (SWIG_arg_fail(1)) SWIG_fail;
39105 {
39106 PyThreadState* __tstate = wxPyBeginAllowThreads();
39107 result = (int)(arg1)->GetFlag();
39108
39109 wxPyEndAllowThreads(__tstate);
39110 if (PyErr_Occurred()) SWIG_fail;
39111 }
39112 {
39113 resultobj = SWIG_From_int((int)(result));
39114 }
39115 return resultobj;
39116 fail:
39117 return NULL;
39118 }
39119
39120
39121 static PyObject *_wrap_wxSizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj;
39123 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39124 int arg2 ;
39125 PyObject * obj0 = 0 ;
39126 PyObject * obj1 = 0 ;
39127 char *kwnames[] = {
39128 (char *) "self",(char *) "border", NULL
39129 };
39130
39131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39133 if (SWIG_arg_fail(1)) SWIG_fail;
39134 {
39135 arg2 = (int)(SWIG_As_int(obj1));
39136 if (SWIG_arg_fail(2)) SWIG_fail;
39137 }
39138 {
39139 PyThreadState* __tstate = wxPyBeginAllowThreads();
39140 (arg1)->SetBorder(arg2);
39141
39142 wxPyEndAllowThreads(__tstate);
39143 if (PyErr_Occurred()) SWIG_fail;
39144 }
39145 Py_INCREF(Py_None); resultobj = Py_None;
39146 return resultobj;
39147 fail:
39148 return NULL;
39149 }
39150
39151
39152 static PyObject *_wrap_wxSizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39153 PyObject *resultobj;
39154 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39155 int result;
39156 PyObject * obj0 = 0 ;
39157 char *kwnames[] = {
39158 (char *) "self", NULL
39159 };
39160
39161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetBorder",kwnames,&obj0)) goto fail;
39162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39163 if (SWIG_arg_fail(1)) SWIG_fail;
39164 {
39165 PyThreadState* __tstate = wxPyBeginAllowThreads();
39166 result = (int)(arg1)->GetBorder();
39167
39168 wxPyEndAllowThreads(__tstate);
39169 if (PyErr_Occurred()) SWIG_fail;
39170 }
39171 {
39172 resultobj = SWIG_From_int((int)(result));
39173 }
39174 return resultobj;
39175 fail:
39176 return NULL;
39177 }
39178
39179
39180 static PyObject *_wrap_wxSizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39181 PyObject *resultobj;
39182 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39183 wxWindow *result;
39184 PyObject * obj0 = 0 ;
39185 char *kwnames[] = {
39186 (char *) "self", NULL
39187 };
39188
39189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetWindow",kwnames,&obj0)) goto fail;
39190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39191 if (SWIG_arg_fail(1)) SWIG_fail;
39192 {
39193 PyThreadState* __tstate = wxPyBeginAllowThreads();
39194 result = (wxWindow *)(arg1)->GetWindow();
39195
39196 wxPyEndAllowThreads(__tstate);
39197 if (PyErr_Occurred()) SWIG_fail;
39198 }
39199 {
39200 resultobj = wxPyMake_wxObject(result, 0);
39201 }
39202 return resultobj;
39203 fail:
39204 return NULL;
39205 }
39206
39207
39208 static PyObject *_wrap_wxSizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39209 PyObject *resultobj;
39210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39211 wxWindow *arg2 = (wxWindow *) 0 ;
39212 PyObject * obj0 = 0 ;
39213 PyObject * obj1 = 0 ;
39214 char *kwnames[] = {
39215 (char *) "self",(char *) "window", NULL
39216 };
39217
39218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39220 if (SWIG_arg_fail(1)) SWIG_fail;
39221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39222 if (SWIG_arg_fail(2)) SWIG_fail;
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 (arg1)->SetWindow(arg2);
39226
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 Py_INCREF(Py_None); resultobj = Py_None;
39231 return resultobj;
39232 fail:
39233 return NULL;
39234 }
39235
39236
39237 static PyObject *_wrap_wxSizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj;
39239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39240 wxSizer *result;
39241 PyObject * obj0 = 0 ;
39242 char *kwnames[] = {
39243 (char *) "self", NULL
39244 };
39245
39246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetSizer",kwnames,&obj0)) goto fail;
39247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39248 if (SWIG_arg_fail(1)) SWIG_fail;
39249 {
39250 PyThreadState* __tstate = wxPyBeginAllowThreads();
39251 result = (wxSizer *)(arg1)->GetSizer();
39252
39253 wxPyEndAllowThreads(__tstate);
39254 if (PyErr_Occurred()) SWIG_fail;
39255 }
39256 {
39257 resultobj = wxPyMake_wxSizer(result, 0);
39258 }
39259 return resultobj;
39260 fail:
39261 return NULL;
39262 }
39263
39264
39265 static PyObject *_wrap_wxSizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39266 PyObject *resultobj;
39267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39268 wxSizer *arg2 = (wxSizer *) 0 ;
39269 PyObject * obj0 = 0 ;
39270 PyObject * obj1 = 0 ;
39271 char *kwnames[] = {
39272 (char *) "self",(char *) "sizer", NULL
39273 };
39274
39275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39277 if (SWIG_arg_fail(1)) SWIG_fail;
39278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39279 if (SWIG_arg_fail(2)) SWIG_fail;
39280 {
39281 PyThreadState* __tstate = wxPyBeginAllowThreads();
39282 (arg1)->SetSizer(arg2);
39283
39284 wxPyEndAllowThreads(__tstate);
39285 if (PyErr_Occurred()) SWIG_fail;
39286 }
39287 Py_INCREF(Py_None); resultobj = Py_None;
39288 return resultobj;
39289 fail:
39290 return NULL;
39291 }
39292
39293
39294 static PyObject *_wrap_wxSizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39295 PyObject *resultobj;
39296 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39297 wxSize *result;
39298 PyObject * obj0 = 0 ;
39299 char *kwnames[] = {
39300 (char *) "self", NULL
39301 };
39302
39303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39305 if (SWIG_arg_fail(1)) SWIG_fail;
39306 {
39307 PyThreadState* __tstate = wxPyBeginAllowThreads();
39308 {
39309 wxSize const &_result_ref = (arg1)->GetSpacer();
39310 result = (wxSize *) &_result_ref;
39311 }
39312
39313 wxPyEndAllowThreads(__tstate);
39314 if (PyErr_Occurred()) SWIG_fail;
39315 }
39316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 static PyObject *_wrap_wxSizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39324 PyObject *resultobj;
39325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39326 wxSize *arg2 = 0 ;
39327 wxSize temp2 ;
39328 PyObject * obj0 = 0 ;
39329 PyObject * obj1 = 0 ;
39330 char *kwnames[] = {
39331 (char *) "self",(char *) "size", NULL
39332 };
39333
39334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39336 if (SWIG_arg_fail(1)) SWIG_fail;
39337 {
39338 arg2 = &temp2;
39339 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39340 }
39341 {
39342 PyThreadState* __tstate = wxPyBeginAllowThreads();
39343 (arg1)->SetSpacer((wxSize const &)*arg2);
39344
39345 wxPyEndAllowThreads(__tstate);
39346 if (PyErr_Occurred()) SWIG_fail;
39347 }
39348 Py_INCREF(Py_None); resultobj = Py_None;
39349 return resultobj;
39350 fail:
39351 return NULL;
39352 }
39353
39354
39355 static PyObject *_wrap_wxSizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39356 PyObject *resultobj;
39357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39358 bool arg2 ;
39359 PyObject * obj0 = 0 ;
39360 PyObject * obj1 = 0 ;
39361 char *kwnames[] = {
39362 (char *) "self",(char *) "show", NULL
39363 };
39364
39365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39367 if (SWIG_arg_fail(1)) SWIG_fail;
39368 {
39369 arg2 = (bool)(SWIG_As_bool(obj1));
39370 if (SWIG_arg_fail(2)) SWIG_fail;
39371 }
39372 {
39373 PyThreadState* __tstate = wxPyBeginAllowThreads();
39374 (arg1)->Show(arg2);
39375
39376 wxPyEndAllowThreads(__tstate);
39377 if (PyErr_Occurred()) SWIG_fail;
39378 }
39379 Py_INCREF(Py_None); resultobj = Py_None;
39380 return resultobj;
39381 fail:
39382 return NULL;
39383 }
39384
39385
39386 static PyObject *_wrap_wxSizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39387 PyObject *resultobj;
39388 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39389 bool result;
39390 PyObject * obj0 = 0 ;
39391 char *kwnames[] = {
39392 (char *) "self", NULL
39393 };
39394
39395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_IsShown",kwnames,&obj0)) goto fail;
39396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39397 if (SWIG_arg_fail(1)) SWIG_fail;
39398 {
39399 PyThreadState* __tstate = wxPyBeginAllowThreads();
39400 result = (bool)(arg1)->IsShown();
39401
39402 wxPyEndAllowThreads(__tstate);
39403 if (PyErr_Occurred()) SWIG_fail;
39404 }
39405 {
39406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39407 }
39408 return resultobj;
39409 fail:
39410 return NULL;
39411 }
39412
39413
39414 static PyObject *_wrap_wxSizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39415 PyObject *resultobj;
39416 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39417 wxPoint result;
39418 PyObject * obj0 = 0 ;
39419 char *kwnames[] = {
39420 (char *) "self", NULL
39421 };
39422
39423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetPosition",kwnames,&obj0)) goto fail;
39424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39425 if (SWIG_arg_fail(1)) SWIG_fail;
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 result = (arg1)->GetPosition();
39429
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 {
39434 wxPoint * resultptr;
39435 resultptr = new wxPoint((wxPoint &)(result));
39436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39437 }
39438 return resultobj;
39439 fail:
39440 return NULL;
39441 }
39442
39443
39444 static PyObject *_wrap_wxSizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39445 PyObject *resultobj;
39446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39447 PyObject *result;
39448 PyObject * obj0 = 0 ;
39449 char *kwnames[] = {
39450 (char *) "self", NULL
39451 };
39452
39453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizerItem_GetUserData",kwnames,&obj0)) goto fail;
39454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39455 if (SWIG_arg_fail(1)) SWIG_fail;
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39459
39460 wxPyEndAllowThreads(__tstate);
39461 if (PyErr_Occurred()) SWIG_fail;
39462 }
39463 resultobj = result;
39464 return resultobj;
39465 fail:
39466 return NULL;
39467 }
39468
39469
39470 static PyObject * wxSizerItem_swigregister(PyObject *, PyObject *args) {
39471 PyObject *obj;
39472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39473 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39474 Py_INCREF(obj);
39475 return Py_BuildValue((char *)"");
39476 }
39477 static PyObject *_wrap_wxSizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39478 PyObject *resultobj;
39479 wxSizer *arg1 = (wxSizer *) 0 ;
39480 PyObject *arg2 = (PyObject *) 0 ;
39481 PyObject * obj0 = 0 ;
39482 PyObject * obj1 = 0 ;
39483 char *kwnames[] = {
39484 (char *) "self",(char *) "_self", NULL
39485 };
39486
39487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39489 if (SWIG_arg_fail(1)) SWIG_fail;
39490 arg2 = obj1;
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 wxSizer__setOORInfo(arg1,arg2);
39494
39495 wxPyEndAllowThreads(__tstate);
39496 if (PyErr_Occurred()) SWIG_fail;
39497 }
39498 Py_INCREF(Py_None); resultobj = Py_None;
39499 return resultobj;
39500 fail:
39501 return NULL;
39502 }
39503
39504
39505 static PyObject *_wrap_wxSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39506 PyObject *resultobj;
39507 wxSizer *arg1 = (wxSizer *) 0 ;
39508 PyObject *arg2 = (PyObject *) 0 ;
39509 int arg3 = (int) 0 ;
39510 int arg4 = (int) 0 ;
39511 int arg5 = (int) 0 ;
39512 PyObject *arg6 = (PyObject *) NULL ;
39513 wxSizerItem *result;
39514 PyObject * obj0 = 0 ;
39515 PyObject * obj1 = 0 ;
39516 PyObject * obj2 = 0 ;
39517 PyObject * obj3 = 0 ;
39518 PyObject * obj4 = 0 ;
39519 PyObject * obj5 = 0 ;
39520 char *kwnames[] = {
39521 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39522 };
39523
39524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:wxSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39526 if (SWIG_arg_fail(1)) SWIG_fail;
39527 arg2 = obj1;
39528 if (obj2) {
39529 {
39530 arg3 = (int)(SWIG_As_int(obj2));
39531 if (SWIG_arg_fail(3)) SWIG_fail;
39532 }
39533 }
39534 if (obj3) {
39535 {
39536 arg4 = (int)(SWIG_As_int(obj3));
39537 if (SWIG_arg_fail(4)) SWIG_fail;
39538 }
39539 }
39540 if (obj4) {
39541 {
39542 arg5 = (int)(SWIG_As_int(obj4));
39543 if (SWIG_arg_fail(5)) SWIG_fail;
39544 }
39545 }
39546 if (obj5) {
39547 arg6 = obj5;
39548 }
39549 {
39550 PyThreadState* __tstate = wxPyBeginAllowThreads();
39551 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39552
39553 wxPyEndAllowThreads(__tstate);
39554 if (PyErr_Occurred()) SWIG_fail;
39555 }
39556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39557 return resultobj;
39558 fail:
39559 return NULL;
39560 }
39561
39562
39563 static PyObject *_wrap_wxSizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39564 PyObject *resultobj;
39565 wxSizer *arg1 = (wxSizer *) 0 ;
39566 int arg2 ;
39567 PyObject *arg3 = (PyObject *) 0 ;
39568 int arg4 = (int) 0 ;
39569 int arg5 = (int) 0 ;
39570 int arg6 = (int) 0 ;
39571 PyObject *arg7 = (PyObject *) NULL ;
39572 wxSizerItem *result;
39573 PyObject * obj0 = 0 ;
39574 PyObject * obj1 = 0 ;
39575 PyObject * obj2 = 0 ;
39576 PyObject * obj3 = 0 ;
39577 PyObject * obj4 = 0 ;
39578 PyObject * obj5 = 0 ;
39579 PyObject * obj6 = 0 ;
39580 char *kwnames[] = {
39581 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39582 };
39583
39584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:wxSizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39586 if (SWIG_arg_fail(1)) SWIG_fail;
39587 {
39588 arg2 = (int)(SWIG_As_int(obj1));
39589 if (SWIG_arg_fail(2)) SWIG_fail;
39590 }
39591 arg3 = obj2;
39592 if (obj3) {
39593 {
39594 arg4 = (int)(SWIG_As_int(obj3));
39595 if (SWIG_arg_fail(4)) SWIG_fail;
39596 }
39597 }
39598 if (obj4) {
39599 {
39600 arg5 = (int)(SWIG_As_int(obj4));
39601 if (SWIG_arg_fail(5)) SWIG_fail;
39602 }
39603 }
39604 if (obj5) {
39605 {
39606 arg6 = (int)(SWIG_As_int(obj5));
39607 if (SWIG_arg_fail(6)) SWIG_fail;
39608 }
39609 }
39610 if (obj6) {
39611 arg7 = obj6;
39612 }
39613 {
39614 PyThreadState* __tstate = wxPyBeginAllowThreads();
39615 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39616
39617 wxPyEndAllowThreads(__tstate);
39618 if (PyErr_Occurred()) SWIG_fail;
39619 }
39620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39621 return resultobj;
39622 fail:
39623 return NULL;
39624 }
39625
39626
39627 static PyObject *_wrap_wxSizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39628 PyObject *resultobj;
39629 wxSizer *arg1 = (wxSizer *) 0 ;
39630 PyObject *arg2 = (PyObject *) 0 ;
39631 int arg3 = (int) 0 ;
39632 int arg4 = (int) 0 ;
39633 int arg5 = (int) 0 ;
39634 PyObject *arg6 = (PyObject *) NULL ;
39635 wxSizerItem *result;
39636 PyObject * obj0 = 0 ;
39637 PyObject * obj1 = 0 ;
39638 PyObject * obj2 = 0 ;
39639 PyObject * obj3 = 0 ;
39640 PyObject * obj4 = 0 ;
39641 PyObject * obj5 = 0 ;
39642 char *kwnames[] = {
39643 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39644 };
39645
39646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:wxSizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39648 if (SWIG_arg_fail(1)) SWIG_fail;
39649 arg2 = obj1;
39650 if (obj2) {
39651 {
39652 arg3 = (int)(SWIG_As_int(obj2));
39653 if (SWIG_arg_fail(3)) SWIG_fail;
39654 }
39655 }
39656 if (obj3) {
39657 {
39658 arg4 = (int)(SWIG_As_int(obj3));
39659 if (SWIG_arg_fail(4)) SWIG_fail;
39660 }
39661 }
39662 if (obj4) {
39663 {
39664 arg5 = (int)(SWIG_As_int(obj4));
39665 if (SWIG_arg_fail(5)) SWIG_fail;
39666 }
39667 }
39668 if (obj5) {
39669 arg6 = obj5;
39670 }
39671 {
39672 PyThreadState* __tstate = wxPyBeginAllowThreads();
39673 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39674
39675 wxPyEndAllowThreads(__tstate);
39676 if (PyErr_Occurred()) SWIG_fail;
39677 }
39678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39679 return resultobj;
39680 fail:
39681 return NULL;
39682 }
39683
39684
39685 static PyObject *_wrap_wxSizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj;
39687 wxSizer *arg1 = (wxSizer *) 0 ;
39688 PyObject *arg2 = (PyObject *) 0 ;
39689 bool result;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 char *kwnames[] = {
39693 (char *) "self",(char *) "item", NULL
39694 };
39695
39696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39698 if (SWIG_arg_fail(1)) SWIG_fail;
39699 arg2 = obj1;
39700 {
39701 PyThreadState* __tstate = wxPyBeginAllowThreads();
39702 result = (bool)wxSizer_Remove(arg1,arg2);
39703
39704 wxPyEndAllowThreads(__tstate);
39705 if (PyErr_Occurred()) SWIG_fail;
39706 }
39707 {
39708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39709 }
39710 return resultobj;
39711 fail:
39712 return NULL;
39713 }
39714
39715
39716 static PyObject *_wrap_wxSizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39717 PyObject *resultobj;
39718 wxSizer *arg1 = (wxSizer *) 0 ;
39719 PyObject *arg2 = (PyObject *) 0 ;
39720 bool result;
39721 PyObject * obj0 = 0 ;
39722 PyObject * obj1 = 0 ;
39723 char *kwnames[] = {
39724 (char *) "self",(char *) "item", NULL
39725 };
39726
39727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39729 if (SWIG_arg_fail(1)) SWIG_fail;
39730 arg2 = obj1;
39731 {
39732 PyThreadState* __tstate = wxPyBeginAllowThreads();
39733 result = (bool)wxSizer_Detach(arg1,arg2);
39734
39735 wxPyEndAllowThreads(__tstate);
39736 if (PyErr_Occurred()) SWIG_fail;
39737 }
39738 {
39739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39740 }
39741 return resultobj;
39742 fail:
39743 return NULL;
39744 }
39745
39746
39747 static PyObject *_wrap_wxSizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39748 PyObject *resultobj;
39749 wxSizer *arg1 = (wxSizer *) 0 ;
39750 PyObject *arg2 = (PyObject *) 0 ;
39751 wxSizerItem *result;
39752 PyObject * obj0 = 0 ;
39753 PyObject * obj1 = 0 ;
39754 char *kwnames[] = {
39755 (char *) "self",(char *) "item", NULL
39756 };
39757
39758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39760 if (SWIG_arg_fail(1)) SWIG_fail;
39761 arg2 = obj1;
39762 {
39763 PyThreadState* __tstate = wxPyBeginAllowThreads();
39764 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39765
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39770 return resultobj;
39771 fail:
39772 return NULL;
39773 }
39774
39775
39776 static PyObject *_wrap_wxSizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39777 PyObject *resultobj;
39778 wxSizer *arg1 = (wxSizer *) 0 ;
39779 PyObject *arg2 = (PyObject *) 0 ;
39780 wxSize *arg3 = 0 ;
39781 wxSize temp3 ;
39782 PyObject * obj0 = 0 ;
39783 PyObject * obj1 = 0 ;
39784 PyObject * obj2 = 0 ;
39785 char *kwnames[] = {
39786 (char *) "self",(char *) "item",(char *) "size", NULL
39787 };
39788
39789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxSizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39791 if (SWIG_arg_fail(1)) SWIG_fail;
39792 arg2 = obj1;
39793 {
39794 arg3 = &temp3;
39795 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39796 }
39797 {
39798 PyThreadState* __tstate = wxPyBeginAllowThreads();
39799 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39800
39801 wxPyEndAllowThreads(__tstate);
39802 if (PyErr_Occurred()) SWIG_fail;
39803 }
39804 Py_INCREF(Py_None); resultobj = Py_None;
39805 return resultobj;
39806 fail:
39807 return NULL;
39808 }
39809
39810
39811 static PyObject *_wrap_wxSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39812 PyObject *resultobj;
39813 wxSizer *arg1 = (wxSizer *) 0 ;
39814 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39815 wxSizerItem *result;
39816 PyObject * obj0 = 0 ;
39817 PyObject * obj1 = 0 ;
39818 char *kwnames[] = {
39819 (char *) "self",(char *) "item", NULL
39820 };
39821
39822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39824 if (SWIG_arg_fail(1)) SWIG_fail;
39825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39826 if (SWIG_arg_fail(2)) SWIG_fail;
39827 {
39828 PyThreadState* __tstate = wxPyBeginAllowThreads();
39829 result = (wxSizerItem *)(arg1)->Add(arg2);
39830
39831 wxPyEndAllowThreads(__tstate);
39832 if (PyErr_Occurred()) SWIG_fail;
39833 }
39834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39835 return resultobj;
39836 fail:
39837 return NULL;
39838 }
39839
39840
39841 static PyObject *_wrap_wxSizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39842 PyObject *resultobj;
39843 wxSizer *arg1 = (wxSizer *) 0 ;
39844 size_t arg2 ;
39845 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39846 wxSizerItem *result;
39847 PyObject * obj0 = 0 ;
39848 PyObject * obj1 = 0 ;
39849 PyObject * obj2 = 0 ;
39850 char *kwnames[] = {
39851 (char *) "self",(char *) "index",(char *) "item", NULL
39852 };
39853
39854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxSizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39856 if (SWIG_arg_fail(1)) SWIG_fail;
39857 {
39858 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39859 if (SWIG_arg_fail(2)) SWIG_fail;
39860 }
39861 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39862 if (SWIG_arg_fail(3)) SWIG_fail;
39863 {
39864 PyThreadState* __tstate = wxPyBeginAllowThreads();
39865 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39866
39867 wxPyEndAllowThreads(__tstate);
39868 if (PyErr_Occurred()) SWIG_fail;
39869 }
39870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39871 return resultobj;
39872 fail:
39873 return NULL;
39874 }
39875
39876
39877 static PyObject *_wrap_wxSizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39878 PyObject *resultobj;
39879 wxSizer *arg1 = (wxSizer *) 0 ;
39880 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39881 wxSizerItem *result;
39882 PyObject * obj0 = 0 ;
39883 PyObject * obj1 = 0 ;
39884 char *kwnames[] = {
39885 (char *) "self",(char *) "item", NULL
39886 };
39887
39888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39890 if (SWIG_arg_fail(1)) SWIG_fail;
39891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39892 if (SWIG_arg_fail(2)) SWIG_fail;
39893 {
39894 PyThreadState* __tstate = wxPyBeginAllowThreads();
39895 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39896
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39901 return resultobj;
39902 fail:
39903 return NULL;
39904 }
39905
39906
39907 static PyObject *_wrap_wxSizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39908 PyObject *resultobj;
39909 wxSizer *arg1 = (wxSizer *) 0 ;
39910 int arg2 ;
39911 int arg3 ;
39912 int arg4 ;
39913 int arg5 ;
39914 PyObject * obj0 = 0 ;
39915 PyObject * obj1 = 0 ;
39916 PyObject * obj2 = 0 ;
39917 PyObject * obj3 = 0 ;
39918 PyObject * obj4 = 0 ;
39919 char *kwnames[] = {
39920 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39921 };
39922
39923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:wxSizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39925 if (SWIG_arg_fail(1)) SWIG_fail;
39926 {
39927 arg2 = (int)(SWIG_As_int(obj1));
39928 if (SWIG_arg_fail(2)) SWIG_fail;
39929 }
39930 {
39931 arg3 = (int)(SWIG_As_int(obj2));
39932 if (SWIG_arg_fail(3)) SWIG_fail;
39933 }
39934 {
39935 arg4 = (int)(SWIG_As_int(obj3));
39936 if (SWIG_arg_fail(4)) SWIG_fail;
39937 }
39938 {
39939 arg5 = (int)(SWIG_As_int(obj4));
39940 if (SWIG_arg_fail(5)) SWIG_fail;
39941 }
39942 {
39943 PyThreadState* __tstate = wxPyBeginAllowThreads();
39944 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39945
39946 wxPyEndAllowThreads(__tstate);
39947 if (PyErr_Occurred()) SWIG_fail;
39948 }
39949 Py_INCREF(Py_None); resultobj = Py_None;
39950 return resultobj;
39951 fail:
39952 return NULL;
39953 }
39954
39955
39956 static PyObject *_wrap_wxSizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39957 PyObject *resultobj;
39958 wxSizer *arg1 = (wxSizer *) 0 ;
39959 wxSize *arg2 = 0 ;
39960 wxSize temp2 ;
39961 PyObject * obj0 = 0 ;
39962 PyObject * obj1 = 0 ;
39963 char *kwnames[] = {
39964 (char *) "self",(char *) "size", NULL
39965 };
39966
39967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39969 if (SWIG_arg_fail(1)) SWIG_fail;
39970 {
39971 arg2 = &temp2;
39972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39973 }
39974 {
39975 PyThreadState* __tstate = wxPyBeginAllowThreads();
39976 (arg1)->SetMinSize((wxSize const &)*arg2);
39977
39978 wxPyEndAllowThreads(__tstate);
39979 if (PyErr_Occurred()) SWIG_fail;
39980 }
39981 Py_INCREF(Py_None); resultobj = Py_None;
39982 return resultobj;
39983 fail:
39984 return NULL;
39985 }
39986
39987
39988 static PyObject *_wrap_wxSizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39989 PyObject *resultobj;
39990 wxSizer *arg1 = (wxSizer *) 0 ;
39991 wxSize result;
39992 PyObject * obj0 = 0 ;
39993 char *kwnames[] = {
39994 (char *) "self", NULL
39995 };
39996
39997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_GetSize",kwnames,&obj0)) goto fail;
39998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39999 if (SWIG_arg_fail(1)) SWIG_fail;
40000 {
40001 PyThreadState* __tstate = wxPyBeginAllowThreads();
40002 result = (arg1)->GetSize();
40003
40004 wxPyEndAllowThreads(__tstate);
40005 if (PyErr_Occurred()) SWIG_fail;
40006 }
40007 {
40008 wxSize * resultptr;
40009 resultptr = new wxSize((wxSize &)(result));
40010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40011 }
40012 return resultobj;
40013 fail:
40014 return NULL;
40015 }
40016
40017
40018 static PyObject *_wrap_wxSizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40019 PyObject *resultobj;
40020 wxSizer *arg1 = (wxSizer *) 0 ;
40021 wxPoint result;
40022 PyObject * obj0 = 0 ;
40023 char *kwnames[] = {
40024 (char *) "self", NULL
40025 };
40026
40027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_GetPosition",kwnames,&obj0)) goto fail;
40028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40029 if (SWIG_arg_fail(1)) SWIG_fail;
40030 {
40031 PyThreadState* __tstate = wxPyBeginAllowThreads();
40032 result = (arg1)->GetPosition();
40033
40034 wxPyEndAllowThreads(__tstate);
40035 if (PyErr_Occurred()) SWIG_fail;
40036 }
40037 {
40038 wxPoint * resultptr;
40039 resultptr = new wxPoint((wxPoint &)(result));
40040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40041 }
40042 return resultobj;
40043 fail:
40044 return NULL;
40045 }
40046
40047
40048 static PyObject *_wrap_wxSizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40049 PyObject *resultobj;
40050 wxSizer *arg1 = (wxSizer *) 0 ;
40051 wxSize result;
40052 PyObject * obj0 = 0 ;
40053 char *kwnames[] = {
40054 (char *) "self", NULL
40055 };
40056
40057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_GetMinSize",kwnames,&obj0)) goto fail;
40058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40059 if (SWIG_arg_fail(1)) SWIG_fail;
40060 {
40061 PyThreadState* __tstate = wxPyBeginAllowThreads();
40062 result = (arg1)->GetMinSize();
40063
40064 wxPyEndAllowThreads(__tstate);
40065 if (PyErr_Occurred()) SWIG_fail;
40066 }
40067 {
40068 wxSize * resultptr;
40069 resultptr = new wxSize((wxSize &)(result));
40070 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40071 }
40072 return resultobj;
40073 fail:
40074 return NULL;
40075 }
40076
40077
40078 static PyObject *_wrap_wxSizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40079 PyObject *resultobj;
40080 wxSizer *arg1 = (wxSizer *) 0 ;
40081 PyObject * obj0 = 0 ;
40082 char *kwnames[] = {
40083 (char *) "self", NULL
40084 };
40085
40086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_RecalcSizes",kwnames,&obj0)) goto fail;
40087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40088 if (SWIG_arg_fail(1)) SWIG_fail;
40089 {
40090 PyThreadState* __tstate = wxPyBeginAllowThreads();
40091 (arg1)->RecalcSizes();
40092
40093 wxPyEndAllowThreads(__tstate);
40094 if (PyErr_Occurred()) SWIG_fail;
40095 }
40096 Py_INCREF(Py_None); resultobj = Py_None;
40097 return resultobj;
40098 fail:
40099 return NULL;
40100 }
40101
40102
40103 static PyObject *_wrap_wxSizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40104 PyObject *resultobj;
40105 wxSizer *arg1 = (wxSizer *) 0 ;
40106 wxSize result;
40107 PyObject * obj0 = 0 ;
40108 char *kwnames[] = {
40109 (char *) "self", NULL
40110 };
40111
40112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_CalcMin",kwnames,&obj0)) goto fail;
40113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40114 if (SWIG_arg_fail(1)) SWIG_fail;
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 result = (arg1)->CalcMin();
40118
40119 wxPyEndAllowThreads(__tstate);
40120 if (PyErr_Occurred()) SWIG_fail;
40121 }
40122 {
40123 wxSize * resultptr;
40124 resultptr = new wxSize((wxSize &)(result));
40125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40126 }
40127 return resultobj;
40128 fail:
40129 return NULL;
40130 }
40131
40132
40133 static PyObject *_wrap_wxSizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40134 PyObject *resultobj;
40135 wxSizer *arg1 = (wxSizer *) 0 ;
40136 PyObject * obj0 = 0 ;
40137 char *kwnames[] = {
40138 (char *) "self", NULL
40139 };
40140
40141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_Layout",kwnames,&obj0)) goto fail;
40142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40143 if (SWIG_arg_fail(1)) SWIG_fail;
40144 {
40145 PyThreadState* __tstate = wxPyBeginAllowThreads();
40146 (arg1)->Layout();
40147
40148 wxPyEndAllowThreads(__tstate);
40149 if (PyErr_Occurred()) SWIG_fail;
40150 }
40151 Py_INCREF(Py_None); resultobj = Py_None;
40152 return resultobj;
40153 fail:
40154 return NULL;
40155 }
40156
40157
40158 static PyObject *_wrap_wxSizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40159 PyObject *resultobj;
40160 wxSizer *arg1 = (wxSizer *) 0 ;
40161 wxWindow *arg2 = (wxWindow *) 0 ;
40162 wxSize result;
40163 PyObject * obj0 = 0 ;
40164 PyObject * obj1 = 0 ;
40165 char *kwnames[] = {
40166 (char *) "self",(char *) "window", NULL
40167 };
40168
40169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40171 if (SWIG_arg_fail(1)) SWIG_fail;
40172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40173 if (SWIG_arg_fail(2)) SWIG_fail;
40174 {
40175 PyThreadState* __tstate = wxPyBeginAllowThreads();
40176 result = (arg1)->Fit(arg2);
40177
40178 wxPyEndAllowThreads(__tstate);
40179 if (PyErr_Occurred()) SWIG_fail;
40180 }
40181 {
40182 wxSize * resultptr;
40183 resultptr = new wxSize((wxSize &)(result));
40184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40185 }
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 static PyObject *_wrap_wxSizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40193 PyObject *resultobj;
40194 wxSizer *arg1 = (wxSizer *) 0 ;
40195 wxWindow *arg2 = (wxWindow *) 0 ;
40196 PyObject * obj0 = 0 ;
40197 PyObject * obj1 = 0 ;
40198 char *kwnames[] = {
40199 (char *) "self",(char *) "window", NULL
40200 };
40201
40202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40204 if (SWIG_arg_fail(1)) SWIG_fail;
40205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40206 if (SWIG_arg_fail(2)) SWIG_fail;
40207 {
40208 PyThreadState* __tstate = wxPyBeginAllowThreads();
40209 (arg1)->FitInside(arg2);
40210
40211 wxPyEndAllowThreads(__tstate);
40212 if (PyErr_Occurred()) SWIG_fail;
40213 }
40214 Py_INCREF(Py_None); resultobj = Py_None;
40215 return resultobj;
40216 fail:
40217 return NULL;
40218 }
40219
40220
40221 static PyObject *_wrap_wxSizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40222 PyObject *resultobj;
40223 wxSizer *arg1 = (wxSizer *) 0 ;
40224 wxWindow *arg2 = (wxWindow *) 0 ;
40225 PyObject * obj0 = 0 ;
40226 PyObject * obj1 = 0 ;
40227 char *kwnames[] = {
40228 (char *) "self",(char *) "window", NULL
40229 };
40230
40231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40233 if (SWIG_arg_fail(1)) SWIG_fail;
40234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40235 if (SWIG_arg_fail(2)) SWIG_fail;
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 (arg1)->SetSizeHints(arg2);
40239
40240 wxPyEndAllowThreads(__tstate);
40241 if (PyErr_Occurred()) SWIG_fail;
40242 }
40243 Py_INCREF(Py_None); resultobj = Py_None;
40244 return resultobj;
40245 fail:
40246 return NULL;
40247 }
40248
40249
40250 static PyObject *_wrap_wxSizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40251 PyObject *resultobj;
40252 wxSizer *arg1 = (wxSizer *) 0 ;
40253 wxWindow *arg2 = (wxWindow *) 0 ;
40254 PyObject * obj0 = 0 ;
40255 PyObject * obj1 = 0 ;
40256 char *kwnames[] = {
40257 (char *) "self",(char *) "window", NULL
40258 };
40259
40260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40262 if (SWIG_arg_fail(1)) SWIG_fail;
40263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40264 if (SWIG_arg_fail(2)) SWIG_fail;
40265 {
40266 PyThreadState* __tstate = wxPyBeginAllowThreads();
40267 (arg1)->SetVirtualSizeHints(arg2);
40268
40269 wxPyEndAllowThreads(__tstate);
40270 if (PyErr_Occurred()) SWIG_fail;
40271 }
40272 Py_INCREF(Py_None); resultobj = Py_None;
40273 return resultobj;
40274 fail:
40275 return NULL;
40276 }
40277
40278
40279 static PyObject *_wrap_wxSizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40280 PyObject *resultobj;
40281 wxSizer *arg1 = (wxSizer *) 0 ;
40282 bool arg2 = (bool) false ;
40283 PyObject * obj0 = 0 ;
40284 PyObject * obj1 = 0 ;
40285 char *kwnames[] = {
40286 (char *) "self",(char *) "deleteWindows", NULL
40287 };
40288
40289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:wxSizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40291 if (SWIG_arg_fail(1)) SWIG_fail;
40292 if (obj1) {
40293 {
40294 arg2 = (bool)(SWIG_As_bool(obj1));
40295 if (SWIG_arg_fail(2)) SWIG_fail;
40296 }
40297 }
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 (arg1)->Clear(arg2);
40301
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 Py_INCREF(Py_None); resultobj = Py_None;
40306 return resultobj;
40307 fail:
40308 return NULL;
40309 }
40310
40311
40312 static PyObject *_wrap_wxSizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40313 PyObject *resultobj;
40314 wxSizer *arg1 = (wxSizer *) 0 ;
40315 PyObject * obj0 = 0 ;
40316 char *kwnames[] = {
40317 (char *) "self", NULL
40318 };
40319
40320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_DeleteWindows",kwnames,&obj0)) goto fail;
40321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40322 if (SWIG_arg_fail(1)) SWIG_fail;
40323 {
40324 PyThreadState* __tstate = wxPyBeginAllowThreads();
40325 (arg1)->DeleteWindows();
40326
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 Py_INCREF(Py_None); resultobj = Py_None;
40331 return resultobj;
40332 fail:
40333 return NULL;
40334 }
40335
40336
40337 static PyObject *_wrap_wxSizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40338 PyObject *resultobj;
40339 wxSizer *arg1 = (wxSizer *) 0 ;
40340 PyObject *result;
40341 PyObject * obj0 = 0 ;
40342 char *kwnames[] = {
40343 (char *) "self", NULL
40344 };
40345
40346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxSizer_GetChildren",kwnames,&obj0)) goto fail;
40347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40348 if (SWIG_arg_fail(1)) SWIG_fail;
40349 {
40350 PyThreadState* __tstate = wxPyBeginAllowThreads();
40351 result = (PyObject *)wxSizer_GetChildren(arg1);
40352
40353 wxPyEndAllowThreads(__tstate);
40354 if (PyErr_Occurred()) SWIG_fail;
40355 }
40356 resultobj = result;
40357 return resultobj;
40358 fail:
40359 return NULL;
40360 }
40361
40362
40363 static PyObject *_wrap_wxSizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40364 PyObject *resultobj;
40365 wxSizer *arg1 = (wxSizer *) 0 ;
40366 PyObject *arg2 = (PyObject *) 0 ;
40367 bool arg3 = (bool) true ;
40368 bool arg4 = (bool) false ;
40369 bool result;
40370 PyObject * obj0 = 0 ;
40371 PyObject * obj1 = 0 ;
40372 PyObject * obj2 = 0 ;
40373 PyObject * obj3 = 0 ;
40374 char *kwnames[] = {
40375 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40376 };
40377
40378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:wxSizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40380 if (SWIG_arg_fail(1)) SWIG_fail;
40381 arg2 = obj1;
40382 if (obj2) {
40383 {
40384 arg3 = (bool)(SWIG_As_bool(obj2));
40385 if (SWIG_arg_fail(3)) SWIG_fail;
40386 }
40387 }
40388 if (obj3) {
40389 {
40390 arg4 = (bool)(SWIG_As_bool(obj3));
40391 if (SWIG_arg_fail(4)) SWIG_fail;
40392 }
40393 }
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40397
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 {
40402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40403 }
40404 return resultobj;
40405 fail:
40406 return NULL;
40407 }
40408
40409
40410 static PyObject *_wrap_wxSizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40411 PyObject *resultobj;
40412 wxSizer *arg1 = (wxSizer *) 0 ;
40413 PyObject *arg2 = (PyObject *) 0 ;
40414 bool result;
40415 PyObject * obj0 = 0 ;
40416 PyObject * obj1 = 0 ;
40417 char *kwnames[] = {
40418 (char *) "self",(char *) "item", NULL
40419 };
40420
40421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40423 if (SWIG_arg_fail(1)) SWIG_fail;
40424 arg2 = obj1;
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 result = (bool)wxSizer_IsShown(arg1,arg2);
40428
40429 wxPyEndAllowThreads(__tstate);
40430 if (PyErr_Occurred()) SWIG_fail;
40431 }
40432 {
40433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40434 }
40435 return resultobj;
40436 fail:
40437 return NULL;
40438 }
40439
40440
40441 static PyObject *_wrap_wxSizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40442 PyObject *resultobj;
40443 wxSizer *arg1 = (wxSizer *) 0 ;
40444 bool arg2 ;
40445 PyObject * obj0 = 0 ;
40446 PyObject * obj1 = 0 ;
40447 char *kwnames[] = {
40448 (char *) "self",(char *) "show", NULL
40449 };
40450
40451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxSizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40453 if (SWIG_arg_fail(1)) SWIG_fail;
40454 {
40455 arg2 = (bool)(SWIG_As_bool(obj1));
40456 if (SWIG_arg_fail(2)) SWIG_fail;
40457 }
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 (arg1)->ShowItems(arg2);
40461
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 Py_INCREF(Py_None); resultobj = Py_None;
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 static PyObject * wxSizer_swigregister(PyObject *, PyObject *args) {
40473 PyObject *obj;
40474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40475 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40476 Py_INCREF(obj);
40477 return Py_BuildValue((char *)"");
40478 }
40479 static PyObject *_wrap_new_wxPySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40480 PyObject *resultobj;
40481 wxPySizer *result;
40482 char *kwnames[] = {
40483 NULL
40484 };
40485
40486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxPySizer",kwnames)) goto fail;
40487 {
40488 PyThreadState* __tstate = wxPyBeginAllowThreads();
40489 result = (wxPySizer *)new wxPySizer();
40490
40491 wxPyEndAllowThreads(__tstate);
40492 if (PyErr_Occurred()) SWIG_fail;
40493 }
40494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40495 return resultobj;
40496 fail:
40497 return NULL;
40498 }
40499
40500
40501 static PyObject *_wrap_wxPySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40502 PyObject *resultobj;
40503 wxPySizer *arg1 = (wxPySizer *) 0 ;
40504 PyObject *arg2 = (PyObject *) 0 ;
40505 PyObject *arg3 = (PyObject *) 0 ;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 PyObject * obj2 = 0 ;
40509 char *kwnames[] = {
40510 (char *) "self",(char *) "self",(char *) "_class", NULL
40511 };
40512
40513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxPySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40515 if (SWIG_arg_fail(1)) SWIG_fail;
40516 arg2 = obj1;
40517 arg3 = obj2;
40518 {
40519 PyThreadState* __tstate = wxPyBeginAllowThreads();
40520 (arg1)->_setCallbackInfo(arg2,arg3);
40521
40522 wxPyEndAllowThreads(__tstate);
40523 if (PyErr_Occurred()) SWIG_fail;
40524 }
40525 Py_INCREF(Py_None); resultobj = Py_None;
40526 return resultobj;
40527 fail:
40528 return NULL;
40529 }
40530
40531
40532 static PyObject * wxPySizer_swigregister(PyObject *, PyObject *args) {
40533 PyObject *obj;
40534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40535 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40536 Py_INCREF(obj);
40537 return Py_BuildValue((char *)"");
40538 }
40539 static PyObject *_wrap_new_wxBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40540 PyObject *resultobj;
40541 int arg1 = (int) wxHORIZONTAL ;
40542 wxBoxSizer *result;
40543 PyObject * obj0 = 0 ;
40544 char *kwnames[] = {
40545 (char *) "orient", NULL
40546 };
40547
40548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_wxBoxSizer",kwnames,&obj0)) goto fail;
40549 if (obj0) {
40550 {
40551 arg1 = (int)(SWIG_As_int(obj0));
40552 if (SWIG_arg_fail(1)) SWIG_fail;
40553 }
40554 }
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40558
40559 wxPyEndAllowThreads(__tstate);
40560 if (PyErr_Occurred()) SWIG_fail;
40561 }
40562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40563 return resultobj;
40564 fail:
40565 return NULL;
40566 }
40567
40568
40569 static PyObject *_wrap_wxBoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40570 PyObject *resultobj;
40571 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40572 int result;
40573 PyObject * obj0 = 0 ;
40574 char *kwnames[] = {
40575 (char *) "self", NULL
40576 };
40577
40578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxBoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40580 if (SWIG_arg_fail(1)) SWIG_fail;
40581 {
40582 PyThreadState* __tstate = wxPyBeginAllowThreads();
40583 result = (int)(arg1)->GetOrientation();
40584
40585 wxPyEndAllowThreads(__tstate);
40586 if (PyErr_Occurred()) SWIG_fail;
40587 }
40588 {
40589 resultobj = SWIG_From_int((int)(result));
40590 }
40591 return resultobj;
40592 fail:
40593 return NULL;
40594 }
40595
40596
40597 static PyObject *_wrap_wxBoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40598 PyObject *resultobj;
40599 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40600 int arg2 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 char *kwnames[] = {
40604 (char *) "self",(char *) "orient", NULL
40605 };
40606
40607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxBoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40609 if (SWIG_arg_fail(1)) SWIG_fail;
40610 {
40611 arg2 = (int)(SWIG_As_int(obj1));
40612 if (SWIG_arg_fail(2)) SWIG_fail;
40613 }
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 (arg1)->SetOrientation(arg2);
40617
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 Py_INCREF(Py_None); resultobj = Py_None;
40622 return resultobj;
40623 fail:
40624 return NULL;
40625 }
40626
40627
40628 static PyObject * wxBoxSizer_swigregister(PyObject *, PyObject *args) {
40629 PyObject *obj;
40630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40631 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40632 Py_INCREF(obj);
40633 return Py_BuildValue((char *)"");
40634 }
40635 static PyObject *_wrap_new_wxStaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40636 PyObject *resultobj;
40637 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40638 int arg2 = (int) wxHORIZONTAL ;
40639 wxStaticBoxSizer *result;
40640 PyObject * obj0 = 0 ;
40641 PyObject * obj1 = 0 ;
40642 char *kwnames[] = {
40643 (char *) "box",(char *) "orient", NULL
40644 };
40645
40646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_wxStaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40648 if (SWIG_arg_fail(1)) SWIG_fail;
40649 if (obj1) {
40650 {
40651 arg2 = (int)(SWIG_As_int(obj1));
40652 if (SWIG_arg_fail(2)) SWIG_fail;
40653 }
40654 }
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40658
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 static PyObject *_wrap_wxStaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40670 PyObject *resultobj;
40671 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40672 wxStaticBox *result;
40673 PyObject * obj0 = 0 ;
40674 char *kwnames[] = {
40675 (char *) "self", NULL
40676 };
40677
40678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40680 if (SWIG_arg_fail(1)) SWIG_fail;
40681 {
40682 PyThreadState* __tstate = wxPyBeginAllowThreads();
40683 result = (wxStaticBox *)(arg1)->GetStaticBox();
40684
40685 wxPyEndAllowThreads(__tstate);
40686 if (PyErr_Occurred()) SWIG_fail;
40687 }
40688 {
40689 resultobj = wxPyMake_wxObject(result, 0);
40690 }
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 static PyObject * wxStaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40698 PyObject *obj;
40699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40700 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40701 Py_INCREF(obj);
40702 return Py_BuildValue((char *)"");
40703 }
40704 static PyObject *_wrap_new_wxGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40705 PyObject *resultobj;
40706 int arg1 = (int) 1 ;
40707 int arg2 = (int) 0 ;
40708 int arg3 = (int) 0 ;
40709 int arg4 = (int) 0 ;
40710 wxGridSizer *result;
40711 PyObject * obj0 = 0 ;
40712 PyObject * obj1 = 0 ;
40713 PyObject * obj2 = 0 ;
40714 PyObject * obj3 = 0 ;
40715 char *kwnames[] = {
40716 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40717 };
40718
40719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_wxGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40720 if (obj0) {
40721 {
40722 arg1 = (int)(SWIG_As_int(obj0));
40723 if (SWIG_arg_fail(1)) SWIG_fail;
40724 }
40725 }
40726 if (obj1) {
40727 {
40728 arg2 = (int)(SWIG_As_int(obj1));
40729 if (SWIG_arg_fail(2)) SWIG_fail;
40730 }
40731 }
40732 if (obj2) {
40733 {
40734 arg3 = (int)(SWIG_As_int(obj2));
40735 if (SWIG_arg_fail(3)) SWIG_fail;
40736 }
40737 }
40738 if (obj3) {
40739 {
40740 arg4 = (int)(SWIG_As_int(obj3));
40741 if (SWIG_arg_fail(4)) SWIG_fail;
40742 }
40743 }
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40747
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 static PyObject *_wrap_wxGridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj;
40760 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40761 int arg2 ;
40762 PyObject * obj0 = 0 ;
40763 PyObject * obj1 = 0 ;
40764 char *kwnames[] = {
40765 (char *) "self",(char *) "cols", NULL
40766 };
40767
40768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40770 if (SWIG_arg_fail(1)) SWIG_fail;
40771 {
40772 arg2 = (int)(SWIG_As_int(obj1));
40773 if (SWIG_arg_fail(2)) SWIG_fail;
40774 }
40775 {
40776 PyThreadState* __tstate = wxPyBeginAllowThreads();
40777 (arg1)->SetCols(arg2);
40778
40779 wxPyEndAllowThreads(__tstate);
40780 if (PyErr_Occurred()) SWIG_fail;
40781 }
40782 Py_INCREF(Py_None); resultobj = Py_None;
40783 return resultobj;
40784 fail:
40785 return NULL;
40786 }
40787
40788
40789 static PyObject *_wrap_wxGridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40790 PyObject *resultobj;
40791 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40792 int arg2 ;
40793 PyObject * obj0 = 0 ;
40794 PyObject * obj1 = 0 ;
40795 char *kwnames[] = {
40796 (char *) "self",(char *) "rows", NULL
40797 };
40798
40799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40801 if (SWIG_arg_fail(1)) SWIG_fail;
40802 {
40803 arg2 = (int)(SWIG_As_int(obj1));
40804 if (SWIG_arg_fail(2)) SWIG_fail;
40805 }
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 (arg1)->SetRows(arg2);
40809
40810 wxPyEndAllowThreads(__tstate);
40811 if (PyErr_Occurred()) SWIG_fail;
40812 }
40813 Py_INCREF(Py_None); resultobj = Py_None;
40814 return resultobj;
40815 fail:
40816 return NULL;
40817 }
40818
40819
40820 static PyObject *_wrap_wxGridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40821 PyObject *resultobj;
40822 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40823 int arg2 ;
40824 PyObject * obj0 = 0 ;
40825 PyObject * obj1 = 0 ;
40826 char *kwnames[] = {
40827 (char *) "self",(char *) "gap", NULL
40828 };
40829
40830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40832 if (SWIG_arg_fail(1)) SWIG_fail;
40833 {
40834 arg2 = (int)(SWIG_As_int(obj1));
40835 if (SWIG_arg_fail(2)) SWIG_fail;
40836 }
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->SetVGap(arg2);
40840
40841 wxPyEndAllowThreads(__tstate);
40842 if (PyErr_Occurred()) SWIG_fail;
40843 }
40844 Py_INCREF(Py_None); resultobj = Py_None;
40845 return resultobj;
40846 fail:
40847 return NULL;
40848 }
40849
40850
40851 static PyObject *_wrap_wxGridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40852 PyObject *resultobj;
40853 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40854 int arg2 ;
40855 PyObject * obj0 = 0 ;
40856 PyObject * obj1 = 0 ;
40857 char *kwnames[] = {
40858 (char *) "self",(char *) "gap", NULL
40859 };
40860
40861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40863 if (SWIG_arg_fail(1)) SWIG_fail;
40864 {
40865 arg2 = (int)(SWIG_As_int(obj1));
40866 if (SWIG_arg_fail(2)) SWIG_fail;
40867 }
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 (arg1)->SetHGap(arg2);
40871
40872 wxPyEndAllowThreads(__tstate);
40873 if (PyErr_Occurred()) SWIG_fail;
40874 }
40875 Py_INCREF(Py_None); resultobj = Py_None;
40876 return resultobj;
40877 fail:
40878 return NULL;
40879 }
40880
40881
40882 static PyObject *_wrap_wxGridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40883 PyObject *resultobj;
40884 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40885 int result;
40886 PyObject * obj0 = 0 ;
40887 char *kwnames[] = {
40888 (char *) "self", NULL
40889 };
40890
40891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGridSizer_GetCols",kwnames,&obj0)) goto fail;
40892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40893 if (SWIG_arg_fail(1)) SWIG_fail;
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 result = (int)(arg1)->GetCols();
40897
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 {
40902 resultobj = SWIG_From_int((int)(result));
40903 }
40904 return resultobj;
40905 fail:
40906 return NULL;
40907 }
40908
40909
40910 static PyObject *_wrap_wxGridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40911 PyObject *resultobj;
40912 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40913 int result;
40914 PyObject * obj0 = 0 ;
40915 char *kwnames[] = {
40916 (char *) "self", NULL
40917 };
40918
40919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGridSizer_GetRows",kwnames,&obj0)) goto fail;
40920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40921 if (SWIG_arg_fail(1)) SWIG_fail;
40922 {
40923 PyThreadState* __tstate = wxPyBeginAllowThreads();
40924 result = (int)(arg1)->GetRows();
40925
40926 wxPyEndAllowThreads(__tstate);
40927 if (PyErr_Occurred()) SWIG_fail;
40928 }
40929 {
40930 resultobj = SWIG_From_int((int)(result));
40931 }
40932 return resultobj;
40933 fail:
40934 return NULL;
40935 }
40936
40937
40938 static PyObject *_wrap_wxGridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40939 PyObject *resultobj;
40940 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40941 int result;
40942 PyObject * obj0 = 0 ;
40943 char *kwnames[] = {
40944 (char *) "self", NULL
40945 };
40946
40947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGridSizer_GetVGap",kwnames,&obj0)) goto fail;
40948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40949 if (SWIG_arg_fail(1)) SWIG_fail;
40950 {
40951 PyThreadState* __tstate = wxPyBeginAllowThreads();
40952 result = (int)(arg1)->GetVGap();
40953
40954 wxPyEndAllowThreads(__tstate);
40955 if (PyErr_Occurred()) SWIG_fail;
40956 }
40957 {
40958 resultobj = SWIG_From_int((int)(result));
40959 }
40960 return resultobj;
40961 fail:
40962 return NULL;
40963 }
40964
40965
40966 static PyObject *_wrap_wxGridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj;
40968 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40969 int result;
40970 PyObject * obj0 = 0 ;
40971 char *kwnames[] = {
40972 (char *) "self", NULL
40973 };
40974
40975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGridSizer_GetHGap",kwnames,&obj0)) goto fail;
40976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40977 if (SWIG_arg_fail(1)) SWIG_fail;
40978 {
40979 PyThreadState* __tstate = wxPyBeginAllowThreads();
40980 result = (int)(arg1)->GetHGap();
40981
40982 wxPyEndAllowThreads(__tstate);
40983 if (PyErr_Occurred()) SWIG_fail;
40984 }
40985 {
40986 resultobj = SWIG_From_int((int)(result));
40987 }
40988 return resultobj;
40989 fail:
40990 return NULL;
40991 }
40992
40993
40994 static PyObject * wxGridSizer_swigregister(PyObject *, PyObject *args) {
40995 PyObject *obj;
40996 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40997 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40998 Py_INCREF(obj);
40999 return Py_BuildValue((char *)"");
41000 }
41001 static PyObject *_wrap_new_wxFlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41002 PyObject *resultobj;
41003 int arg1 = (int) 1 ;
41004 int arg2 = (int) 0 ;
41005 int arg3 = (int) 0 ;
41006 int arg4 = (int) 0 ;
41007 wxFlexGridSizer *result;
41008 PyObject * obj0 = 0 ;
41009 PyObject * obj1 = 0 ;
41010 PyObject * obj2 = 0 ;
41011 PyObject * obj3 = 0 ;
41012 char *kwnames[] = {
41013 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41014 };
41015
41016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_wxFlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41017 if (obj0) {
41018 {
41019 arg1 = (int)(SWIG_As_int(obj0));
41020 if (SWIG_arg_fail(1)) SWIG_fail;
41021 }
41022 }
41023 if (obj1) {
41024 {
41025 arg2 = (int)(SWIG_As_int(obj1));
41026 if (SWIG_arg_fail(2)) SWIG_fail;
41027 }
41028 }
41029 if (obj2) {
41030 {
41031 arg3 = (int)(SWIG_As_int(obj2));
41032 if (SWIG_arg_fail(3)) SWIG_fail;
41033 }
41034 }
41035 if (obj3) {
41036 {
41037 arg4 = (int)(SWIG_As_int(obj3));
41038 if (SWIG_arg_fail(4)) SWIG_fail;
41039 }
41040 }
41041 {
41042 PyThreadState* __tstate = wxPyBeginAllowThreads();
41043 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41044
41045 wxPyEndAllowThreads(__tstate);
41046 if (PyErr_Occurred()) SWIG_fail;
41047 }
41048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 static PyObject *_wrap_wxFlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj;
41057 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41058 size_t arg2 ;
41059 int arg3 = (int) 0 ;
41060 PyObject * obj0 = 0 ;
41061 PyObject * obj1 = 0 ;
41062 PyObject * obj2 = 0 ;
41063 char *kwnames[] = {
41064 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41065 };
41066
41067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxFlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41069 if (SWIG_arg_fail(1)) SWIG_fail;
41070 {
41071 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41072 if (SWIG_arg_fail(2)) SWIG_fail;
41073 }
41074 if (obj2) {
41075 {
41076 arg3 = (int)(SWIG_As_int(obj2));
41077 if (SWIG_arg_fail(3)) SWIG_fail;
41078 }
41079 }
41080 {
41081 PyThreadState* __tstate = wxPyBeginAllowThreads();
41082 (arg1)->AddGrowableRow(arg2,arg3);
41083
41084 wxPyEndAllowThreads(__tstate);
41085 if (PyErr_Occurred()) SWIG_fail;
41086 }
41087 Py_INCREF(Py_None); resultobj = Py_None;
41088 return resultobj;
41089 fail:
41090 return NULL;
41091 }
41092
41093
41094 static PyObject *_wrap_wxFlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41095 PyObject *resultobj;
41096 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41097 size_t arg2 ;
41098 PyObject * obj0 = 0 ;
41099 PyObject * obj1 = 0 ;
41100 char *kwnames[] = {
41101 (char *) "self",(char *) "idx", NULL
41102 };
41103
41104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxFlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41106 if (SWIG_arg_fail(1)) SWIG_fail;
41107 {
41108 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41109 if (SWIG_arg_fail(2)) SWIG_fail;
41110 }
41111 {
41112 PyThreadState* __tstate = wxPyBeginAllowThreads();
41113 (arg1)->RemoveGrowableRow(arg2);
41114
41115 wxPyEndAllowThreads(__tstate);
41116 if (PyErr_Occurred()) SWIG_fail;
41117 }
41118 Py_INCREF(Py_None); resultobj = Py_None;
41119 return resultobj;
41120 fail:
41121 return NULL;
41122 }
41123
41124
41125 static PyObject *_wrap_wxFlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41126 PyObject *resultobj;
41127 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41128 size_t arg2 ;
41129 int arg3 = (int) 0 ;
41130 PyObject * obj0 = 0 ;
41131 PyObject * obj1 = 0 ;
41132 PyObject * obj2 = 0 ;
41133 char *kwnames[] = {
41134 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41135 };
41136
41137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxFlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41139 if (SWIG_arg_fail(1)) SWIG_fail;
41140 {
41141 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41142 if (SWIG_arg_fail(2)) SWIG_fail;
41143 }
41144 if (obj2) {
41145 {
41146 arg3 = (int)(SWIG_As_int(obj2));
41147 if (SWIG_arg_fail(3)) SWIG_fail;
41148 }
41149 }
41150 {
41151 PyThreadState* __tstate = wxPyBeginAllowThreads();
41152 (arg1)->AddGrowableCol(arg2,arg3);
41153
41154 wxPyEndAllowThreads(__tstate);
41155 if (PyErr_Occurred()) SWIG_fail;
41156 }
41157 Py_INCREF(Py_None); resultobj = Py_None;
41158 return resultobj;
41159 fail:
41160 return NULL;
41161 }
41162
41163
41164 static PyObject *_wrap_wxFlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41165 PyObject *resultobj;
41166 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41167 size_t arg2 ;
41168 PyObject * obj0 = 0 ;
41169 PyObject * obj1 = 0 ;
41170 char *kwnames[] = {
41171 (char *) "self",(char *) "idx", NULL
41172 };
41173
41174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxFlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41176 if (SWIG_arg_fail(1)) SWIG_fail;
41177 {
41178 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41179 if (SWIG_arg_fail(2)) SWIG_fail;
41180 }
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 (arg1)->RemoveGrowableCol(arg2);
41184
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 Py_INCREF(Py_None); resultobj = Py_None;
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 static PyObject *_wrap_wxFlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj;
41197 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41198 int arg2 ;
41199 PyObject * obj0 = 0 ;
41200 PyObject * obj1 = 0 ;
41201 char *kwnames[] = {
41202 (char *) "self",(char *) "direction", NULL
41203 };
41204
41205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxFlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41207 if (SWIG_arg_fail(1)) SWIG_fail;
41208 {
41209 arg2 = (int)(SWIG_As_int(obj1));
41210 if (SWIG_arg_fail(2)) SWIG_fail;
41211 }
41212 {
41213 PyThreadState* __tstate = wxPyBeginAllowThreads();
41214 (arg1)->SetFlexibleDirection(arg2);
41215
41216 wxPyEndAllowThreads(__tstate);
41217 if (PyErr_Occurred()) SWIG_fail;
41218 }
41219 Py_INCREF(Py_None); resultobj = Py_None;
41220 return resultobj;
41221 fail:
41222 return NULL;
41223 }
41224
41225
41226 static PyObject *_wrap_wxFlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41227 PyObject *resultobj;
41228 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41229 int result;
41230 PyObject * obj0 = 0 ;
41231 char *kwnames[] = {
41232 (char *) "self", NULL
41233 };
41234
41235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41237 if (SWIG_arg_fail(1)) SWIG_fail;
41238 {
41239 PyThreadState* __tstate = wxPyBeginAllowThreads();
41240 result = (int)(arg1)->GetFlexibleDirection();
41241
41242 wxPyEndAllowThreads(__tstate);
41243 if (PyErr_Occurred()) SWIG_fail;
41244 }
41245 {
41246 resultobj = SWIG_From_int((int)(result));
41247 }
41248 return resultobj;
41249 fail:
41250 return NULL;
41251 }
41252
41253
41254 static PyObject *_wrap_wxFlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41255 PyObject *resultobj;
41256 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41257 wxFlexSizerGrowMode arg2 ;
41258 PyObject * obj0 = 0 ;
41259 PyObject * obj1 = 0 ;
41260 char *kwnames[] = {
41261 (char *) "self",(char *) "mode", NULL
41262 };
41263
41264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxFlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41266 if (SWIG_arg_fail(1)) SWIG_fail;
41267 {
41268 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41269 if (SWIG_arg_fail(2)) SWIG_fail;
41270 }
41271 {
41272 PyThreadState* __tstate = wxPyBeginAllowThreads();
41273 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41274
41275 wxPyEndAllowThreads(__tstate);
41276 if (PyErr_Occurred()) SWIG_fail;
41277 }
41278 Py_INCREF(Py_None); resultobj = Py_None;
41279 return resultobj;
41280 fail:
41281 return NULL;
41282 }
41283
41284
41285 static PyObject *_wrap_wxFlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41286 PyObject *resultobj;
41287 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41288 wxFlexSizerGrowMode result;
41289 PyObject * obj0 = 0 ;
41290 char *kwnames[] = {
41291 (char *) "self", NULL
41292 };
41293
41294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41296 if (SWIG_arg_fail(1)) SWIG_fail;
41297 {
41298 PyThreadState* __tstate = wxPyBeginAllowThreads();
41299 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41300
41301 wxPyEndAllowThreads(__tstate);
41302 if (PyErr_Occurred()) SWIG_fail;
41303 }
41304 resultobj = SWIG_From_int((result));
41305 return resultobj;
41306 fail:
41307 return NULL;
41308 }
41309
41310
41311 static PyObject *_wrap_wxFlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41312 PyObject *resultobj;
41313 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41314 wxArrayInt *result;
41315 PyObject * obj0 = 0 ;
41316 char *kwnames[] = {
41317 (char *) "self", NULL
41318 };
41319
41320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41322 if (SWIG_arg_fail(1)) SWIG_fail;
41323 {
41324 PyThreadState* __tstate = wxPyBeginAllowThreads();
41325 {
41326 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41327 result = (wxArrayInt *) &_result_ref;
41328 }
41329
41330 wxPyEndAllowThreads(__tstate);
41331 if (PyErr_Occurred()) SWIG_fail;
41332 }
41333 {
41334 resultobj = PyList_New(0);
41335 size_t idx;
41336 for (idx = 0; idx < result->GetCount(); idx += 1) {
41337 PyObject* val = PyInt_FromLong( result->Item(idx) );
41338 PyList_Append(resultobj, val);
41339 Py_DECREF(val);
41340 }
41341 }
41342 return resultobj;
41343 fail:
41344 return NULL;
41345 }
41346
41347
41348 static PyObject *_wrap_wxFlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41349 PyObject *resultobj;
41350 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41351 wxArrayInt *result;
41352 PyObject * obj0 = 0 ;
41353 char *kwnames[] = {
41354 (char *) "self", NULL
41355 };
41356
41357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxFlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41359 if (SWIG_arg_fail(1)) SWIG_fail;
41360 {
41361 PyThreadState* __tstate = wxPyBeginAllowThreads();
41362 {
41363 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41364 result = (wxArrayInt *) &_result_ref;
41365 }
41366
41367 wxPyEndAllowThreads(__tstate);
41368 if (PyErr_Occurred()) SWIG_fail;
41369 }
41370 {
41371 resultobj = PyList_New(0);
41372 size_t idx;
41373 for (idx = 0; idx < result->GetCount(); idx += 1) {
41374 PyObject* val = PyInt_FromLong( result->Item(idx) );
41375 PyList_Append(resultobj, val);
41376 Py_DECREF(val);
41377 }
41378 }
41379 return resultobj;
41380 fail:
41381 return NULL;
41382 }
41383
41384
41385 static PyObject * wxFlexGridSizer_swigregister(PyObject *, PyObject *args) {
41386 PyObject *obj;
41387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41388 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41389 Py_INCREF(obj);
41390 return Py_BuildValue((char *)"");
41391 }
41392 static PyObject *_wrap_new_wxStdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj;
41394 wxStdDialogButtonSizer *result;
41395 char *kwnames[] = {
41396 NULL
41397 };
41398
41399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxStdDialogButtonSizer",kwnames)) goto fail;
41400 {
41401 PyThreadState* __tstate = wxPyBeginAllowThreads();
41402 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41403
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 static PyObject *_wrap_wxStdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj;
41416 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41417 wxButton *arg2 = (wxButton *) 0 ;
41418 PyObject * obj0 = 0 ;
41419 PyObject * obj1 = 0 ;
41420 char *kwnames[] = {
41421 (char *) "self",(char *) "button", NULL
41422 };
41423
41424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxStdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41426 if (SWIG_arg_fail(1)) SWIG_fail;
41427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41428 if (SWIG_arg_fail(2)) SWIG_fail;
41429 {
41430 PyThreadState* __tstate = wxPyBeginAllowThreads();
41431 (arg1)->AddButton(arg2);
41432
41433 wxPyEndAllowThreads(__tstate);
41434 if (PyErr_Occurred()) SWIG_fail;
41435 }
41436 Py_INCREF(Py_None); resultobj = Py_None;
41437 return resultobj;
41438 fail:
41439 return NULL;
41440 }
41441
41442
41443 static PyObject *_wrap_wxStdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41444 PyObject *resultobj;
41445 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41446 PyObject * obj0 = 0 ;
41447 char *kwnames[] = {
41448 (char *) "self", NULL
41449 };
41450
41451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41453 if (SWIG_arg_fail(1)) SWIG_fail;
41454 {
41455 PyThreadState* __tstate = wxPyBeginAllowThreads();
41456 (arg1)->Realize();
41457
41458 wxPyEndAllowThreads(__tstate);
41459 if (PyErr_Occurred()) SWIG_fail;
41460 }
41461 Py_INCREF(Py_None); resultobj = Py_None;
41462 return resultobj;
41463 fail:
41464 return NULL;
41465 }
41466
41467
41468 static PyObject *_wrap_wxStdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41469 PyObject *resultobj;
41470 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41471 wxButton *arg2 = (wxButton *) 0 ;
41472 PyObject * obj0 = 0 ;
41473 PyObject * obj1 = 0 ;
41474 char *kwnames[] = {
41475 (char *) "self",(char *) "button", NULL
41476 };
41477
41478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxStdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41480 if (SWIG_arg_fail(1)) SWIG_fail;
41481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41482 if (SWIG_arg_fail(2)) SWIG_fail;
41483 {
41484 PyThreadState* __tstate = wxPyBeginAllowThreads();
41485 (arg1)->SetAffirmativeButton(arg2);
41486
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 Py_INCREF(Py_None); resultobj = Py_None;
41491 return resultobj;
41492 fail:
41493 return NULL;
41494 }
41495
41496
41497 static PyObject *_wrap_wxStdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41498 PyObject *resultobj;
41499 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41500 wxButton *arg2 = (wxButton *) 0 ;
41501 PyObject * obj0 = 0 ;
41502 PyObject * obj1 = 0 ;
41503 char *kwnames[] = {
41504 (char *) "self",(char *) "button", NULL
41505 };
41506
41507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxStdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41509 if (SWIG_arg_fail(1)) SWIG_fail;
41510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41511 if (SWIG_arg_fail(2)) SWIG_fail;
41512 {
41513 PyThreadState* __tstate = wxPyBeginAllowThreads();
41514 (arg1)->SetNegativeButton(arg2);
41515
41516 wxPyEndAllowThreads(__tstate);
41517 if (PyErr_Occurred()) SWIG_fail;
41518 }
41519 Py_INCREF(Py_None); resultobj = Py_None;
41520 return resultobj;
41521 fail:
41522 return NULL;
41523 }
41524
41525
41526 static PyObject *_wrap_wxStdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41527 PyObject *resultobj;
41528 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41529 wxButton *arg2 = (wxButton *) 0 ;
41530 PyObject * obj0 = 0 ;
41531 PyObject * obj1 = 0 ;
41532 char *kwnames[] = {
41533 (char *) "self",(char *) "button", NULL
41534 };
41535
41536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxStdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41538 if (SWIG_arg_fail(1)) SWIG_fail;
41539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41540 if (SWIG_arg_fail(2)) SWIG_fail;
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 (arg1)->SetCancelButton(arg2);
41544
41545 wxPyEndAllowThreads(__tstate);
41546 if (PyErr_Occurred()) SWIG_fail;
41547 }
41548 Py_INCREF(Py_None); resultobj = Py_None;
41549 return resultobj;
41550 fail:
41551 return NULL;
41552 }
41553
41554
41555 static PyObject *_wrap_wxStdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41556 PyObject *resultobj;
41557 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41558 wxButton *result;
41559 PyObject * obj0 = 0 ;
41560 char *kwnames[] = {
41561 (char *) "self", NULL
41562 };
41563
41564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41566 if (SWIG_arg_fail(1)) SWIG_fail;
41567 {
41568 PyThreadState* __tstate = wxPyBeginAllowThreads();
41569 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41570
41571 wxPyEndAllowThreads(__tstate);
41572 if (PyErr_Occurred()) SWIG_fail;
41573 }
41574 {
41575 resultobj = wxPyMake_wxObject(result, 0);
41576 }
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 static PyObject *_wrap_wxStdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj;
41585 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41586 wxButton *result;
41587 PyObject * obj0 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41598
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 {
41603 resultobj = wxPyMake_wxObject(result, 0);
41604 }
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 static PyObject *_wrap_wxStdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41612 PyObject *resultobj;
41613 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41614 wxButton *result;
41615 PyObject * obj0 = 0 ;
41616 char *kwnames[] = {
41617 (char *) "self", NULL
41618 };
41619
41620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41622 if (SWIG_arg_fail(1)) SWIG_fail;
41623 {
41624 PyThreadState* __tstate = wxPyBeginAllowThreads();
41625 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41626
41627 wxPyEndAllowThreads(__tstate);
41628 if (PyErr_Occurred()) SWIG_fail;
41629 }
41630 {
41631 resultobj = wxPyMake_wxObject(result, 0);
41632 }
41633 return resultobj;
41634 fail:
41635 return NULL;
41636 }
41637
41638
41639 static PyObject *_wrap_wxStdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41640 PyObject *resultobj;
41641 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41642 wxButton *result;
41643 PyObject * obj0 = 0 ;
41644 char *kwnames[] = {
41645 (char *) "self", NULL
41646 };
41647
41648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41650 if (SWIG_arg_fail(1)) SWIG_fail;
41651 {
41652 PyThreadState* __tstate = wxPyBeginAllowThreads();
41653 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41654
41655 wxPyEndAllowThreads(__tstate);
41656 if (PyErr_Occurred()) SWIG_fail;
41657 }
41658 {
41659 resultobj = wxPyMake_wxObject(result, 0);
41660 }
41661 return resultobj;
41662 fail:
41663 return NULL;
41664 }
41665
41666
41667 static PyObject *_wrap_wxStdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41668 PyObject *resultobj;
41669 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41670 wxButton *result;
41671 PyObject * obj0 = 0 ;
41672 char *kwnames[] = {
41673 (char *) "self", NULL
41674 };
41675
41676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxStdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41678 if (SWIG_arg_fail(1)) SWIG_fail;
41679 {
41680 PyThreadState* __tstate = wxPyBeginAllowThreads();
41681 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41682
41683 wxPyEndAllowThreads(__tstate);
41684 if (PyErr_Occurred()) SWIG_fail;
41685 }
41686 {
41687 resultobj = wxPyMake_wxObject(result, 0);
41688 }
41689 return resultobj;
41690 fail:
41691 return NULL;
41692 }
41693
41694
41695 static PyObject * wxStdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41696 PyObject *obj;
41697 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41698 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41699 Py_INCREF(obj);
41700 return Py_BuildValue((char *)"");
41701 }
41702 static PyObject *_wrap_new_wxGBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41703 PyObject *resultobj;
41704 int arg1 = (int) 0 ;
41705 int arg2 = (int) 0 ;
41706 wxGBPosition *result;
41707 PyObject * obj0 = 0 ;
41708 PyObject * obj1 = 0 ;
41709 char *kwnames[] = {
41710 (char *) "row",(char *) "col", NULL
41711 };
41712
41713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxGBPosition",kwnames,&obj0,&obj1)) goto fail;
41714 if (obj0) {
41715 {
41716 arg1 = (int)(SWIG_As_int(obj0));
41717 if (SWIG_arg_fail(1)) SWIG_fail;
41718 }
41719 }
41720 if (obj1) {
41721 {
41722 arg2 = (int)(SWIG_As_int(obj1));
41723 if (SWIG_arg_fail(2)) SWIG_fail;
41724 }
41725 }
41726 {
41727 PyThreadState* __tstate = wxPyBeginAllowThreads();
41728 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41729
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41734 return resultobj;
41735 fail:
41736 return NULL;
41737 }
41738
41739
41740 static PyObject *_wrap_wxGBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41741 PyObject *resultobj;
41742 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41743 int result;
41744 PyObject * obj0 = 0 ;
41745 char *kwnames[] = {
41746 (char *) "self", NULL
41747 };
41748
41749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBPosition_GetRow",kwnames,&obj0)) goto fail;
41750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41751 if (SWIG_arg_fail(1)) SWIG_fail;
41752 {
41753 PyThreadState* __tstate = wxPyBeginAllowThreads();
41754 result = (int)((wxGBPosition const *)arg1)->GetRow();
41755
41756 wxPyEndAllowThreads(__tstate);
41757 if (PyErr_Occurred()) SWIG_fail;
41758 }
41759 {
41760 resultobj = SWIG_From_int((int)(result));
41761 }
41762 return resultobj;
41763 fail:
41764 return NULL;
41765 }
41766
41767
41768 static PyObject *_wrap_wxGBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41769 PyObject *resultobj;
41770 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41771 int result;
41772 PyObject * obj0 = 0 ;
41773 char *kwnames[] = {
41774 (char *) "self", NULL
41775 };
41776
41777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBPosition_GetCol",kwnames,&obj0)) goto fail;
41778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41779 if (SWIG_arg_fail(1)) SWIG_fail;
41780 {
41781 PyThreadState* __tstate = wxPyBeginAllowThreads();
41782 result = (int)((wxGBPosition const *)arg1)->GetCol();
41783
41784 wxPyEndAllowThreads(__tstate);
41785 if (PyErr_Occurred()) SWIG_fail;
41786 }
41787 {
41788 resultobj = SWIG_From_int((int)(result));
41789 }
41790 return resultobj;
41791 fail:
41792 return NULL;
41793 }
41794
41795
41796 static PyObject *_wrap_wxGBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41797 PyObject *resultobj;
41798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41799 int arg2 ;
41800 PyObject * obj0 = 0 ;
41801 PyObject * obj1 = 0 ;
41802 char *kwnames[] = {
41803 (char *) "self",(char *) "row", NULL
41804 };
41805
41806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41808 if (SWIG_arg_fail(1)) SWIG_fail;
41809 {
41810 arg2 = (int)(SWIG_As_int(obj1));
41811 if (SWIG_arg_fail(2)) SWIG_fail;
41812 }
41813 {
41814 PyThreadState* __tstate = wxPyBeginAllowThreads();
41815 (arg1)->SetRow(arg2);
41816
41817 wxPyEndAllowThreads(__tstate);
41818 if (PyErr_Occurred()) SWIG_fail;
41819 }
41820 Py_INCREF(Py_None); resultobj = Py_None;
41821 return resultobj;
41822 fail:
41823 return NULL;
41824 }
41825
41826
41827 static PyObject *_wrap_wxGBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41828 PyObject *resultobj;
41829 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41830 int arg2 ;
41831 PyObject * obj0 = 0 ;
41832 PyObject * obj1 = 0 ;
41833 char *kwnames[] = {
41834 (char *) "self",(char *) "col", NULL
41835 };
41836
41837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41839 if (SWIG_arg_fail(1)) SWIG_fail;
41840 {
41841 arg2 = (int)(SWIG_As_int(obj1));
41842 if (SWIG_arg_fail(2)) SWIG_fail;
41843 }
41844 {
41845 PyThreadState* __tstate = wxPyBeginAllowThreads();
41846 (arg1)->SetCol(arg2);
41847
41848 wxPyEndAllowThreads(__tstate);
41849 if (PyErr_Occurred()) SWIG_fail;
41850 }
41851 Py_INCREF(Py_None); resultobj = Py_None;
41852 return resultobj;
41853 fail:
41854 return NULL;
41855 }
41856
41857
41858 static PyObject *_wrap_wxGBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41859 PyObject *resultobj;
41860 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41861 wxGBPosition *arg2 = 0 ;
41862 bool result;
41863 wxGBPosition temp2 ;
41864 PyObject * obj0 = 0 ;
41865 PyObject * obj1 = 0 ;
41866 char *kwnames[] = {
41867 (char *) "self",(char *) "other", NULL
41868 };
41869
41870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41872 if (SWIG_arg_fail(1)) SWIG_fail;
41873 {
41874 arg2 = &temp2;
41875 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41876 }
41877 {
41878 PyThreadState* __tstate = wxPyBeginAllowThreads();
41879 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41880
41881 wxPyEndAllowThreads(__tstate);
41882 if (PyErr_Occurred()) SWIG_fail;
41883 }
41884 {
41885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41886 }
41887 return resultobj;
41888 fail:
41889 return NULL;
41890 }
41891
41892
41893 static PyObject *_wrap_wxGBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41894 PyObject *resultobj;
41895 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41896 wxGBPosition *arg2 = 0 ;
41897 bool result;
41898 wxGBPosition temp2 ;
41899 PyObject * obj0 = 0 ;
41900 PyObject * obj1 = 0 ;
41901 char *kwnames[] = {
41902 (char *) "self",(char *) "other", NULL
41903 };
41904
41905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41907 if (SWIG_arg_fail(1)) SWIG_fail;
41908 {
41909 arg2 = &temp2;
41910 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41911 }
41912 {
41913 PyThreadState* __tstate = wxPyBeginAllowThreads();
41914 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41915
41916 wxPyEndAllowThreads(__tstate);
41917 if (PyErr_Occurred()) SWIG_fail;
41918 }
41919 {
41920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41921 }
41922 return resultobj;
41923 fail:
41924 return NULL;
41925 }
41926
41927
41928 static PyObject *_wrap_wxGBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41929 PyObject *resultobj;
41930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41931 int arg2 = (int) 0 ;
41932 int arg3 = (int) 0 ;
41933 PyObject * obj0 = 0 ;
41934 PyObject * obj1 = 0 ;
41935 PyObject * obj2 = 0 ;
41936 char *kwnames[] = {
41937 (char *) "self",(char *) "row",(char *) "col", NULL
41938 };
41939
41940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:wxGBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41942 if (SWIG_arg_fail(1)) SWIG_fail;
41943 if (obj1) {
41944 {
41945 arg2 = (int)(SWIG_As_int(obj1));
41946 if (SWIG_arg_fail(2)) SWIG_fail;
41947 }
41948 }
41949 if (obj2) {
41950 {
41951 arg3 = (int)(SWIG_As_int(obj2));
41952 if (SWIG_arg_fail(3)) SWIG_fail;
41953 }
41954 }
41955 {
41956 PyThreadState* __tstate = wxPyBeginAllowThreads();
41957 wxGBPosition_Set(arg1,arg2,arg3);
41958
41959 wxPyEndAllowThreads(__tstate);
41960 if (PyErr_Occurred()) SWIG_fail;
41961 }
41962 Py_INCREF(Py_None); resultobj = Py_None;
41963 return resultobj;
41964 fail:
41965 return NULL;
41966 }
41967
41968
41969 static PyObject *_wrap_wxGBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41970 PyObject *resultobj;
41971 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41972 PyObject *result;
41973 PyObject * obj0 = 0 ;
41974 char *kwnames[] = {
41975 (char *) "self", NULL
41976 };
41977
41978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBPosition_Get",kwnames,&obj0)) goto fail;
41979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41980 if (SWIG_arg_fail(1)) SWIG_fail;
41981 {
41982 PyThreadState* __tstate = wxPyBeginAllowThreads();
41983 result = (PyObject *)wxGBPosition_Get(arg1);
41984
41985 wxPyEndAllowThreads(__tstate);
41986 if (PyErr_Occurred()) SWIG_fail;
41987 }
41988 resultobj = result;
41989 return resultobj;
41990 fail:
41991 return NULL;
41992 }
41993
41994
41995 static PyObject * wxGBPosition_swigregister(PyObject *, PyObject *args) {
41996 PyObject *obj;
41997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41998 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41999 Py_INCREF(obj);
42000 return Py_BuildValue((char *)"");
42001 }
42002 static PyObject *_wrap_new_wxGBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42003 PyObject *resultobj;
42004 int arg1 = (int) 1 ;
42005 int arg2 = (int) 1 ;
42006 wxGBSpan *result;
42007 PyObject * obj0 = 0 ;
42008 PyObject * obj1 = 0 ;
42009 char *kwnames[] = {
42010 (char *) "rowspan",(char *) "colspan", NULL
42011 };
42012
42013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxGBSpan",kwnames,&obj0,&obj1)) goto fail;
42014 if (obj0) {
42015 {
42016 arg1 = (int)(SWIG_As_int(obj0));
42017 if (SWIG_arg_fail(1)) SWIG_fail;
42018 }
42019 }
42020 if (obj1) {
42021 {
42022 arg2 = (int)(SWIG_As_int(obj1));
42023 if (SWIG_arg_fail(2)) SWIG_fail;
42024 }
42025 }
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42029
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 static PyObject *_wrap_wxGBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42041 PyObject *resultobj;
42042 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42043 int result;
42044 PyObject * obj0 = 0 ;
42045 char *kwnames[] = {
42046 (char *) "self", NULL
42047 };
42048
42049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42051 if (SWIG_arg_fail(1)) SWIG_fail;
42052 {
42053 PyThreadState* __tstate = wxPyBeginAllowThreads();
42054 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42055
42056 wxPyEndAllowThreads(__tstate);
42057 if (PyErr_Occurred()) SWIG_fail;
42058 }
42059 {
42060 resultobj = SWIG_From_int((int)(result));
42061 }
42062 return resultobj;
42063 fail:
42064 return NULL;
42065 }
42066
42067
42068 static PyObject *_wrap_wxGBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42069 PyObject *resultobj;
42070 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42071 int result;
42072 PyObject * obj0 = 0 ;
42073 char *kwnames[] = {
42074 (char *) "self", NULL
42075 };
42076
42077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSpan_GetColspan",kwnames,&obj0)) goto fail;
42078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42079 if (SWIG_arg_fail(1)) SWIG_fail;
42080 {
42081 PyThreadState* __tstate = wxPyBeginAllowThreads();
42082 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42083
42084 wxPyEndAllowThreads(__tstate);
42085 if (PyErr_Occurred()) SWIG_fail;
42086 }
42087 {
42088 resultobj = SWIG_From_int((int)(result));
42089 }
42090 return resultobj;
42091 fail:
42092 return NULL;
42093 }
42094
42095
42096 static PyObject *_wrap_wxGBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj;
42098 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42099 int arg2 ;
42100 PyObject * obj0 = 0 ;
42101 PyObject * obj1 = 0 ;
42102 char *kwnames[] = {
42103 (char *) "self",(char *) "rowspan", NULL
42104 };
42105
42106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42108 if (SWIG_arg_fail(1)) SWIG_fail;
42109 {
42110 arg2 = (int)(SWIG_As_int(obj1));
42111 if (SWIG_arg_fail(2)) SWIG_fail;
42112 }
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 (arg1)->SetRowspan(arg2);
42116
42117 wxPyEndAllowThreads(__tstate);
42118 if (PyErr_Occurred()) SWIG_fail;
42119 }
42120 Py_INCREF(Py_None); resultobj = Py_None;
42121 return resultobj;
42122 fail:
42123 return NULL;
42124 }
42125
42126
42127 static PyObject *_wrap_wxGBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42128 PyObject *resultobj;
42129 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42130 int arg2 ;
42131 PyObject * obj0 = 0 ;
42132 PyObject * obj1 = 0 ;
42133 char *kwnames[] = {
42134 (char *) "self",(char *) "colspan", NULL
42135 };
42136
42137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42139 if (SWIG_arg_fail(1)) SWIG_fail;
42140 {
42141 arg2 = (int)(SWIG_As_int(obj1));
42142 if (SWIG_arg_fail(2)) SWIG_fail;
42143 }
42144 {
42145 PyThreadState* __tstate = wxPyBeginAllowThreads();
42146 (arg1)->SetColspan(arg2);
42147
42148 wxPyEndAllowThreads(__tstate);
42149 if (PyErr_Occurred()) SWIG_fail;
42150 }
42151 Py_INCREF(Py_None); resultobj = Py_None;
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 static PyObject *_wrap_wxGBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42159 PyObject *resultobj;
42160 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42161 wxGBSpan *arg2 = 0 ;
42162 bool result;
42163 wxGBSpan temp2 ;
42164 PyObject * obj0 = 0 ;
42165 PyObject * obj1 = 0 ;
42166 char *kwnames[] = {
42167 (char *) "self",(char *) "other", NULL
42168 };
42169
42170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42172 if (SWIG_arg_fail(1)) SWIG_fail;
42173 {
42174 arg2 = &temp2;
42175 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42176 }
42177 {
42178 PyThreadState* __tstate = wxPyBeginAllowThreads();
42179 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42180
42181 wxPyEndAllowThreads(__tstate);
42182 if (PyErr_Occurred()) SWIG_fail;
42183 }
42184 {
42185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42186 }
42187 return resultobj;
42188 fail:
42189 return NULL;
42190 }
42191
42192
42193 static PyObject *_wrap_wxGBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42194 PyObject *resultobj;
42195 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42196 wxGBSpan *arg2 = 0 ;
42197 bool result;
42198 wxGBSpan temp2 ;
42199 PyObject * obj0 = 0 ;
42200 PyObject * obj1 = 0 ;
42201 char *kwnames[] = {
42202 (char *) "self",(char *) "other", NULL
42203 };
42204
42205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42207 if (SWIG_arg_fail(1)) SWIG_fail;
42208 {
42209 arg2 = &temp2;
42210 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42211 }
42212 {
42213 PyThreadState* __tstate = wxPyBeginAllowThreads();
42214 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42215
42216 wxPyEndAllowThreads(__tstate);
42217 if (PyErr_Occurred()) SWIG_fail;
42218 }
42219 {
42220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42221 }
42222 return resultobj;
42223 fail:
42224 return NULL;
42225 }
42226
42227
42228 static PyObject *_wrap_wxGBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42229 PyObject *resultobj;
42230 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42231 int arg2 = (int) 1 ;
42232 int arg3 = (int) 1 ;
42233 PyObject * obj0 = 0 ;
42234 PyObject * obj1 = 0 ;
42235 PyObject * obj2 = 0 ;
42236 char *kwnames[] = {
42237 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42238 };
42239
42240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:wxGBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42242 if (SWIG_arg_fail(1)) SWIG_fail;
42243 if (obj1) {
42244 {
42245 arg2 = (int)(SWIG_As_int(obj1));
42246 if (SWIG_arg_fail(2)) SWIG_fail;
42247 }
42248 }
42249 if (obj2) {
42250 {
42251 arg3 = (int)(SWIG_As_int(obj2));
42252 if (SWIG_arg_fail(3)) SWIG_fail;
42253 }
42254 }
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 wxGBSpan_Set(arg1,arg2,arg3);
42258
42259 wxPyEndAllowThreads(__tstate);
42260 if (PyErr_Occurred()) SWIG_fail;
42261 }
42262 Py_INCREF(Py_None); resultobj = Py_None;
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 static PyObject *_wrap_wxGBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42270 PyObject *resultobj;
42271 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42272 PyObject *result;
42273 PyObject * obj0 = 0 ;
42274 char *kwnames[] = {
42275 (char *) "self", NULL
42276 };
42277
42278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSpan_Get",kwnames,&obj0)) goto fail;
42279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42280 if (SWIG_arg_fail(1)) SWIG_fail;
42281 {
42282 PyThreadState* __tstate = wxPyBeginAllowThreads();
42283 result = (PyObject *)wxGBSpan_Get(arg1);
42284
42285 wxPyEndAllowThreads(__tstate);
42286 if (PyErr_Occurred()) SWIG_fail;
42287 }
42288 resultobj = result;
42289 return resultobj;
42290 fail:
42291 return NULL;
42292 }
42293
42294
42295 static PyObject * wxGBSpan_swigregister(PyObject *, PyObject *args) {
42296 PyObject *obj;
42297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42298 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42299 Py_INCREF(obj);
42300 return Py_BuildValue((char *)"");
42301 }
42302 static int _wrap_wxDefaultSpan_set(PyObject *) {
42303 PyErr_SetString(PyExc_TypeError,"Variable wxDefaultSpan is read-only.");
42304 return 1;
42305 }
42306
42307
42308 static PyObject *_wrap_wxDefaultSpan_get(void) {
42309 PyObject *pyobj;
42310
42311 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42312 return pyobj;
42313 }
42314
42315
42316 static PyObject *_wrap_new_wxGBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42317 PyObject *resultobj;
42318 wxGBSizerItem *result;
42319 char *kwnames[] = {
42320 NULL
42321 };
42322
42323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxGBSizerItem",kwnames)) goto fail;
42324 {
42325 PyThreadState* __tstate = wxPyBeginAllowThreads();
42326 result = (wxGBSizerItem *)new wxGBSizerItem();
42327
42328 wxPyEndAllowThreads(__tstate);
42329 if (PyErr_Occurred()) SWIG_fail;
42330 }
42331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42332 return resultobj;
42333 fail:
42334 return NULL;
42335 }
42336
42337
42338 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42339 PyObject *resultobj;
42340 wxWindow *arg1 = (wxWindow *) 0 ;
42341 wxGBPosition *arg2 = 0 ;
42342 wxGBSpan *arg3 = 0 ;
42343 int arg4 ;
42344 int arg5 ;
42345 PyObject *arg6 = (PyObject *) NULL ;
42346 wxGBSizerItem *result;
42347 wxGBPosition temp2 ;
42348 wxGBSpan temp3 ;
42349 PyObject * obj0 = 0 ;
42350 PyObject * obj1 = 0 ;
42351 PyObject * obj2 = 0 ;
42352 PyObject * obj3 = 0 ;
42353 PyObject * obj4 = 0 ;
42354 PyObject * obj5 = 0 ;
42355 char *kwnames[] = {
42356 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42357 };
42358
42359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42361 if (SWIG_arg_fail(1)) SWIG_fail;
42362 {
42363 arg2 = &temp2;
42364 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42365 }
42366 {
42367 arg3 = &temp3;
42368 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42369 }
42370 {
42371 arg4 = (int)(SWIG_As_int(obj3));
42372 if (SWIG_arg_fail(4)) SWIG_fail;
42373 }
42374 {
42375 arg5 = (int)(SWIG_As_int(obj4));
42376 if (SWIG_arg_fail(5)) SWIG_fail;
42377 }
42378 if (obj5) {
42379 arg6 = obj5;
42380 }
42381 {
42382 PyThreadState* __tstate = wxPyBeginAllowThreads();
42383 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42384
42385 wxPyEndAllowThreads(__tstate);
42386 if (PyErr_Occurred()) SWIG_fail;
42387 }
42388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42389 return resultobj;
42390 fail:
42391 return NULL;
42392 }
42393
42394
42395 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42396 PyObject *resultobj;
42397 wxSizer *arg1 = (wxSizer *) 0 ;
42398 wxGBPosition *arg2 = 0 ;
42399 wxGBSpan *arg3 = 0 ;
42400 int arg4 ;
42401 int arg5 ;
42402 PyObject *arg6 = (PyObject *) NULL ;
42403 wxGBSizerItem *result;
42404 wxGBPosition temp2 ;
42405 wxGBSpan temp3 ;
42406 PyObject * obj0 = 0 ;
42407 PyObject * obj1 = 0 ;
42408 PyObject * obj2 = 0 ;
42409 PyObject * obj3 = 0 ;
42410 PyObject * obj4 = 0 ;
42411 PyObject * obj5 = 0 ;
42412 char *kwnames[] = {
42413 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42414 };
42415
42416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42418 if (SWIG_arg_fail(1)) SWIG_fail;
42419 {
42420 arg2 = &temp2;
42421 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42422 }
42423 {
42424 arg3 = &temp3;
42425 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42426 }
42427 {
42428 arg4 = (int)(SWIG_As_int(obj3));
42429 if (SWIG_arg_fail(4)) SWIG_fail;
42430 }
42431 {
42432 arg5 = (int)(SWIG_As_int(obj4));
42433 if (SWIG_arg_fail(5)) SWIG_fail;
42434 }
42435 if (obj5) {
42436 arg6 = obj5;
42437 }
42438 {
42439 PyThreadState* __tstate = wxPyBeginAllowThreads();
42440 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42441
42442 wxPyEndAllowThreads(__tstate);
42443 if (PyErr_Occurred()) SWIG_fail;
42444 }
42445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42446 return resultobj;
42447 fail:
42448 return NULL;
42449 }
42450
42451
42452 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj;
42454 int arg1 ;
42455 int arg2 ;
42456 wxGBPosition *arg3 = 0 ;
42457 wxGBSpan *arg4 = 0 ;
42458 int arg5 ;
42459 int arg6 ;
42460 PyObject *arg7 = (PyObject *) NULL ;
42461 wxGBSizerItem *result;
42462 wxGBPosition temp3 ;
42463 wxGBSpan temp4 ;
42464 PyObject * obj0 = 0 ;
42465 PyObject * obj1 = 0 ;
42466 PyObject * obj2 = 0 ;
42467 PyObject * obj3 = 0 ;
42468 PyObject * obj4 = 0 ;
42469 PyObject * obj5 = 0 ;
42470 PyObject * obj6 = 0 ;
42471 char *kwnames[] = {
42472 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42473 };
42474
42475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42476 {
42477 arg1 = (int)(SWIG_As_int(obj0));
42478 if (SWIG_arg_fail(1)) SWIG_fail;
42479 }
42480 {
42481 arg2 = (int)(SWIG_As_int(obj1));
42482 if (SWIG_arg_fail(2)) SWIG_fail;
42483 }
42484 {
42485 arg3 = &temp3;
42486 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42487 }
42488 {
42489 arg4 = &temp4;
42490 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42491 }
42492 {
42493 arg5 = (int)(SWIG_As_int(obj4));
42494 if (SWIG_arg_fail(5)) SWIG_fail;
42495 }
42496 {
42497 arg6 = (int)(SWIG_As_int(obj5));
42498 if (SWIG_arg_fail(6)) SWIG_fail;
42499 }
42500 if (obj6) {
42501 arg7 = obj6;
42502 }
42503 {
42504 PyThreadState* __tstate = wxPyBeginAllowThreads();
42505 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42506
42507 wxPyEndAllowThreads(__tstate);
42508 if (PyErr_Occurred()) SWIG_fail;
42509 }
42510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42511 return resultobj;
42512 fail:
42513 return NULL;
42514 }
42515
42516
42517 static PyObject *_wrap_wxGBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42518 PyObject *resultobj;
42519 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42520 wxGBPosition result;
42521 PyObject * obj0 = 0 ;
42522 char *kwnames[] = {
42523 (char *) "self", NULL
42524 };
42525
42526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42528 if (SWIG_arg_fail(1)) SWIG_fail;
42529 {
42530 PyThreadState* __tstate = wxPyBeginAllowThreads();
42531 result = ((wxGBSizerItem const *)arg1)->GetPos();
42532
42533 wxPyEndAllowThreads(__tstate);
42534 if (PyErr_Occurred()) SWIG_fail;
42535 }
42536 {
42537 wxGBPosition * resultptr;
42538 resultptr = new wxGBPosition((wxGBPosition &)(result));
42539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42540 }
42541 return resultobj;
42542 fail:
42543 return NULL;
42544 }
42545
42546
42547 static PyObject *_wrap_wxGBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42548 PyObject *resultobj;
42549 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42550 wxGBSpan result;
42551 PyObject * obj0 = 0 ;
42552 char *kwnames[] = {
42553 (char *) "self", NULL
42554 };
42555
42556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42558 if (SWIG_arg_fail(1)) SWIG_fail;
42559 {
42560 PyThreadState* __tstate = wxPyBeginAllowThreads();
42561 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42562
42563 wxPyEndAllowThreads(__tstate);
42564 if (PyErr_Occurred()) SWIG_fail;
42565 }
42566 {
42567 wxGBSpan * resultptr;
42568 resultptr = new wxGBSpan((wxGBSpan &)(result));
42569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42570 }
42571 return resultobj;
42572 fail:
42573 return NULL;
42574 }
42575
42576
42577 static PyObject *_wrap_wxGBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42578 PyObject *resultobj;
42579 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42580 wxGBPosition *arg2 = 0 ;
42581 bool result;
42582 wxGBPosition temp2 ;
42583 PyObject * obj0 = 0 ;
42584 PyObject * obj1 = 0 ;
42585 char *kwnames[] = {
42586 (char *) "self",(char *) "pos", NULL
42587 };
42588
42589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42591 if (SWIG_arg_fail(1)) SWIG_fail;
42592 {
42593 arg2 = &temp2;
42594 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42595 }
42596 {
42597 PyThreadState* __tstate = wxPyBeginAllowThreads();
42598 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42599
42600 wxPyEndAllowThreads(__tstate);
42601 if (PyErr_Occurred()) SWIG_fail;
42602 }
42603 {
42604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42605 }
42606 return resultobj;
42607 fail:
42608 return NULL;
42609 }
42610
42611
42612 static PyObject *_wrap_wxGBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42613 PyObject *resultobj;
42614 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42615 wxGBSpan *arg2 = 0 ;
42616 bool result;
42617 wxGBSpan temp2 ;
42618 PyObject * obj0 = 0 ;
42619 PyObject * obj1 = 0 ;
42620 char *kwnames[] = {
42621 (char *) "self",(char *) "span", NULL
42622 };
42623
42624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42626 if (SWIG_arg_fail(1)) SWIG_fail;
42627 {
42628 arg2 = &temp2;
42629 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42630 }
42631 {
42632 PyThreadState* __tstate = wxPyBeginAllowThreads();
42633 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42634
42635 wxPyEndAllowThreads(__tstate);
42636 if (PyErr_Occurred()) SWIG_fail;
42637 }
42638 {
42639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42640 }
42641 return resultobj;
42642 fail:
42643 return NULL;
42644 }
42645
42646
42647 static PyObject *_wrap_wxGBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42648 PyObject *resultobj;
42649 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42650 wxGBSizerItem *arg2 = 0 ;
42651 bool result;
42652 PyObject * obj0 = 0 ;
42653 PyObject * obj1 = 0 ;
42654 char *kwnames[] = {
42655 (char *) "self",(char *) "other", NULL
42656 };
42657
42658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42660 if (SWIG_arg_fail(1)) SWIG_fail;
42661 {
42662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42663 if (SWIG_arg_fail(2)) SWIG_fail;
42664 if (arg2 == NULL) {
42665 SWIG_null_ref("wxGBSizerItem");
42666 }
42667 if (SWIG_arg_fail(2)) SWIG_fail;
42668 }
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42672
42673 wxPyEndAllowThreads(__tstate);
42674 if (PyErr_Occurred()) SWIG_fail;
42675 }
42676 {
42677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42678 }
42679 return resultobj;
42680 fail:
42681 return NULL;
42682 }
42683
42684
42685 static PyObject *_wrap_wxGBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42686 PyObject *resultobj;
42687 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42688 wxGBPosition *arg2 = 0 ;
42689 wxGBSpan *arg3 = 0 ;
42690 bool result;
42691 wxGBPosition temp2 ;
42692 wxGBSpan temp3 ;
42693 PyObject * obj0 = 0 ;
42694 PyObject * obj1 = 0 ;
42695 PyObject * obj2 = 0 ;
42696 char *kwnames[] = {
42697 (char *) "self",(char *) "pos",(char *) "span", NULL
42698 };
42699
42700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxGBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42702 if (SWIG_arg_fail(1)) SWIG_fail;
42703 {
42704 arg2 = &temp2;
42705 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42706 }
42707 {
42708 arg3 = &temp3;
42709 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42710 }
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42714
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 {
42719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42720 }
42721 return resultobj;
42722 fail:
42723 return NULL;
42724 }
42725
42726
42727 static PyObject *_wrap_wxGBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42728 PyObject *resultobj;
42729 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42730 wxGBPosition result;
42731 PyObject * obj0 = 0 ;
42732 char *kwnames[] = {
42733 (char *) "self", NULL
42734 };
42735
42736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42738 if (SWIG_arg_fail(1)) SWIG_fail;
42739 {
42740 PyThreadState* __tstate = wxPyBeginAllowThreads();
42741 result = wxGBSizerItem_GetEndPos(arg1);
42742
42743 wxPyEndAllowThreads(__tstate);
42744 if (PyErr_Occurred()) SWIG_fail;
42745 }
42746 {
42747 wxGBPosition * resultptr;
42748 resultptr = new wxGBPosition((wxGBPosition &)(result));
42749 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42750 }
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 static PyObject *_wrap_wxGBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42758 PyObject *resultobj;
42759 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42760 wxGridBagSizer *result;
42761 PyObject * obj0 = 0 ;
42762 char *kwnames[] = {
42763 (char *) "self", NULL
42764 };
42765
42766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42768 if (SWIG_arg_fail(1)) SWIG_fail;
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42772
42773 wxPyEndAllowThreads(__tstate);
42774 if (PyErr_Occurred()) SWIG_fail;
42775 }
42776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42777 return resultobj;
42778 fail:
42779 return NULL;
42780 }
42781
42782
42783 static PyObject *_wrap_wxGBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42784 PyObject *resultobj;
42785 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42786 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42787 PyObject * obj0 = 0 ;
42788 PyObject * obj1 = 0 ;
42789 char *kwnames[] = {
42790 (char *) "self",(char *) "sizer", NULL
42791 };
42792
42793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42795 if (SWIG_arg_fail(1)) SWIG_fail;
42796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42797 if (SWIG_arg_fail(2)) SWIG_fail;
42798 {
42799 PyThreadState* __tstate = wxPyBeginAllowThreads();
42800 (arg1)->SetGBSizer(arg2);
42801
42802 wxPyEndAllowThreads(__tstate);
42803 if (PyErr_Occurred()) SWIG_fail;
42804 }
42805 Py_INCREF(Py_None); resultobj = Py_None;
42806 return resultobj;
42807 fail:
42808 return NULL;
42809 }
42810
42811
42812 static PyObject * wxGBSizerItem_swigregister(PyObject *, PyObject *args) {
42813 PyObject *obj;
42814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42815 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42816 Py_INCREF(obj);
42817 return Py_BuildValue((char *)"");
42818 }
42819 static PyObject *_wrap_new_wxGridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42820 PyObject *resultobj;
42821 int arg1 = (int) 0 ;
42822 int arg2 = (int) 0 ;
42823 wxGridBagSizer *result;
42824 PyObject * obj0 = 0 ;
42825 PyObject * obj1 = 0 ;
42826 char *kwnames[] = {
42827 (char *) "vgap",(char *) "hgap", NULL
42828 };
42829
42830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_wxGridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42831 if (obj0) {
42832 {
42833 arg1 = (int)(SWIG_As_int(obj0));
42834 if (SWIG_arg_fail(1)) SWIG_fail;
42835 }
42836 }
42837 if (obj1) {
42838 {
42839 arg2 = (int)(SWIG_As_int(obj1));
42840 if (SWIG_arg_fail(2)) SWIG_fail;
42841 }
42842 }
42843 {
42844 PyThreadState* __tstate = wxPyBeginAllowThreads();
42845 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42846
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42851 return resultobj;
42852 fail:
42853 return NULL;
42854 }
42855
42856
42857 static PyObject *_wrap_wxGridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42858 PyObject *resultobj;
42859 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42860 PyObject *arg2 = (PyObject *) 0 ;
42861 wxGBPosition *arg3 = 0 ;
42862 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42863 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42864 int arg5 = (int) 0 ;
42865 int arg6 = (int) 0 ;
42866 PyObject *arg7 = (PyObject *) NULL ;
42867 wxGBSizerItem *result;
42868 wxGBPosition temp3 ;
42869 wxGBSpan temp4 ;
42870 PyObject * obj0 = 0 ;
42871 PyObject * obj1 = 0 ;
42872 PyObject * obj2 = 0 ;
42873 PyObject * obj3 = 0 ;
42874 PyObject * obj4 = 0 ;
42875 PyObject * obj5 = 0 ;
42876 PyObject * obj6 = 0 ;
42877 char *kwnames[] = {
42878 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42879 };
42880
42881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:wxGridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42883 if (SWIG_arg_fail(1)) SWIG_fail;
42884 arg2 = obj1;
42885 {
42886 arg3 = &temp3;
42887 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42888 }
42889 if (obj3) {
42890 {
42891 arg4 = &temp4;
42892 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42893 }
42894 }
42895 if (obj4) {
42896 {
42897 arg5 = (int)(SWIG_As_int(obj4));
42898 if (SWIG_arg_fail(5)) SWIG_fail;
42899 }
42900 }
42901 if (obj5) {
42902 {
42903 arg6 = (int)(SWIG_As_int(obj5));
42904 if (SWIG_arg_fail(6)) SWIG_fail;
42905 }
42906 }
42907 if (obj6) {
42908 arg7 = obj6;
42909 }
42910 {
42911 PyThreadState* __tstate = wxPyBeginAllowThreads();
42912 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42913
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42918 return resultobj;
42919 fail:
42920 return NULL;
42921 }
42922
42923
42924 static PyObject *_wrap_wxGridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42925 PyObject *resultobj;
42926 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42927 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42928 wxGBSizerItem *result;
42929 PyObject * obj0 = 0 ;
42930 PyObject * obj1 = 0 ;
42931 char *kwnames[] = {
42932 (char *) "self",(char *) "item", NULL
42933 };
42934
42935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42937 if (SWIG_arg_fail(1)) SWIG_fail;
42938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42939 if (SWIG_arg_fail(2)) SWIG_fail;
42940 {
42941 PyThreadState* __tstate = wxPyBeginAllowThreads();
42942 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42943
42944 wxPyEndAllowThreads(__tstate);
42945 if (PyErr_Occurred()) SWIG_fail;
42946 }
42947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42948 return resultobj;
42949 fail:
42950 return NULL;
42951 }
42952
42953
42954 static PyObject *_wrap_wxGridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42955 PyObject *resultobj;
42956 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42957 int arg2 ;
42958 int arg3 ;
42959 wxSize result;
42960 PyObject * obj0 = 0 ;
42961 PyObject * obj1 = 0 ;
42962 PyObject * obj2 = 0 ;
42963 char *kwnames[] = {
42964 (char *) "self",(char *) "row",(char *) "col", NULL
42965 };
42966
42967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxGridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42969 if (SWIG_arg_fail(1)) SWIG_fail;
42970 {
42971 arg2 = (int)(SWIG_As_int(obj1));
42972 if (SWIG_arg_fail(2)) SWIG_fail;
42973 }
42974 {
42975 arg3 = (int)(SWIG_As_int(obj2));
42976 if (SWIG_arg_fail(3)) SWIG_fail;
42977 }
42978 {
42979 PyThreadState* __tstate = wxPyBeginAllowThreads();
42980 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42981
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 {
42986 wxSize * resultptr;
42987 resultptr = new wxSize((wxSize &)(result));
42988 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42989 }
42990 return resultobj;
42991 fail:
42992 return NULL;
42993 }
42994
42995
42996 static PyObject *_wrap_wxGridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42997 PyObject *resultobj;
42998 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42999 wxSize result;
43000 PyObject * obj0 = 0 ;
43001 char *kwnames[] = {
43002 (char *) "self", NULL
43003 };
43004
43005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxGridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43007 if (SWIG_arg_fail(1)) SWIG_fail;
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43011
43012 wxPyEndAllowThreads(__tstate);
43013 if (PyErr_Occurred()) SWIG_fail;
43014 }
43015 {
43016 wxSize * resultptr;
43017 resultptr = new wxSize((wxSize &)(result));
43018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43019 }
43020 return resultobj;
43021 fail:
43022 return NULL;
43023 }
43024
43025
43026 static PyObject *_wrap_wxGridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43027 PyObject *resultobj;
43028 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43029 wxSize *arg2 = 0 ;
43030 wxSize temp2 ;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033 char *kwnames[] = {
43034 (char *) "self",(char *) "sz", NULL
43035 };
43036
43037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43039 if (SWIG_arg_fail(1)) SWIG_fail;
43040 {
43041 arg2 = &temp2;
43042 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43043 }
43044 {
43045 PyThreadState* __tstate = wxPyBeginAllowThreads();
43046 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43047
43048 wxPyEndAllowThreads(__tstate);
43049 if (PyErr_Occurred()) SWIG_fail;
43050 }
43051 Py_INCREF(Py_None); resultobj = Py_None;
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 static PyObject *_wrap_wxGridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43059 PyObject *resultobj;
43060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43061 wxWindow *arg2 = (wxWindow *) 0 ;
43062 wxGBPosition result;
43063 PyObject * obj0 = 0 ;
43064 PyObject * obj1 = 0 ;
43065
43066 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43068 if (SWIG_arg_fail(1)) SWIG_fail;
43069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43070 if (SWIG_arg_fail(2)) SWIG_fail;
43071 {
43072 PyThreadState* __tstate = wxPyBeginAllowThreads();
43073 result = (arg1)->GetItemPosition(arg2);
43074
43075 wxPyEndAllowThreads(__tstate);
43076 if (PyErr_Occurred()) SWIG_fail;
43077 }
43078 {
43079 wxGBPosition * resultptr;
43080 resultptr = new wxGBPosition((wxGBPosition &)(result));
43081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43082 }
43083 return resultobj;
43084 fail:
43085 return NULL;
43086 }
43087
43088
43089 static PyObject *_wrap_wxGridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43090 PyObject *resultobj;
43091 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43092 wxSizer *arg2 = (wxSizer *) 0 ;
43093 wxGBPosition result;
43094 PyObject * obj0 = 0 ;
43095 PyObject * obj1 = 0 ;
43096
43097 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43099 if (SWIG_arg_fail(1)) SWIG_fail;
43100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43101 if (SWIG_arg_fail(2)) SWIG_fail;
43102 {
43103 PyThreadState* __tstate = wxPyBeginAllowThreads();
43104 result = (arg1)->GetItemPosition(arg2);
43105
43106 wxPyEndAllowThreads(__tstate);
43107 if (PyErr_Occurred()) SWIG_fail;
43108 }
43109 {
43110 wxGBPosition * resultptr;
43111 resultptr = new wxGBPosition((wxGBPosition &)(result));
43112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43113 }
43114 return resultobj;
43115 fail:
43116 return NULL;
43117 }
43118
43119
43120 static PyObject *_wrap_wxGridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43121 PyObject *resultobj;
43122 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43123 size_t arg2 ;
43124 wxGBPosition result;
43125 PyObject * obj0 = 0 ;
43126 PyObject * obj1 = 0 ;
43127
43128 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43130 if (SWIG_arg_fail(1)) SWIG_fail;
43131 {
43132 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43133 if (SWIG_arg_fail(2)) SWIG_fail;
43134 }
43135 {
43136 PyThreadState* __tstate = wxPyBeginAllowThreads();
43137 result = (arg1)->GetItemPosition(arg2);
43138
43139 wxPyEndAllowThreads(__tstate);
43140 if (PyErr_Occurred()) SWIG_fail;
43141 }
43142 {
43143 wxGBPosition * resultptr;
43144 resultptr = new wxGBPosition((wxGBPosition &)(result));
43145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43146 }
43147 return resultobj;
43148 fail:
43149 return NULL;
43150 }
43151
43152
43153 static PyObject *_wrap_wxGridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43154 int argc;
43155 PyObject *argv[3];
43156 int ii;
43157
43158 argc = PyObject_Length(args);
43159 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43160 argv[ii] = PyTuple_GetItem(args,ii);
43161 }
43162 if (argc == 2) {
43163 int _v;
43164 {
43165 void *ptr;
43166 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43167 _v = 0;
43168 PyErr_Clear();
43169 } else {
43170 _v = 1;
43171 }
43172 }
43173 if (_v) {
43174 {
43175 void *ptr;
43176 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43177 _v = 0;
43178 PyErr_Clear();
43179 } else {
43180 _v = 1;
43181 }
43182 }
43183 if (_v) {
43184 return _wrap_wxGridBagSizer_GetItemPosition__SWIG_0(self,args);
43185 }
43186 }
43187 }
43188 if (argc == 2) {
43189 int _v;
43190 {
43191 void *ptr;
43192 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43193 _v = 0;
43194 PyErr_Clear();
43195 } else {
43196 _v = 1;
43197 }
43198 }
43199 if (_v) {
43200 {
43201 void *ptr;
43202 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43203 _v = 0;
43204 PyErr_Clear();
43205 } else {
43206 _v = 1;
43207 }
43208 }
43209 if (_v) {
43210 return _wrap_wxGridBagSizer_GetItemPosition__SWIG_1(self,args);
43211 }
43212 }
43213 }
43214 if (argc == 2) {
43215 int _v;
43216 {
43217 void *ptr;
43218 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43219 _v = 0;
43220 PyErr_Clear();
43221 } else {
43222 _v = 1;
43223 }
43224 }
43225 if (_v) {
43226 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43227 if (_v) {
43228 return _wrap_wxGridBagSizer_GetItemPosition__SWIG_2(self,args);
43229 }
43230 }
43231 }
43232
43233 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'wxGridBagSizer_GetItemPosition'");
43234 return NULL;
43235 }
43236
43237
43238 static PyObject *_wrap_wxGridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43239 PyObject *resultobj;
43240 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43241 wxWindow *arg2 = (wxWindow *) 0 ;
43242 wxGBPosition *arg3 = 0 ;
43243 bool result;
43244 wxGBPosition temp3 ;
43245 PyObject * obj0 = 0 ;
43246 PyObject * obj1 = 0 ;
43247 PyObject * obj2 = 0 ;
43248
43249 if(!PyArg_ParseTuple(args,(char *)"OOO:wxGridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43251 if (SWIG_arg_fail(1)) SWIG_fail;
43252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43253 if (SWIG_arg_fail(2)) SWIG_fail;
43254 {
43255 arg3 = &temp3;
43256 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43257 }
43258 {
43259 PyThreadState* __tstate = wxPyBeginAllowThreads();
43260 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43261
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 {
43266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43267 }
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 static PyObject *_wrap_wxGridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43275 PyObject *resultobj;
43276 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43277 wxSizer *arg2 = (wxSizer *) 0 ;
43278 wxGBPosition *arg3 = 0 ;
43279 bool result;
43280 wxGBPosition temp3 ;
43281 PyObject * obj0 = 0 ;
43282 PyObject * obj1 = 0 ;
43283 PyObject * obj2 = 0 ;
43284
43285 if(!PyArg_ParseTuple(args,(char *)"OOO:wxGridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43287 if (SWIG_arg_fail(1)) SWIG_fail;
43288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43289 if (SWIG_arg_fail(2)) SWIG_fail;
43290 {
43291 arg3 = &temp3;
43292 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43293 }
43294 {
43295 PyThreadState* __tstate = wxPyBeginAllowThreads();
43296 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43297
43298 wxPyEndAllowThreads(__tstate);
43299 if (PyErr_Occurred()) SWIG_fail;
43300 }
43301 {
43302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43303 }
43304 return resultobj;
43305 fail:
43306 return NULL;
43307 }
43308
43309
43310 static PyObject *_wrap_wxGridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43311 PyObject *resultobj;
43312 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43313 size_t arg2 ;
43314 wxGBPosition *arg3 = 0 ;
43315 bool result;
43316 wxGBPosition temp3 ;
43317 PyObject * obj0 = 0 ;
43318 PyObject * obj1 = 0 ;
43319 PyObject * obj2 = 0 ;
43320
43321 if(!PyArg_ParseTuple(args,(char *)"OOO:wxGridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43323 if (SWIG_arg_fail(1)) SWIG_fail;
43324 {
43325 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43326 if (SWIG_arg_fail(2)) SWIG_fail;
43327 }
43328 {
43329 arg3 = &temp3;
43330 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43331 }
43332 {
43333 PyThreadState* __tstate = wxPyBeginAllowThreads();
43334 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43335
43336 wxPyEndAllowThreads(__tstate);
43337 if (PyErr_Occurred()) SWIG_fail;
43338 }
43339 {
43340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43341 }
43342 return resultobj;
43343 fail:
43344 return NULL;
43345 }
43346
43347
43348 static PyObject *_wrap_wxGridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43349 int argc;
43350 PyObject *argv[4];
43351 int ii;
43352
43353 argc = PyObject_Length(args);
43354 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43355 argv[ii] = PyTuple_GetItem(args,ii);
43356 }
43357 if (argc == 3) {
43358 int _v;
43359 {
43360 void *ptr;
43361 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43362 _v = 0;
43363 PyErr_Clear();
43364 } else {
43365 _v = 1;
43366 }
43367 }
43368 if (_v) {
43369 {
43370 void *ptr;
43371 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43372 _v = 0;
43373 PyErr_Clear();
43374 } else {
43375 _v = 1;
43376 }
43377 }
43378 if (_v) {
43379 {
43380 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43381 }
43382 if (_v) {
43383 return _wrap_wxGridBagSizer_SetItemPosition__SWIG_0(self,args);
43384 }
43385 }
43386 }
43387 }
43388 if (argc == 3) {
43389 int _v;
43390 {
43391 void *ptr;
43392 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43393 _v = 0;
43394 PyErr_Clear();
43395 } else {
43396 _v = 1;
43397 }
43398 }
43399 if (_v) {
43400 {
43401 void *ptr;
43402 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43403 _v = 0;
43404 PyErr_Clear();
43405 } else {
43406 _v = 1;
43407 }
43408 }
43409 if (_v) {
43410 {
43411 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43412 }
43413 if (_v) {
43414 return _wrap_wxGridBagSizer_SetItemPosition__SWIG_1(self,args);
43415 }
43416 }
43417 }
43418 }
43419 if (argc == 3) {
43420 int _v;
43421 {
43422 void *ptr;
43423 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43424 _v = 0;
43425 PyErr_Clear();
43426 } else {
43427 _v = 1;
43428 }
43429 }
43430 if (_v) {
43431 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43432 if (_v) {
43433 {
43434 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43435 }
43436 if (_v) {
43437 return _wrap_wxGridBagSizer_SetItemPosition__SWIG_2(self,args);
43438 }
43439 }
43440 }
43441 }
43442
43443 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'wxGridBagSizer_SetItemPosition'");
43444 return NULL;
43445 }
43446
43447
43448 static PyObject *_wrap_wxGridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43449 PyObject *resultobj;
43450 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43451 wxWindow *arg2 = (wxWindow *) 0 ;
43452 wxGBSpan result;
43453 PyObject * obj0 = 0 ;
43454 PyObject * obj1 = 0 ;
43455
43456 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43458 if (SWIG_arg_fail(1)) SWIG_fail;
43459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43460 if (SWIG_arg_fail(2)) SWIG_fail;
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = (arg1)->GetItemSpan(arg2);
43464
43465 wxPyEndAllowThreads(__tstate);
43466 if (PyErr_Occurred()) SWIG_fail;
43467 }
43468 {
43469 wxGBSpan * resultptr;
43470 resultptr = new wxGBSpan((wxGBSpan &)(result));
43471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43472 }
43473 return resultobj;
43474 fail:
43475 return NULL;
43476 }
43477
43478
43479 static PyObject *_wrap_wxGridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43480 PyObject *resultobj;
43481 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43482 wxSizer *arg2 = (wxSizer *) 0 ;
43483 wxGBSpan result;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486
43487 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43489 if (SWIG_arg_fail(1)) SWIG_fail;
43490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43491 if (SWIG_arg_fail(2)) SWIG_fail;
43492 {
43493 PyThreadState* __tstate = wxPyBeginAllowThreads();
43494 result = (arg1)->GetItemSpan(arg2);
43495
43496 wxPyEndAllowThreads(__tstate);
43497 if (PyErr_Occurred()) SWIG_fail;
43498 }
43499 {
43500 wxGBSpan * resultptr;
43501 resultptr = new wxGBSpan((wxGBSpan &)(result));
43502 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43503 }
43504 return resultobj;
43505 fail:
43506 return NULL;
43507 }
43508
43509
43510 static PyObject *_wrap_wxGridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43511 PyObject *resultobj;
43512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43513 size_t arg2 ;
43514 wxGBSpan result;
43515 PyObject * obj0 = 0 ;
43516 PyObject * obj1 = 0 ;
43517
43518 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43520 if (SWIG_arg_fail(1)) SWIG_fail;
43521 {
43522 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43523 if (SWIG_arg_fail(2)) SWIG_fail;
43524 }
43525 {
43526 PyThreadState* __tstate = wxPyBeginAllowThreads();
43527 result = (arg1)->GetItemSpan(arg2);
43528
43529 wxPyEndAllowThreads(__tstate);
43530 if (PyErr_Occurred()) SWIG_fail;
43531 }
43532 {
43533 wxGBSpan * resultptr;
43534 resultptr = new wxGBSpan((wxGBSpan &)(result));
43535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43536 }
43537 return resultobj;
43538 fail:
43539 return NULL;
43540 }
43541
43542
43543 static PyObject *_wrap_wxGridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43544 int argc;
43545 PyObject *argv[3];
43546 int ii;
43547
43548 argc = PyObject_Length(args);
43549 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43550 argv[ii] = PyTuple_GetItem(args,ii);
43551 }
43552 if (argc == 2) {
43553 int _v;
43554 {
43555 void *ptr;
43556 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43557 _v = 0;
43558 PyErr_Clear();
43559 } else {
43560 _v = 1;
43561 }
43562 }
43563 if (_v) {
43564 {
43565 void *ptr;
43566 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43567 _v = 0;
43568 PyErr_Clear();
43569 } else {
43570 _v = 1;
43571 }
43572 }
43573 if (_v) {
43574 return _wrap_wxGridBagSizer_GetItemSpan__SWIG_0(self,args);
43575 }
43576 }
43577 }
43578 if (argc == 2) {
43579 int _v;
43580 {
43581 void *ptr;
43582 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43583 _v = 0;
43584 PyErr_Clear();
43585 } else {
43586 _v = 1;
43587 }
43588 }
43589 if (_v) {
43590 {
43591 void *ptr;
43592 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43593 _v = 0;
43594 PyErr_Clear();
43595 } else {
43596 _v = 1;
43597 }
43598 }
43599 if (_v) {
43600 return _wrap_wxGridBagSizer_GetItemSpan__SWIG_1(self,args);
43601 }
43602 }
43603 }
43604 if (argc == 2) {
43605 int _v;
43606 {
43607 void *ptr;
43608 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43609 _v = 0;
43610 PyErr_Clear();
43611 } else {
43612 _v = 1;
43613 }
43614 }
43615 if (_v) {
43616 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43617 if (_v) {
43618 return _wrap_wxGridBagSizer_GetItemSpan__SWIG_2(self,args);
43619 }
43620 }
43621 }
43622
43623 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'wxGridBagSizer_GetItemSpan'");
43624 return NULL;
43625 }
43626
43627
43628 static PyObject *_wrap_wxGridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43629 PyObject *resultobj;
43630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43631 wxWindow *arg2 = (wxWindow *) 0 ;
43632 wxGBSpan *arg3 = 0 ;
43633 bool result;
43634 wxGBSpan temp3 ;
43635 PyObject * obj0 = 0 ;
43636 PyObject * obj1 = 0 ;
43637 PyObject * obj2 = 0 ;
43638
43639 if(!PyArg_ParseTuple(args,(char *)"OOO:wxGridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43641 if (SWIG_arg_fail(1)) SWIG_fail;
43642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43643 if (SWIG_arg_fail(2)) SWIG_fail;
43644 {
43645 arg3 = &temp3;
43646 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43647 }
43648 {
43649 PyThreadState* __tstate = wxPyBeginAllowThreads();
43650 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43651
43652 wxPyEndAllowThreads(__tstate);
43653 if (PyErr_Occurred()) SWIG_fail;
43654 }
43655 {
43656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43657 }
43658 return resultobj;
43659 fail:
43660 return NULL;
43661 }
43662
43663
43664 static PyObject *_wrap_wxGridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43665 PyObject *resultobj;
43666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43667 wxSizer *arg2 = (wxSizer *) 0 ;
43668 wxGBSpan *arg3 = 0 ;
43669 bool result;
43670 wxGBSpan temp3 ;
43671 PyObject * obj0 = 0 ;
43672 PyObject * obj1 = 0 ;
43673 PyObject * obj2 = 0 ;
43674
43675 if(!PyArg_ParseTuple(args,(char *)"OOO:wxGridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43677 if (SWIG_arg_fail(1)) SWIG_fail;
43678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43679 if (SWIG_arg_fail(2)) SWIG_fail;
43680 {
43681 arg3 = &temp3;
43682 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43683 }
43684 {
43685 PyThreadState* __tstate = wxPyBeginAllowThreads();
43686 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43687
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 {
43692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43693 }
43694 return resultobj;
43695 fail:
43696 return NULL;
43697 }
43698
43699
43700 static PyObject *_wrap_wxGridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43701 PyObject *resultobj;
43702 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43703 size_t arg2 ;
43704 wxGBSpan *arg3 = 0 ;
43705 bool result;
43706 wxGBSpan temp3 ;
43707 PyObject * obj0 = 0 ;
43708 PyObject * obj1 = 0 ;
43709 PyObject * obj2 = 0 ;
43710
43711 if(!PyArg_ParseTuple(args,(char *)"OOO:wxGridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43713 if (SWIG_arg_fail(1)) SWIG_fail;
43714 {
43715 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43716 if (SWIG_arg_fail(2)) SWIG_fail;
43717 }
43718 {
43719 arg3 = &temp3;
43720 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43721 }
43722 {
43723 PyThreadState* __tstate = wxPyBeginAllowThreads();
43724 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43725
43726 wxPyEndAllowThreads(__tstate);
43727 if (PyErr_Occurred()) SWIG_fail;
43728 }
43729 {
43730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43731 }
43732 return resultobj;
43733 fail:
43734 return NULL;
43735 }
43736
43737
43738 static PyObject *_wrap_wxGridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43739 int argc;
43740 PyObject *argv[4];
43741 int ii;
43742
43743 argc = PyObject_Length(args);
43744 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43745 argv[ii] = PyTuple_GetItem(args,ii);
43746 }
43747 if (argc == 3) {
43748 int _v;
43749 {
43750 void *ptr;
43751 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43752 _v = 0;
43753 PyErr_Clear();
43754 } else {
43755 _v = 1;
43756 }
43757 }
43758 if (_v) {
43759 {
43760 void *ptr;
43761 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43762 _v = 0;
43763 PyErr_Clear();
43764 } else {
43765 _v = 1;
43766 }
43767 }
43768 if (_v) {
43769 {
43770 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43771 }
43772 if (_v) {
43773 return _wrap_wxGridBagSizer_SetItemSpan__SWIG_0(self,args);
43774 }
43775 }
43776 }
43777 }
43778 if (argc == 3) {
43779 int _v;
43780 {
43781 void *ptr;
43782 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43783 _v = 0;
43784 PyErr_Clear();
43785 } else {
43786 _v = 1;
43787 }
43788 }
43789 if (_v) {
43790 {
43791 void *ptr;
43792 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43793 _v = 0;
43794 PyErr_Clear();
43795 } else {
43796 _v = 1;
43797 }
43798 }
43799 if (_v) {
43800 {
43801 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43802 }
43803 if (_v) {
43804 return _wrap_wxGridBagSizer_SetItemSpan__SWIG_1(self,args);
43805 }
43806 }
43807 }
43808 }
43809 if (argc == 3) {
43810 int _v;
43811 {
43812 void *ptr;
43813 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43814 _v = 0;
43815 PyErr_Clear();
43816 } else {
43817 _v = 1;
43818 }
43819 }
43820 if (_v) {
43821 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43822 if (_v) {
43823 {
43824 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43825 }
43826 if (_v) {
43827 return _wrap_wxGridBagSizer_SetItemSpan__SWIG_2(self,args);
43828 }
43829 }
43830 }
43831 }
43832
43833 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'wxGridBagSizer_SetItemSpan'");
43834 return NULL;
43835 }
43836
43837
43838 static PyObject *_wrap_wxGridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43839 PyObject *resultobj;
43840 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43841 wxWindow *arg2 = (wxWindow *) 0 ;
43842 wxGBSizerItem *result;
43843 PyObject * obj0 = 0 ;
43844 PyObject * obj1 = 0 ;
43845
43846 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43848 if (SWIG_arg_fail(1)) SWIG_fail;
43849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43850 if (SWIG_arg_fail(2)) SWIG_fail;
43851 {
43852 PyThreadState* __tstate = wxPyBeginAllowThreads();
43853 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43854
43855 wxPyEndAllowThreads(__tstate);
43856 if (PyErr_Occurred()) SWIG_fail;
43857 }
43858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43859 return resultobj;
43860 fail:
43861 return NULL;
43862 }
43863
43864
43865 static PyObject *_wrap_wxGridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43866 PyObject *resultobj;
43867 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43868 wxSizer *arg2 = (wxSizer *) 0 ;
43869 wxGBSizerItem *result;
43870 PyObject * obj0 = 0 ;
43871 PyObject * obj1 = 0 ;
43872
43873 if(!PyArg_ParseTuple(args,(char *)"OO:wxGridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43875 if (SWIG_arg_fail(1)) SWIG_fail;
43876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43877 if (SWIG_arg_fail(2)) SWIG_fail;
43878 {
43879 PyThreadState* __tstate = wxPyBeginAllowThreads();
43880 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43881
43882 wxPyEndAllowThreads(__tstate);
43883 if (PyErr_Occurred()) SWIG_fail;
43884 }
43885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43886 return resultobj;
43887 fail:
43888 return NULL;
43889 }
43890
43891
43892 static PyObject *_wrap_wxGridBagSizer_FindItem(PyObject *self, PyObject *args) {
43893 int argc;
43894 PyObject *argv[3];
43895 int ii;
43896
43897 argc = PyObject_Length(args);
43898 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43899 argv[ii] = PyTuple_GetItem(args,ii);
43900 }
43901 if (argc == 2) {
43902 int _v;
43903 {
43904 void *ptr;
43905 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43906 _v = 0;
43907 PyErr_Clear();
43908 } else {
43909 _v = 1;
43910 }
43911 }
43912 if (_v) {
43913 {
43914 void *ptr;
43915 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43916 _v = 0;
43917 PyErr_Clear();
43918 } else {
43919 _v = 1;
43920 }
43921 }
43922 if (_v) {
43923 return _wrap_wxGridBagSizer_FindItem__SWIG_0(self,args);
43924 }
43925 }
43926 }
43927 if (argc == 2) {
43928 int _v;
43929 {
43930 void *ptr;
43931 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43932 _v = 0;
43933 PyErr_Clear();
43934 } else {
43935 _v = 1;
43936 }
43937 }
43938 if (_v) {
43939 {
43940 void *ptr;
43941 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43942 _v = 0;
43943 PyErr_Clear();
43944 } else {
43945 _v = 1;
43946 }
43947 }
43948 if (_v) {
43949 return _wrap_wxGridBagSizer_FindItem__SWIG_1(self,args);
43950 }
43951 }
43952 }
43953
43954 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'wxGridBagSizer_FindItem'");
43955 return NULL;
43956 }
43957
43958
43959 static PyObject *_wrap_wxGridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43960 PyObject *resultobj;
43961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43962 wxGBPosition *arg2 = 0 ;
43963 wxGBSizerItem *result;
43964 wxGBPosition temp2 ;
43965 PyObject * obj0 = 0 ;
43966 PyObject * obj1 = 0 ;
43967 char *kwnames[] = {
43968 (char *) "self",(char *) "pos", NULL
43969 };
43970
43971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43973 if (SWIG_arg_fail(1)) SWIG_fail;
43974 {
43975 arg2 = &temp2;
43976 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43977 }
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43981
43982 wxPyEndAllowThreads(__tstate);
43983 if (PyErr_Occurred()) SWIG_fail;
43984 }
43985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43986 return resultobj;
43987 fail:
43988 return NULL;
43989 }
43990
43991
43992 static PyObject *_wrap_wxGridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43993 PyObject *resultobj;
43994 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43995 wxPoint *arg2 = 0 ;
43996 wxGBSizerItem *result;
43997 wxPoint temp2 ;
43998 PyObject * obj0 = 0 ;
43999 PyObject * obj1 = 0 ;
44000 char *kwnames[] = {
44001 (char *) "self",(char *) "pt", NULL
44002 };
44003
44004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxGridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44006 if (SWIG_arg_fail(1)) SWIG_fail;
44007 {
44008 arg2 = &temp2;
44009 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44010 }
44011 {
44012 PyThreadState* __tstate = wxPyBeginAllowThreads();
44013 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44014
44015 wxPyEndAllowThreads(__tstate);
44016 if (PyErr_Occurred()) SWIG_fail;
44017 }
44018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44019 return resultobj;
44020 fail:
44021 return NULL;
44022 }
44023
44024
44025 static PyObject *_wrap_wxGridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44026 PyObject *resultobj;
44027 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44028 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44029 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44030 bool result;
44031 PyObject * obj0 = 0 ;
44032 PyObject * obj1 = 0 ;
44033 PyObject * obj2 = 0 ;
44034 char *kwnames[] = {
44035 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44036 };
44037
44038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxGridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44040 if (SWIG_arg_fail(1)) SWIG_fail;
44041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44042 if (SWIG_arg_fail(2)) SWIG_fail;
44043 if (obj2) {
44044 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44045 if (SWIG_arg_fail(3)) SWIG_fail;
44046 }
44047 {
44048 PyThreadState* __tstate = wxPyBeginAllowThreads();
44049 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44050
44051 wxPyEndAllowThreads(__tstate);
44052 if (PyErr_Occurred()) SWIG_fail;
44053 }
44054 {
44055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44056 }
44057 return resultobj;
44058 fail:
44059 return NULL;
44060 }
44061
44062
44063 static PyObject *_wrap_wxGridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44064 PyObject *resultobj;
44065 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44066 wxGBPosition *arg2 = 0 ;
44067 wxGBSpan *arg3 = 0 ;
44068 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44069 bool result;
44070 wxGBPosition temp2 ;
44071 wxGBSpan temp3 ;
44072 PyObject * obj0 = 0 ;
44073 PyObject * obj1 = 0 ;
44074 PyObject * obj2 = 0 ;
44075 PyObject * obj3 = 0 ;
44076 char *kwnames[] = {
44077 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44078 };
44079
44080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxGridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44082 if (SWIG_arg_fail(1)) SWIG_fail;
44083 {
44084 arg2 = &temp2;
44085 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44086 }
44087 {
44088 arg3 = &temp3;
44089 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44090 }
44091 if (obj3) {
44092 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44093 if (SWIG_arg_fail(4)) SWIG_fail;
44094 }
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44098
44099 wxPyEndAllowThreads(__tstate);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 }
44102 {
44103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44104 }
44105 return resultobj;
44106 fail:
44107 return NULL;
44108 }
44109
44110
44111 static PyObject * wxGridBagSizer_swigregister(PyObject *, PyObject *args) {
44112 PyObject *obj;
44113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44114 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44115 Py_INCREF(obj);
44116 return Py_BuildValue((char *)"");
44117 }
44118 static PyObject *_wrap_wxIndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44119 PyObject *resultobj;
44120 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44121 wxRelationship arg2 ;
44122 wxWindow *arg3 = (wxWindow *) 0 ;
44123 wxEdge arg4 ;
44124 int arg5 = (int) 0 ;
44125 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44126 PyObject * obj0 = 0 ;
44127 PyObject * obj1 = 0 ;
44128 PyObject * obj2 = 0 ;
44129 PyObject * obj3 = 0 ;
44130 PyObject * obj4 = 0 ;
44131 PyObject * obj5 = 0 ;
44132 char *kwnames[] = {
44133 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44134 };
44135
44136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:wxIndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44138 if (SWIG_arg_fail(1)) SWIG_fail;
44139 {
44140 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44141 if (SWIG_arg_fail(2)) SWIG_fail;
44142 }
44143 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44144 if (SWIG_arg_fail(3)) SWIG_fail;
44145 {
44146 arg4 = (wxEdge)(SWIG_As_int(obj3));
44147 if (SWIG_arg_fail(4)) SWIG_fail;
44148 }
44149 if (obj4) {
44150 {
44151 arg5 = (int)(SWIG_As_int(obj4));
44152 if (SWIG_arg_fail(5)) SWIG_fail;
44153 }
44154 }
44155 if (obj5) {
44156 {
44157 arg6 = (int)(SWIG_As_int(obj5));
44158 if (SWIG_arg_fail(6)) SWIG_fail;
44159 }
44160 }
44161 {
44162 PyThreadState* __tstate = wxPyBeginAllowThreads();
44163 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44164
44165 wxPyEndAllowThreads(__tstate);
44166 if (PyErr_Occurred()) SWIG_fail;
44167 }
44168 Py_INCREF(Py_None); resultobj = Py_None;
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 static PyObject *_wrap_wxIndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj;
44177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44178 wxWindow *arg2 = (wxWindow *) 0 ;
44179 int arg3 = (int) 0 ;
44180 PyObject * obj0 = 0 ;
44181 PyObject * obj1 = 0 ;
44182 PyObject * obj2 = 0 ;
44183 char *kwnames[] = {
44184 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44185 };
44186
44187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxIndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44189 if (SWIG_arg_fail(1)) SWIG_fail;
44190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44191 if (SWIG_arg_fail(2)) SWIG_fail;
44192 if (obj2) {
44193 {
44194 arg3 = (int)(SWIG_As_int(obj2));
44195 if (SWIG_arg_fail(3)) SWIG_fail;
44196 }
44197 }
44198 {
44199 PyThreadState* __tstate = wxPyBeginAllowThreads();
44200 (arg1)->LeftOf(arg2,arg3);
44201
44202 wxPyEndAllowThreads(__tstate);
44203 if (PyErr_Occurred()) SWIG_fail;
44204 }
44205 Py_INCREF(Py_None); resultobj = Py_None;
44206 return resultobj;
44207 fail:
44208 return NULL;
44209 }
44210
44211
44212 static PyObject *_wrap_wxIndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44213 PyObject *resultobj;
44214 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44215 wxWindow *arg2 = (wxWindow *) 0 ;
44216 int arg3 = (int) 0 ;
44217 PyObject * obj0 = 0 ;
44218 PyObject * obj1 = 0 ;
44219 PyObject * obj2 = 0 ;
44220 char *kwnames[] = {
44221 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44222 };
44223
44224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxIndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44226 if (SWIG_arg_fail(1)) SWIG_fail;
44227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44228 if (SWIG_arg_fail(2)) SWIG_fail;
44229 if (obj2) {
44230 {
44231 arg3 = (int)(SWIG_As_int(obj2));
44232 if (SWIG_arg_fail(3)) SWIG_fail;
44233 }
44234 }
44235 {
44236 PyThreadState* __tstate = wxPyBeginAllowThreads();
44237 (arg1)->RightOf(arg2,arg3);
44238
44239 wxPyEndAllowThreads(__tstate);
44240 if (PyErr_Occurred()) SWIG_fail;
44241 }
44242 Py_INCREF(Py_None); resultobj = Py_None;
44243 return resultobj;
44244 fail:
44245 return NULL;
44246 }
44247
44248
44249 static PyObject *_wrap_wxIndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44250 PyObject *resultobj;
44251 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44252 wxWindow *arg2 = (wxWindow *) 0 ;
44253 int arg3 = (int) 0 ;
44254 PyObject * obj0 = 0 ;
44255 PyObject * obj1 = 0 ;
44256 PyObject * obj2 = 0 ;
44257 char *kwnames[] = {
44258 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44259 };
44260
44261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxIndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44263 if (SWIG_arg_fail(1)) SWIG_fail;
44264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44265 if (SWIG_arg_fail(2)) SWIG_fail;
44266 if (obj2) {
44267 {
44268 arg3 = (int)(SWIG_As_int(obj2));
44269 if (SWIG_arg_fail(3)) SWIG_fail;
44270 }
44271 }
44272 {
44273 PyThreadState* __tstate = wxPyBeginAllowThreads();
44274 (arg1)->Above(arg2,arg3);
44275
44276 wxPyEndAllowThreads(__tstate);
44277 if (PyErr_Occurred()) SWIG_fail;
44278 }
44279 Py_INCREF(Py_None); resultobj = Py_None;
44280 return resultobj;
44281 fail:
44282 return NULL;
44283 }
44284
44285
44286 static PyObject *_wrap_wxIndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44287 PyObject *resultobj;
44288 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44289 wxWindow *arg2 = (wxWindow *) 0 ;
44290 int arg3 = (int) 0 ;
44291 PyObject * obj0 = 0 ;
44292 PyObject * obj1 = 0 ;
44293 PyObject * obj2 = 0 ;
44294 char *kwnames[] = {
44295 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44296 };
44297
44298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:wxIndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44300 if (SWIG_arg_fail(1)) SWIG_fail;
44301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44302 if (SWIG_arg_fail(2)) SWIG_fail;
44303 if (obj2) {
44304 {
44305 arg3 = (int)(SWIG_As_int(obj2));
44306 if (SWIG_arg_fail(3)) SWIG_fail;
44307 }
44308 }
44309 {
44310 PyThreadState* __tstate = wxPyBeginAllowThreads();
44311 (arg1)->Below(arg2,arg3);
44312
44313 wxPyEndAllowThreads(__tstate);
44314 if (PyErr_Occurred()) SWIG_fail;
44315 }
44316 Py_INCREF(Py_None); resultobj = Py_None;
44317 return resultobj;
44318 fail:
44319 return NULL;
44320 }
44321
44322
44323 static PyObject *_wrap_wxIndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44324 PyObject *resultobj;
44325 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44326 wxWindow *arg2 = (wxWindow *) 0 ;
44327 wxEdge arg3 ;
44328 int arg4 = (int) 0 ;
44329 PyObject * obj0 = 0 ;
44330 PyObject * obj1 = 0 ;
44331 PyObject * obj2 = 0 ;
44332 PyObject * obj3 = 0 ;
44333 char *kwnames[] = {
44334 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44335 };
44336
44337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:wxIndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44339 if (SWIG_arg_fail(1)) SWIG_fail;
44340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44341 if (SWIG_arg_fail(2)) SWIG_fail;
44342 {
44343 arg3 = (wxEdge)(SWIG_As_int(obj2));
44344 if (SWIG_arg_fail(3)) SWIG_fail;
44345 }
44346 if (obj3) {
44347 {
44348 arg4 = (int)(SWIG_As_int(obj3));
44349 if (SWIG_arg_fail(4)) SWIG_fail;
44350 }
44351 }
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44355
44356 wxPyEndAllowThreads(__tstate);
44357 if (PyErr_Occurred()) SWIG_fail;
44358 }
44359 Py_INCREF(Py_None); resultobj = Py_None;
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 static PyObject *_wrap_wxIndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44367 PyObject *resultobj;
44368 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44369 wxWindow *arg2 = (wxWindow *) 0 ;
44370 wxEdge arg3 ;
44371 int arg4 ;
44372 PyObject * obj0 = 0 ;
44373 PyObject * obj1 = 0 ;
44374 PyObject * obj2 = 0 ;
44375 PyObject * obj3 = 0 ;
44376 char *kwnames[] = {
44377 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44378 };
44379
44380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxIndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44382 if (SWIG_arg_fail(1)) SWIG_fail;
44383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44384 if (SWIG_arg_fail(2)) SWIG_fail;
44385 {
44386 arg3 = (wxEdge)(SWIG_As_int(obj2));
44387 if (SWIG_arg_fail(3)) SWIG_fail;
44388 }
44389 {
44390 arg4 = (int)(SWIG_As_int(obj3));
44391 if (SWIG_arg_fail(4)) SWIG_fail;
44392 }
44393 {
44394 PyThreadState* __tstate = wxPyBeginAllowThreads();
44395 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44396
44397 wxPyEndAllowThreads(__tstate);
44398 if (PyErr_Occurred()) SWIG_fail;
44399 }
44400 Py_INCREF(Py_None); resultobj = Py_None;
44401 return resultobj;
44402 fail:
44403 return NULL;
44404 }
44405
44406
44407 static PyObject *_wrap_wxIndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44408 PyObject *resultobj;
44409 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44410 int arg2 ;
44411 PyObject * obj0 = 0 ;
44412 PyObject * obj1 = 0 ;
44413 char *kwnames[] = {
44414 (char *) "self",(char *) "val", NULL
44415 };
44416
44417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44419 if (SWIG_arg_fail(1)) SWIG_fail;
44420 {
44421 arg2 = (int)(SWIG_As_int(obj1));
44422 if (SWIG_arg_fail(2)) SWIG_fail;
44423 }
44424 {
44425 PyThreadState* __tstate = wxPyBeginAllowThreads();
44426 (arg1)->Absolute(arg2);
44427
44428 wxPyEndAllowThreads(__tstate);
44429 if (PyErr_Occurred()) SWIG_fail;
44430 }
44431 Py_INCREF(Py_None); resultobj = Py_None;
44432 return resultobj;
44433 fail:
44434 return NULL;
44435 }
44436
44437
44438 static PyObject *_wrap_wxIndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44439 PyObject *resultobj;
44440 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44441 PyObject * obj0 = 0 ;
44442 char *kwnames[] = {
44443 (char *) "self", NULL
44444 };
44445
44446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44448 if (SWIG_arg_fail(1)) SWIG_fail;
44449 {
44450 PyThreadState* __tstate = wxPyBeginAllowThreads();
44451 (arg1)->Unconstrained();
44452
44453 wxPyEndAllowThreads(__tstate);
44454 if (PyErr_Occurred()) SWIG_fail;
44455 }
44456 Py_INCREF(Py_None); resultobj = Py_None;
44457 return resultobj;
44458 fail:
44459 return NULL;
44460 }
44461
44462
44463 static PyObject *_wrap_wxIndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44464 PyObject *resultobj;
44465 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44466 PyObject * obj0 = 0 ;
44467 char *kwnames[] = {
44468 (char *) "self", NULL
44469 };
44470
44471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44473 if (SWIG_arg_fail(1)) SWIG_fail;
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 (arg1)->AsIs();
44477
44478 wxPyEndAllowThreads(__tstate);
44479 if (PyErr_Occurred()) SWIG_fail;
44480 }
44481 Py_INCREF(Py_None); resultobj = Py_None;
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 static PyObject *_wrap_wxIndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44489 PyObject *resultobj;
44490 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44491 wxWindow *result;
44492 PyObject * obj0 = 0 ;
44493 char *kwnames[] = {
44494 (char *) "self", NULL
44495 };
44496
44497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44499 if (SWIG_arg_fail(1)) SWIG_fail;
44500 {
44501 PyThreadState* __tstate = wxPyBeginAllowThreads();
44502 result = (wxWindow *)(arg1)->GetOtherWindow();
44503
44504 wxPyEndAllowThreads(__tstate);
44505 if (PyErr_Occurred()) SWIG_fail;
44506 }
44507 {
44508 resultobj = wxPyMake_wxObject(result, 0);
44509 }
44510 return resultobj;
44511 fail:
44512 return NULL;
44513 }
44514
44515
44516 static PyObject *_wrap_wxIndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44517 PyObject *resultobj;
44518 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44519 wxEdge result;
44520 PyObject * obj0 = 0 ;
44521 char *kwnames[] = {
44522 (char *) "self", NULL
44523 };
44524
44525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44527 if (SWIG_arg_fail(1)) SWIG_fail;
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44531
44532 wxPyEndAllowThreads(__tstate);
44533 if (PyErr_Occurred()) SWIG_fail;
44534 }
44535 resultobj = SWIG_From_int((result));
44536 return resultobj;
44537 fail:
44538 return NULL;
44539 }
44540
44541
44542 static PyObject *_wrap_wxIndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44543 PyObject *resultobj;
44544 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44545 wxEdge arg2 ;
44546 PyObject * obj0 = 0 ;
44547 PyObject * obj1 = 0 ;
44548 char *kwnames[] = {
44549 (char *) "self",(char *) "which", NULL
44550 };
44551
44552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44554 if (SWIG_arg_fail(1)) SWIG_fail;
44555 {
44556 arg2 = (wxEdge)(SWIG_As_int(obj1));
44557 if (SWIG_arg_fail(2)) SWIG_fail;
44558 }
44559 {
44560 PyThreadState* __tstate = wxPyBeginAllowThreads();
44561 (arg1)->SetEdge((wxEdge )arg2);
44562
44563 wxPyEndAllowThreads(__tstate);
44564 if (PyErr_Occurred()) SWIG_fail;
44565 }
44566 Py_INCREF(Py_None); resultobj = Py_None;
44567 return resultobj;
44568 fail:
44569 return NULL;
44570 }
44571
44572
44573 static PyObject *_wrap_wxIndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44574 PyObject *resultobj;
44575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44576 int arg2 ;
44577 PyObject * obj0 = 0 ;
44578 PyObject * obj1 = 0 ;
44579 char *kwnames[] = {
44580 (char *) "self",(char *) "v", NULL
44581 };
44582
44583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44585 if (SWIG_arg_fail(1)) SWIG_fail;
44586 {
44587 arg2 = (int)(SWIG_As_int(obj1));
44588 if (SWIG_arg_fail(2)) SWIG_fail;
44589 }
44590 {
44591 PyThreadState* __tstate = wxPyBeginAllowThreads();
44592 (arg1)->SetValue(arg2);
44593
44594 wxPyEndAllowThreads(__tstate);
44595 if (PyErr_Occurred()) SWIG_fail;
44596 }
44597 Py_INCREF(Py_None); resultobj = Py_None;
44598 return resultobj;
44599 fail:
44600 return NULL;
44601 }
44602
44603
44604 static PyObject *_wrap_wxIndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44605 PyObject *resultobj;
44606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44607 int result;
44608 PyObject * obj0 = 0 ;
44609 char *kwnames[] = {
44610 (char *) "self", NULL
44611 };
44612
44613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44615 if (SWIG_arg_fail(1)) SWIG_fail;
44616 {
44617 PyThreadState* __tstate = wxPyBeginAllowThreads();
44618 result = (int)(arg1)->GetMargin();
44619
44620 wxPyEndAllowThreads(__tstate);
44621 if (PyErr_Occurred()) SWIG_fail;
44622 }
44623 {
44624 resultobj = SWIG_From_int((int)(result));
44625 }
44626 return resultobj;
44627 fail:
44628 return NULL;
44629 }
44630
44631
44632 static PyObject *_wrap_wxIndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44633 PyObject *resultobj;
44634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44635 int arg2 ;
44636 PyObject * obj0 = 0 ;
44637 PyObject * obj1 = 0 ;
44638 char *kwnames[] = {
44639 (char *) "self",(char *) "m", NULL
44640 };
44641
44642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44644 if (SWIG_arg_fail(1)) SWIG_fail;
44645 {
44646 arg2 = (int)(SWIG_As_int(obj1));
44647 if (SWIG_arg_fail(2)) SWIG_fail;
44648 }
44649 {
44650 PyThreadState* __tstate = wxPyBeginAllowThreads();
44651 (arg1)->SetMargin(arg2);
44652
44653 wxPyEndAllowThreads(__tstate);
44654 if (PyErr_Occurred()) SWIG_fail;
44655 }
44656 Py_INCREF(Py_None); resultobj = Py_None;
44657 return resultobj;
44658 fail:
44659 return NULL;
44660 }
44661
44662
44663 static PyObject *_wrap_wxIndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44664 PyObject *resultobj;
44665 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44666 int result;
44667 PyObject * obj0 = 0 ;
44668 char *kwnames[] = {
44669 (char *) "self", NULL
44670 };
44671
44672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44674 if (SWIG_arg_fail(1)) SWIG_fail;
44675 {
44676 PyThreadState* __tstate = wxPyBeginAllowThreads();
44677 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44678
44679 wxPyEndAllowThreads(__tstate);
44680 if (PyErr_Occurred()) SWIG_fail;
44681 }
44682 {
44683 resultobj = SWIG_From_int((int)(result));
44684 }
44685 return resultobj;
44686 fail:
44687 return NULL;
44688 }
44689
44690
44691 static PyObject *_wrap_wxIndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44692 PyObject *resultobj;
44693 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44694 int result;
44695 PyObject * obj0 = 0 ;
44696 char *kwnames[] = {
44697 (char *) "self", NULL
44698 };
44699
44700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44702 if (SWIG_arg_fail(1)) SWIG_fail;
44703 {
44704 PyThreadState* __tstate = wxPyBeginAllowThreads();
44705 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44706
44707 wxPyEndAllowThreads(__tstate);
44708 if (PyErr_Occurred()) SWIG_fail;
44709 }
44710 {
44711 resultobj = SWIG_From_int((int)(result));
44712 }
44713 return resultobj;
44714 fail:
44715 return NULL;
44716 }
44717
44718
44719 static PyObject *_wrap_wxIndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44720 PyObject *resultobj;
44721 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44722 int result;
44723 PyObject * obj0 = 0 ;
44724 char *kwnames[] = {
44725 (char *) "self", NULL
44726 };
44727
44728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44730 if (SWIG_arg_fail(1)) SWIG_fail;
44731 {
44732 PyThreadState* __tstate = wxPyBeginAllowThreads();
44733 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44734
44735 wxPyEndAllowThreads(__tstate);
44736 if (PyErr_Occurred()) SWIG_fail;
44737 }
44738 {
44739 resultobj = SWIG_From_int((int)(result));
44740 }
44741 return resultobj;
44742 fail:
44743 return NULL;
44744 }
44745
44746
44747 static PyObject *_wrap_wxIndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44748 PyObject *resultobj;
44749 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44750 bool result;
44751 PyObject * obj0 = 0 ;
44752 char *kwnames[] = {
44753 (char *) "self", NULL
44754 };
44755
44756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44758 if (SWIG_arg_fail(1)) SWIG_fail;
44759 {
44760 PyThreadState* __tstate = wxPyBeginAllowThreads();
44761 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44762
44763 wxPyEndAllowThreads(__tstate);
44764 if (PyErr_Occurred()) SWIG_fail;
44765 }
44766 {
44767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44768 }
44769 return resultobj;
44770 fail:
44771 return NULL;
44772 }
44773
44774
44775 static PyObject *_wrap_wxIndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44776 PyObject *resultobj;
44777 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44778 bool arg2 ;
44779 PyObject * obj0 = 0 ;
44780 PyObject * obj1 = 0 ;
44781 char *kwnames[] = {
44782 (char *) "self",(char *) "d", NULL
44783 };
44784
44785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44787 if (SWIG_arg_fail(1)) SWIG_fail;
44788 {
44789 arg2 = (bool)(SWIG_As_bool(obj1));
44790 if (SWIG_arg_fail(2)) SWIG_fail;
44791 }
44792 {
44793 PyThreadState* __tstate = wxPyBeginAllowThreads();
44794 (arg1)->SetDone(arg2);
44795
44796 wxPyEndAllowThreads(__tstate);
44797 if (PyErr_Occurred()) SWIG_fail;
44798 }
44799 Py_INCREF(Py_None); resultobj = Py_None;
44800 return resultobj;
44801 fail:
44802 return NULL;
44803 }
44804
44805
44806 static PyObject *_wrap_wxIndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44807 PyObject *resultobj;
44808 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44809 wxRelationship result;
44810 PyObject * obj0 = 0 ;
44811 char *kwnames[] = {
44812 (char *) "self", NULL
44813 };
44814
44815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxIndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44817 if (SWIG_arg_fail(1)) SWIG_fail;
44818 {
44819 PyThreadState* __tstate = wxPyBeginAllowThreads();
44820 result = (wxRelationship)(arg1)->GetRelationship();
44821
44822 wxPyEndAllowThreads(__tstate);
44823 if (PyErr_Occurred()) SWIG_fail;
44824 }
44825 resultobj = SWIG_From_int((result));
44826 return resultobj;
44827 fail:
44828 return NULL;
44829 }
44830
44831
44832 static PyObject *_wrap_wxIndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44833 PyObject *resultobj;
44834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44835 wxRelationship arg2 ;
44836 PyObject * obj0 = 0 ;
44837 PyObject * obj1 = 0 ;
44838 char *kwnames[] = {
44839 (char *) "self",(char *) "r", NULL
44840 };
44841
44842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44844 if (SWIG_arg_fail(1)) SWIG_fail;
44845 {
44846 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44847 if (SWIG_arg_fail(2)) SWIG_fail;
44848 }
44849 {
44850 PyThreadState* __tstate = wxPyBeginAllowThreads();
44851 (arg1)->SetRelationship((wxRelationship )arg2);
44852
44853 wxPyEndAllowThreads(__tstate);
44854 if (PyErr_Occurred()) SWIG_fail;
44855 }
44856 Py_INCREF(Py_None); resultobj = Py_None;
44857 return resultobj;
44858 fail:
44859 return NULL;
44860 }
44861
44862
44863 static PyObject *_wrap_wxIndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44864 PyObject *resultobj;
44865 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44866 wxWindow *arg2 = (wxWindow *) 0 ;
44867 bool result;
44868 PyObject * obj0 = 0 ;
44869 PyObject * obj1 = 0 ;
44870 char *kwnames[] = {
44871 (char *) "self",(char *) "otherW", NULL
44872 };
44873
44874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxIndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44876 if (SWIG_arg_fail(1)) SWIG_fail;
44877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44878 if (SWIG_arg_fail(2)) SWIG_fail;
44879 {
44880 PyThreadState* __tstate = wxPyBeginAllowThreads();
44881 result = (bool)(arg1)->ResetIfWin(arg2);
44882
44883 wxPyEndAllowThreads(__tstate);
44884 if (PyErr_Occurred()) SWIG_fail;
44885 }
44886 {
44887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44888 }
44889 return resultobj;
44890 fail:
44891 return NULL;
44892 }
44893
44894
44895 static PyObject *_wrap_wxIndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44896 PyObject *resultobj;
44897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44898 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44899 wxWindow *arg3 = (wxWindow *) 0 ;
44900 bool result;
44901 PyObject * obj0 = 0 ;
44902 PyObject * obj1 = 0 ;
44903 PyObject * obj2 = 0 ;
44904 char *kwnames[] = {
44905 (char *) "self",(char *) "constraints",(char *) "win", NULL
44906 };
44907
44908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:wxIndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44910 if (SWIG_arg_fail(1)) SWIG_fail;
44911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44912 if (SWIG_arg_fail(2)) SWIG_fail;
44913 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44914 if (SWIG_arg_fail(3)) SWIG_fail;
44915 {
44916 PyThreadState* __tstate = wxPyBeginAllowThreads();
44917 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44918
44919 wxPyEndAllowThreads(__tstate);
44920 if (PyErr_Occurred()) SWIG_fail;
44921 }
44922 {
44923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44924 }
44925 return resultobj;
44926 fail:
44927 return NULL;
44928 }
44929
44930
44931 static PyObject *_wrap_wxIndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44932 PyObject *resultobj;
44933 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44934 wxEdge arg2 ;
44935 wxWindow *arg3 = (wxWindow *) 0 ;
44936 wxWindow *arg4 = (wxWindow *) 0 ;
44937 int result;
44938 PyObject * obj0 = 0 ;
44939 PyObject * obj1 = 0 ;
44940 PyObject * obj2 = 0 ;
44941 PyObject * obj3 = 0 ;
44942 char *kwnames[] = {
44943 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44944 };
44945
44946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:wxIndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44948 if (SWIG_arg_fail(1)) SWIG_fail;
44949 {
44950 arg2 = (wxEdge)(SWIG_As_int(obj1));
44951 if (SWIG_arg_fail(2)) SWIG_fail;
44952 }
44953 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44954 if (SWIG_arg_fail(3)) SWIG_fail;
44955 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44956 if (SWIG_arg_fail(4)) SWIG_fail;
44957 {
44958 PyThreadState* __tstate = wxPyBeginAllowThreads();
44959 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44960
44961 wxPyEndAllowThreads(__tstate);
44962 if (PyErr_Occurred()) SWIG_fail;
44963 }
44964 {
44965 resultobj = SWIG_From_int((int)(result));
44966 }
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 static PyObject * wxIndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44974 PyObject *obj;
44975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44976 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44977 Py_INCREF(obj);
44978 return Py_BuildValue((char *)"");
44979 }
44980 static PyObject *_wrap_wxLayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44981 PyObject *resultobj;
44982 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44983 wxIndividualLayoutConstraint *result;
44984 PyObject * obj0 = 0 ;
44985 char *kwnames[] = {
44986 (char *) "self", NULL
44987 };
44988
44989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44991 if (SWIG_arg_fail(1)) SWIG_fail;
44992 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44993
44994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44995 return resultobj;
44996 fail:
44997 return NULL;
44998 }
44999
45000
45001 static PyObject *_wrap_wxLayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45002 PyObject *resultobj;
45003 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45004 wxIndividualLayoutConstraint *result;
45005 PyObject * obj0 = 0 ;
45006 char *kwnames[] = {
45007 (char *) "self", NULL
45008 };
45009
45010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45012 if (SWIG_arg_fail(1)) SWIG_fail;
45013 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45014
45015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45016 return resultobj;
45017 fail:
45018 return NULL;
45019 }
45020
45021
45022 static PyObject *_wrap_wxLayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45023 PyObject *resultobj;
45024 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45025 wxIndividualLayoutConstraint *result;
45026 PyObject * obj0 = 0 ;
45027 char *kwnames[] = {
45028 (char *) "self", NULL
45029 };
45030
45031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45033 if (SWIG_arg_fail(1)) SWIG_fail;
45034 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45035
45036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45037 return resultobj;
45038 fail:
45039 return NULL;
45040 }
45041
45042
45043 static PyObject *_wrap_wxLayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45044 PyObject *resultobj;
45045 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45046 wxIndividualLayoutConstraint *result;
45047 PyObject * obj0 = 0 ;
45048 char *kwnames[] = {
45049 (char *) "self", NULL
45050 };
45051
45052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45054 if (SWIG_arg_fail(1)) SWIG_fail;
45055 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45056
45057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45058 return resultobj;
45059 fail:
45060 return NULL;
45061 }
45062
45063
45064 static PyObject *_wrap_wxLayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45065 PyObject *resultobj;
45066 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45067 wxIndividualLayoutConstraint *result;
45068 PyObject * obj0 = 0 ;
45069 char *kwnames[] = {
45070 (char *) "self", NULL
45071 };
45072
45073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45075 if (SWIG_arg_fail(1)) SWIG_fail;
45076 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45077
45078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45079 return resultobj;
45080 fail:
45081 return NULL;
45082 }
45083
45084
45085 static PyObject *_wrap_wxLayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45086 PyObject *resultobj;
45087 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45088 wxIndividualLayoutConstraint *result;
45089 PyObject * obj0 = 0 ;
45090 char *kwnames[] = {
45091 (char *) "self", NULL
45092 };
45093
45094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45096 if (SWIG_arg_fail(1)) SWIG_fail;
45097 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45098
45099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45100 return resultobj;
45101 fail:
45102 return NULL;
45103 }
45104
45105
45106 static PyObject *_wrap_wxLayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45107 PyObject *resultobj;
45108 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45109 wxIndividualLayoutConstraint *result;
45110 PyObject * obj0 = 0 ;
45111 char *kwnames[] = {
45112 (char *) "self", NULL
45113 };
45114
45115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45117 if (SWIG_arg_fail(1)) SWIG_fail;
45118 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45119
45120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45121 return resultobj;
45122 fail:
45123 return NULL;
45124 }
45125
45126
45127 static PyObject *_wrap_wxLayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45128 PyObject *resultobj;
45129 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45130 wxIndividualLayoutConstraint *result;
45131 PyObject * obj0 = 0 ;
45132 char *kwnames[] = {
45133 (char *) "self", NULL
45134 };
45135
45136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45138 if (SWIG_arg_fail(1)) SWIG_fail;
45139 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45140
45141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45142 return resultobj;
45143 fail:
45144 return NULL;
45145 }
45146
45147
45148 static PyObject *_wrap_new_wxLayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45149 PyObject *resultobj;
45150 wxLayoutConstraints *result;
45151 char *kwnames[] = {
45152 NULL
45153 };
45154
45155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_wxLayoutConstraints",kwnames)) goto fail;
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45159
45160 wxPyEndAllowThreads(__tstate);
45161 if (PyErr_Occurred()) SWIG_fail;
45162 }
45163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45164 return resultobj;
45165 fail:
45166 return NULL;
45167 }
45168
45169
45170 static PyObject *_wrap_wxLayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45171 PyObject *resultobj;
45172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45173 wxWindow *arg2 = (wxWindow *) 0 ;
45174 int *arg3 = (int *) 0 ;
45175 bool result;
45176 int temp3 ;
45177 int res3 = 0 ;
45178 PyObject * obj0 = 0 ;
45179 PyObject * obj1 = 0 ;
45180 char *kwnames[] = {
45181 (char *) "self",(char *) "win", NULL
45182 };
45183
45184 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:wxLayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45187 if (SWIG_arg_fail(1)) SWIG_fail;
45188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45189 if (SWIG_arg_fail(2)) SWIG_fail;
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45193
45194 wxPyEndAllowThreads(__tstate);
45195 if (PyErr_Occurred()) SWIG_fail;
45196 }
45197 {
45198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45199 }
45200 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45201 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45202 return resultobj;
45203 fail:
45204 return NULL;
45205 }
45206
45207
45208 static PyObject *_wrap_wxLayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45209 PyObject *resultobj;
45210 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45211 bool result;
45212 PyObject * obj0 = 0 ;
45213 char *kwnames[] = {
45214 (char *) "self", NULL
45215 };
45216
45217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:wxLayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45219 if (SWIG_arg_fail(1)) SWIG_fail;
45220 {
45221 PyThreadState* __tstate = wxPyBeginAllowThreads();
45222 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45223
45224 wxPyEndAllowThreads(__tstate);
45225 if (PyErr_Occurred()) SWIG_fail;
45226 }
45227 {
45228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45229 }
45230 return resultobj;
45231 fail:
45232 return NULL;
45233 }
45234
45235
45236 static PyObject * wxLayoutConstraints_swigregister(PyObject *, PyObject *args) {
45237 PyObject *obj;
45238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45239 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45240 Py_INCREF(obj);
45241 return Py_BuildValue((char *)"");
45242 }
45243 static PyMethodDef SwigMethods[] = {
45244 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45245 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45246 { (char *)"wxObject_GetClassName", (PyCFunction) _wrap_wxObject_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"wxObject_Destroy", (PyCFunction) _wrap_wxObject_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"wxObject_swigregister", wxObject_swigregister, METH_VARARGS, NULL},
45249 { (char *)"wxSize_width_set", (PyCFunction) _wrap_wxSize_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"wxSize_width_get", (PyCFunction) _wrap_wxSize_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"wxSize_height_set", (PyCFunction) _wrap_wxSize_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"wxSize_height_get", (PyCFunction) _wrap_wxSize_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"new_wxSize", (PyCFunction) _wrap_new_wxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"delete_wxSize", (PyCFunction) _wrap_delete_wxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"wxSize___eq__", (PyCFunction) _wrap_wxSize___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"wxSize___ne__", (PyCFunction) _wrap_wxSize___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"wxSize___add__", (PyCFunction) _wrap_wxSize___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"wxSize___sub__", (PyCFunction) _wrap_wxSize___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"wxSize_IncTo", (PyCFunction) _wrap_wxSize_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"wxSize_DecTo", (PyCFunction) _wrap_wxSize_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"wxSize_Set", (PyCFunction) _wrap_wxSize_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"wxSize_SetWidth", (PyCFunction) _wrap_wxSize_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"wxSize_SetHeight", (PyCFunction) _wrap_wxSize_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"wxSize_GetWidth", (PyCFunction) _wrap_wxSize_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"wxSize_GetHeight", (PyCFunction) _wrap_wxSize_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"wxSize_IsFullySpecified", (PyCFunction) _wrap_wxSize_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"wxSize_SetDefaults", (PyCFunction) _wrap_wxSize_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"wxSize_Get", (PyCFunction) _wrap_wxSize_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"wxSize_swigregister", wxSize_swigregister, METH_VARARGS, NULL},
45270 { (char *)"wxRealPoint_x_set", (PyCFunction) _wrap_wxRealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"wxRealPoint_x_get", (PyCFunction) _wrap_wxRealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"wxRealPoint_y_set", (PyCFunction) _wrap_wxRealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"wxRealPoint_y_get", (PyCFunction) _wrap_wxRealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"new_wxRealPoint", (PyCFunction) _wrap_new_wxRealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"delete_wxRealPoint", (PyCFunction) _wrap_delete_wxRealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"wxRealPoint___eq__", (PyCFunction) _wrap_wxRealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"wxRealPoint___ne__", (PyCFunction) _wrap_wxRealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"wxRealPoint___add__", (PyCFunction) _wrap_wxRealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"wxRealPoint___sub__", (PyCFunction) _wrap_wxRealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"wxRealPoint_Set", (PyCFunction) _wrap_wxRealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"wxRealPoint_Get", (PyCFunction) _wrap_wxRealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"wxRealPoint_swigregister", wxRealPoint_swigregister, METH_VARARGS, NULL},
45283 { (char *)"wxPoint_x_set", (PyCFunction) _wrap_wxPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"wxPoint_x_get", (PyCFunction) _wrap_wxPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"wxPoint_y_set", (PyCFunction) _wrap_wxPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"wxPoint_y_get", (PyCFunction) _wrap_wxPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"new_wxPoint", (PyCFunction) _wrap_new_wxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"delete_wxPoint", (PyCFunction) _wrap_delete_wxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"wxPoint___eq__", (PyCFunction) _wrap_wxPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"wxPoint___ne__", (PyCFunction) _wrap_wxPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"wxPoint___add__", (PyCFunction) _wrap_wxPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"wxPoint___sub__", (PyCFunction) _wrap_wxPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"wxPoint___iadd__", (PyCFunction) _wrap_wxPoint___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"wxPoint___isub__", (PyCFunction) _wrap_wxPoint___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"wxPoint_Set", (PyCFunction) _wrap_wxPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"wxPoint_Get", (PyCFunction) _wrap_wxPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"wxPoint_swigregister", wxPoint_swigregister, METH_VARARGS, NULL},
45298 { (char *)"new_wxRect", (PyCFunction) _wrap_new_wxRect, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"delete_wxRect", (PyCFunction) _wrap_delete_wxRect, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"wxRect_GetX", (PyCFunction) _wrap_wxRect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"wxRect_SetX", (PyCFunction) _wrap_wxRect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"wxRect_GetY", (PyCFunction) _wrap_wxRect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"wxRect_SetY", (PyCFunction) _wrap_wxRect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"wxRect_GetWidth", (PyCFunction) _wrap_wxRect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"wxRect_SetWidth", (PyCFunction) _wrap_wxRect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"wxRect_GetHeight", (PyCFunction) _wrap_wxRect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"wxRect_SetHeight", (PyCFunction) _wrap_wxRect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"wxRect_GetPosition", (PyCFunction) _wrap_wxRect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"wxRect_SetPosition", (PyCFunction) _wrap_wxRect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"wxRect_GetSize", (PyCFunction) _wrap_wxRect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"wxRect_SetSize", (PyCFunction) _wrap_wxRect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"wxRect_IsEmpty", (PyCFunction) _wrap_wxRect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"wxRect_GetTopLeft", (PyCFunction) _wrap_wxRect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"wxRect_SetTopLeft", (PyCFunction) _wrap_wxRect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"wxRect_GetBottomRight", (PyCFunction) _wrap_wxRect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"wxRect_SetBottomRight", (PyCFunction) _wrap_wxRect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"wxRect_GetLeft", (PyCFunction) _wrap_wxRect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"wxRect_GetTop", (PyCFunction) _wrap_wxRect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"wxRect_GetBottom", (PyCFunction) _wrap_wxRect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"wxRect_GetRight", (PyCFunction) _wrap_wxRect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"wxRect_SetLeft", (PyCFunction) _wrap_wxRect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"wxRect_SetRight", (PyCFunction) _wrap_wxRect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"wxRect_SetTop", (PyCFunction) _wrap_wxRect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"wxRect_SetBottom", (PyCFunction) _wrap_wxRect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"wxRect_Inflate", (PyCFunction) _wrap_wxRect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"wxRect_Deflate", (PyCFunction) _wrap_wxRect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"wxRect_OffsetXY", (PyCFunction) _wrap_wxRect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"wxRect_Offset", (PyCFunction) _wrap_wxRect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"wxRect_Intersect", (PyCFunction) _wrap_wxRect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"wxRect_Union", (PyCFunction) _wrap_wxRect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"wxRect___add__", (PyCFunction) _wrap_wxRect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"wxRect___iadd__", (PyCFunction) _wrap_wxRect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"wxRect___eq__", (PyCFunction) _wrap_wxRect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"wxRect___ne__", (PyCFunction) _wrap_wxRect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"wxRect_InsideXY", (PyCFunction) _wrap_wxRect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"wxRect_Inside", (PyCFunction) _wrap_wxRect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"wxRect_Intersects", (PyCFunction) _wrap_wxRect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"wxRect_x_set", (PyCFunction) _wrap_wxRect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"wxRect_x_get", (PyCFunction) _wrap_wxRect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"wxRect_y_set", (PyCFunction) _wrap_wxRect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"wxRect_y_get", (PyCFunction) _wrap_wxRect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"wxRect_width_set", (PyCFunction) _wrap_wxRect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"wxRect_width_get", (PyCFunction) _wrap_wxRect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"wxRect_height_set", (PyCFunction) _wrap_wxRect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"wxRect_height_get", (PyCFunction) _wrap_wxRect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"wxRect_Set", (PyCFunction) _wrap_wxRect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"wxRect_Get", (PyCFunction) _wrap_wxRect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"wxRect_swigregister", wxRect_swigregister, METH_VARARGS, NULL},
45352 { (char *)"wxIntersectRect", (PyCFunction) _wrap_wxIntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"new_wxPoint2D", (PyCFunction) _wrap_new_wxPoint2D, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"wxPoint2D_GetFloor", (PyCFunction) _wrap_wxPoint2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"wxPoint2D_GetRounded", (PyCFunction) _wrap_wxPoint2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"wxPoint2D_GetVectorLength", (PyCFunction) _wrap_wxPoint2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"wxPoint2D_GetVectorAngle", (PyCFunction) _wrap_wxPoint2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"wxPoint2D_SetVectorLength", (PyCFunction) _wrap_wxPoint2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"wxPoint2D_SetVectorAngle", (PyCFunction) _wrap_wxPoint2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"wxPoint2D_GetDistance", (PyCFunction) _wrap_wxPoint2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"wxPoint2D_GetDistanceSquare", (PyCFunction) _wrap_wxPoint2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"wxPoint2D_GetDotProduct", (PyCFunction) _wrap_wxPoint2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"wxPoint2D_GetCrossProduct", (PyCFunction) _wrap_wxPoint2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"wxPoint2D___neg__", (PyCFunction) _wrap_wxPoint2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"wxPoint2D___iadd__", (PyCFunction) _wrap_wxPoint2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"wxPoint2D___isub__", (PyCFunction) _wrap_wxPoint2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"wxPoint2D___imul__", (PyCFunction) _wrap_wxPoint2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"wxPoint2D___idiv__", (PyCFunction) _wrap_wxPoint2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"wxPoint2D___eq__", (PyCFunction) _wrap_wxPoint2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"wxPoint2D___ne__", (PyCFunction) _wrap_wxPoint2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"wxPoint2D_x_set", (PyCFunction) _wrap_wxPoint2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"wxPoint2D_x_get", (PyCFunction) _wrap_wxPoint2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"wxPoint2D_y_set", (PyCFunction) _wrap_wxPoint2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"wxPoint2D_y_get", (PyCFunction) _wrap_wxPoint2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"wxPoint2D_Set", (PyCFunction) _wrap_wxPoint2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"wxPoint2D_Get", (PyCFunction) _wrap_wxPoint2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"wxPoint2D_swigregister", wxPoint2D_swigregister, METH_VARARGS, NULL},
45380 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45399 { (char *)"wxOutputStream_write", (PyCFunction) _wrap_wxOutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"wxOutputStream_swigregister", wxOutputStream_swigregister, METH_VARARGS, NULL},
45401 { (char *)"new_wxFSFile", (PyCFunction) _wrap_new_wxFSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"delete_wxFSFile", (PyCFunction) _wrap_delete_wxFSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"wxFSFile_GetStream", (PyCFunction) _wrap_wxFSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"wxFSFile_GetMimeType", (PyCFunction) _wrap_wxFSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"wxFSFile_GetLocation", (PyCFunction) _wrap_wxFSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"wxFSFile_GetAnchor", (PyCFunction) _wrap_wxFSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"wxFSFile_GetModificationTime", (PyCFunction) _wrap_wxFSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"wxFSFile_swigregister", wxFSFile_swigregister, METH_VARARGS, NULL},
45409 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45410 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45422 { (char *)"new_wxFileSystem", (PyCFunction) _wrap_new_wxFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"delete_wxFileSystem", (PyCFunction) _wrap_delete_wxFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"wxFileSystem_ChangePathTo", (PyCFunction) _wrap_wxFileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"wxFileSystem_GetPath", (PyCFunction) _wrap_wxFileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"wxFileSystem_OpenFile", (PyCFunction) _wrap_wxFileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"wxFileSystem_FindFirst", (PyCFunction) _wrap_wxFileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"wxFileSystem_FindNext", (PyCFunction) _wrap_wxFileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"wxFileSystem_AddHandler", (PyCFunction) _wrap_wxFileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"wxFileSystem_CleanUpHandlers", (PyCFunction) _wrap_wxFileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"wxFileSystem_FileNameToURL", (PyCFunction) _wrap_wxFileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"wxFileSystem_URLToFileName", (PyCFunction) _wrap_wxFileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"wxFileSystem_swigregister", wxFileSystem_swigregister, METH_VARARGS, NULL},
45434 { (char *)"new_wxInternetFSHandler", (PyCFunction) _wrap_new_wxInternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"wxInternetFSHandler_CanOpen", (PyCFunction) _wrap_wxInternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"wxInternetFSHandler_OpenFile", (PyCFunction) _wrap_wxInternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"wxInternetFSHandler_swigregister", wxInternetFSHandler_swigregister, METH_VARARGS, NULL},
45438 { (char *)"new_wxZipFSHandler", (PyCFunction) _wrap_new_wxZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"wxZipFSHandler_CanOpen", (PyCFunction) _wrap_wxZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"wxZipFSHandler_OpenFile", (PyCFunction) _wrap_wxZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"wxZipFSHandler_FindFirst", (PyCFunction) _wrap_wxZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"wxZipFSHandler_FindNext", (PyCFunction) _wrap_wxZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"wxZipFSHandler_swigregister", wxZipFSHandler_swigregister, METH_VARARGS, NULL},
45444 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"new_wxMemoryFSHandler", (PyCFunction) _wrap_new_wxMemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"wxMemoryFSHandler_RemoveFile", (PyCFunction) _wrap_wxMemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"wxMemoryFSHandler_CanOpen", (PyCFunction) _wrap_wxMemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"wxMemoryFSHandler_OpenFile", (PyCFunction) _wrap_wxMemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"wxMemoryFSHandler_FindFirst", (PyCFunction) _wrap_wxMemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"wxMemoryFSHandler_FindNext", (PyCFunction) _wrap_wxMemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"wxMemoryFSHandler_swigregister", wxMemoryFSHandler_swigregister, METH_VARARGS, NULL},
45454 { (char *)"wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"wxImageHandler_GetExtension", (PyCFunction) _wrap_wxImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"wxImageHandler_GetType", (PyCFunction) _wrap_wxImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"wxImageHandler_GetMimeType", (PyCFunction) _wrap_wxImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"wxImageHandler_CanRead", (PyCFunction) _wrap_wxImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"wxImageHandler_SetName", (PyCFunction) _wrap_wxImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"wxImageHandler_SetExtension", (PyCFunction) _wrap_wxImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"wxImageHandler_SetType", (PyCFunction) _wrap_wxImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"wxImageHandler_SetMimeType", (PyCFunction) _wrap_wxImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"wxImageHandler_swigregister", wxImageHandler_swigregister, METH_VARARGS, NULL},
45464 { (char *)"new_wxImageHistogram", (PyCFunction) _wrap_new_wxImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"wxImageHistogram_MakeKey", (PyCFunction) _wrap_wxImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"wxImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_wxImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"wxImageHistogram_GetCount", (PyCFunction) _wrap_wxImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"wxImageHistogram_GetCountRGB", (PyCFunction) _wrap_wxImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"wxImageHistogram_GetCountColour", (PyCFunction) _wrap_wxImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"wxImageHistogram_swigregister", wxImageHistogram_swigregister, METH_VARARGS, NULL},
45471 { (char *)"new_wxImage", (PyCFunction) _wrap_new_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"delete_wxImage", (PyCFunction) _wrap_delete_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"wxImage_Create", (PyCFunction) _wrap_wxImage_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"wxImage_Destroy", (PyCFunction) _wrap_wxImage_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"wxImage_Scale", (PyCFunction) _wrap_wxImage_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"wxImage_ShrinkBy", (PyCFunction) _wrap_wxImage_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"wxImage_Rescale", (PyCFunction) _wrap_wxImage_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"wxImage_Resize", (PyCFunction) _wrap_wxImage_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"wxImage_SetRGB", (PyCFunction) _wrap_wxImage_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"wxImage_SetRGBRect", (PyCFunction) _wrap_wxImage_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"wxImage_GetRed", (PyCFunction) _wrap_wxImage_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"wxImage_GetGreen", (PyCFunction) _wrap_wxImage_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"wxImage_GetBlue", (PyCFunction) _wrap_wxImage_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"wxImage_SetAlpha", (PyCFunction) _wrap_wxImage_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"wxImage_GetAlpha", (PyCFunction) _wrap_wxImage_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"wxImage_HasAlpha", (PyCFunction) _wrap_wxImage_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"wxImage_InitAlpha", (PyCFunction) _wrap_wxImage_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"wxImage_FindFirstUnusedColour", (PyCFunction) _wrap_wxImage_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"wxImage_ConvertAlphaToMask", (PyCFunction) _wrap_wxImage_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"wxImage_ConvertColourToAlpha", (PyCFunction) _wrap_wxImage_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"wxImage_SetMaskFromImage", (PyCFunction) _wrap_wxImage_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"wxImage_CanRead", (PyCFunction) _wrap_wxImage_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"wxImage_GetImageCount", (PyCFunction) _wrap_wxImage_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"wxImage_LoadFile", (PyCFunction) _wrap_wxImage_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"wxImage_CanReadStream", (PyCFunction) _wrap_wxImage_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"wxImage_LoadStream", (PyCFunction) _wrap_wxImage_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"wxImage_LoadMimeStream", (PyCFunction) _wrap_wxImage_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"wxImage_GetSize", (PyCFunction) _wrap_wxImage_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"wxImage_GetSubImage", (PyCFunction) _wrap_wxImage_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"wxImage_Size", (PyCFunction) _wrap_wxImage_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"wxImage_Copy", (PyCFunction) _wrap_wxImage_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"wxImage_Paste", (PyCFunction) _wrap_wxImage_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"wxImage_GetData", (PyCFunction) _wrap_wxImage_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"wxImage_SetData", (PyCFunction) _wrap_wxImage_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"wxImage_GetDataBuffer", (PyCFunction) _wrap_wxImage_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"wxImage_SetDataBuffer", (PyCFunction) _wrap_wxImage_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"wxImage_GetAlphaData", (PyCFunction) _wrap_wxImage_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"wxImage_SetAlphaData", (PyCFunction) _wrap_wxImage_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"wxImage_GetAlphaBuffer", (PyCFunction) _wrap_wxImage_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"wxImage_SetAlphaBuffer", (PyCFunction) _wrap_wxImage_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"wxImage_SetMaskColour", (PyCFunction) _wrap_wxImage_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"wxImage_GetOrFindMaskColour", (PyCFunction) _wrap_wxImage_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"wxImage_GetMaskRed", (PyCFunction) _wrap_wxImage_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"wxImage_GetMaskGreen", (PyCFunction) _wrap_wxImage_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"wxImage_GetMaskBlue", (PyCFunction) _wrap_wxImage_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"wxImage_SetMask", (PyCFunction) _wrap_wxImage_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"wxImage_HasMask", (PyCFunction) _wrap_wxImage_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"wxImage_Rotate", (PyCFunction) _wrap_wxImage_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"wxImage_Rotate90", (PyCFunction) _wrap_wxImage_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"wxImage_Mirror", (PyCFunction) _wrap_wxImage_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"wxImage_Replace", (PyCFunction) _wrap_wxImage_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"wxImage_ConvertToMono", (PyCFunction) _wrap_wxImage_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"wxImage_SetOption", (PyCFunction) _wrap_wxImage_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"wxImage_SetOptionInt", (PyCFunction) _wrap_wxImage_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"wxImage_GetOption", (PyCFunction) _wrap_wxImage_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"wxImage_GetOptionInt", (PyCFunction) _wrap_wxImage_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"wxImage_HasOption", (PyCFunction) _wrap_wxImage_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"wxImage_CountColours", (PyCFunction) _wrap_wxImage_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"wxImage_ComputeHistogram", (PyCFunction) _wrap_wxImage_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"wxImage_AddHandler", (PyCFunction) _wrap_wxImage_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"wxImage_InsertHandler", (PyCFunction) _wrap_wxImage_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"wxImage_RemoveHandler", (PyCFunction) _wrap_wxImage_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"wxImage_GetImageExtWildcard", (PyCFunction) _wrap_wxImage_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"wxImage_ConvertToBitmap", (PyCFunction) _wrap_wxImage_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"wxImage_ConvertToMonoBitmap", (PyCFunction) _wrap_wxImage_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"wxImage_swigregister", wxImage_swigregister, METH_VARARGS, NULL},
45550 { (char *)"new_wxBMPHandler", (PyCFunction) _wrap_new_wxBMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"wxBMPHandler_swigregister", wxBMPHandler_swigregister, METH_VARARGS, NULL},
45552 { (char *)"new_wxICOHandler", (PyCFunction) _wrap_new_wxICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"wxICOHandler_swigregister", wxICOHandler_swigregister, METH_VARARGS, NULL},
45554 { (char *)"new_wxCURHandler", (PyCFunction) _wrap_new_wxCURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"wxCURHandler_swigregister", wxCURHandler_swigregister, METH_VARARGS, NULL},
45556 { (char *)"new_wxANIHandler", (PyCFunction) _wrap_new_wxANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"wxANIHandler_swigregister", wxANIHandler_swigregister, METH_VARARGS, NULL},
45558 { (char *)"new_wxPNGHandler", (PyCFunction) _wrap_new_wxPNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"wxPNGHandler_swigregister", wxPNGHandler_swigregister, METH_VARARGS, NULL},
45560 { (char *)"new_wxGIFHandler", (PyCFunction) _wrap_new_wxGIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"wxGIFHandler_swigregister", wxGIFHandler_swigregister, METH_VARARGS, NULL},
45562 { (char *)"new_wxPCXHandler", (PyCFunction) _wrap_new_wxPCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"wxPCXHandler_swigregister", wxPCXHandler_swigregister, METH_VARARGS, NULL},
45564 { (char *)"new_wxJPEGHandler", (PyCFunction) _wrap_new_wxJPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"wxJPEGHandler_swigregister", wxJPEGHandler_swigregister, METH_VARARGS, NULL},
45566 { (char *)"new_wxPNMHandler", (PyCFunction) _wrap_new_wxPNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"wxPNMHandler_swigregister", wxPNMHandler_swigregister, METH_VARARGS, NULL},
45568 { (char *)"new_wxXPMHandler", (PyCFunction) _wrap_new_wxXPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"wxXPMHandler_swigregister", wxXPMHandler_swigregister, METH_VARARGS, NULL},
45570 { (char *)"new_wxTIFFHandler", (PyCFunction) _wrap_new_wxTIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"wxTIFFHandler_swigregister", wxTIFFHandler_swigregister, METH_VARARGS, NULL},
45572 { (char *)"wxQuantize_Quantize", (PyCFunction) _wrap_wxQuantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"wxQuantize_swigregister", wxQuantize_swigregister, METH_VARARGS, NULL},
45574 { (char *)"new_wxEvtHandler", (PyCFunction) _wrap_new_wxEvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"wxEvtHandler_GetNextHandler", (PyCFunction) _wrap_wxEvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"wxEvtHandler_GetPreviousHandler", (PyCFunction) _wrap_wxEvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"wxEvtHandler_SetNextHandler", (PyCFunction) _wrap_wxEvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"wxEvtHandler_SetPreviousHandler", (PyCFunction) _wrap_wxEvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"wxEvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_wxEvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"wxEvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_wxEvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"wxEvtHandler_ProcessEvent", (PyCFunction) _wrap_wxEvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"wxEvtHandler_AddPendingEvent", (PyCFunction) _wrap_wxEvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"wxEvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_wxEvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"wxEvtHandler_Connect", (PyCFunction) _wrap_wxEvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"wxEvtHandler_Disconnect", (PyCFunction) _wrap_wxEvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"wxEvtHandler__setOORInfo", (PyCFunction) _wrap_wxEvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"wxEvtHandler_swigregister", wxEvtHandler_swigregister, METH_VARARGS, NULL},
45588 { (char *)"wxNewEventType", (PyCFunction) _wrap_wxNewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"delete_wxEvent", (PyCFunction) _wrap_delete_wxEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"wxEvent_SetEventType", (PyCFunction) _wrap_wxEvent_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"wxEvent_GetEventType", (PyCFunction) _wrap_wxEvent_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"wxEvent_GetEventObject", (PyCFunction) _wrap_wxEvent_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"wxEvent_SetEventObject", (PyCFunction) _wrap_wxEvent_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"wxEvent_GetTimestamp", (PyCFunction) _wrap_wxEvent_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"wxEvent_SetTimestamp", (PyCFunction) _wrap_wxEvent_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"wxEvent_GetId", (PyCFunction) _wrap_wxEvent_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"wxEvent_SetId", (PyCFunction) _wrap_wxEvent_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"wxEvent_IsCommandEvent", (PyCFunction) _wrap_wxEvent_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"wxEvent_Skip", (PyCFunction) _wrap_wxEvent_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"wxEvent_GetSkipped", (PyCFunction) _wrap_wxEvent_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"wxEvent_ShouldPropagate", (PyCFunction) _wrap_wxEvent_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"wxEvent_StopPropagation", (PyCFunction) _wrap_wxEvent_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"wxEvent_ResumePropagation", (PyCFunction) _wrap_wxEvent_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"wxEvent_Clone", (PyCFunction) _wrap_wxEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"wxEvent_swigregister", wxEvent_swigregister, METH_VARARGS, NULL},
45606 { (char *)"new_wxPropagationDisabler", (PyCFunction) _wrap_new_wxPropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"delete_wxPropagationDisabler", (PyCFunction) _wrap_delete_wxPropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"wxPropagationDisabler_swigregister", wxPropagationDisabler_swigregister, METH_VARARGS, NULL},
45609 { (char *)"new_wxPropagateOnce", (PyCFunction) _wrap_new_wxPropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"delete_wxPropagateOnce", (PyCFunction) _wrap_delete_wxPropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"wxPropagateOnce_swigregister", wxPropagateOnce_swigregister, METH_VARARGS, NULL},
45612 { (char *)"new_wxCommandEvent", (PyCFunction) _wrap_new_wxCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"wxCommandEvent_GetSelection", (PyCFunction) _wrap_wxCommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"wxCommandEvent_SetString", (PyCFunction) _wrap_wxCommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"wxCommandEvent_GetString", (PyCFunction) _wrap_wxCommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"wxCommandEvent_IsChecked", (PyCFunction) _wrap_wxCommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"wxCommandEvent_IsSelection", (PyCFunction) _wrap_wxCommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"wxCommandEvent_SetExtraLong", (PyCFunction) _wrap_wxCommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"wxCommandEvent_GetExtraLong", (PyCFunction) _wrap_wxCommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"wxCommandEvent_SetInt", (PyCFunction) _wrap_wxCommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"wxCommandEvent_GetInt", (PyCFunction) _wrap_wxCommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"wxCommandEvent_Clone", (PyCFunction) _wrap_wxCommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"wxCommandEvent_swigregister", wxCommandEvent_swigregister, METH_VARARGS, NULL},
45624 { (char *)"new_wxNotifyEvent", (PyCFunction) _wrap_new_wxNotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"wxNotifyEvent_Veto", (PyCFunction) _wrap_wxNotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"wxNotifyEvent_Allow", (PyCFunction) _wrap_wxNotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"wxNotifyEvent_IsAllowed", (PyCFunction) _wrap_wxNotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"wxNotifyEvent_swigregister", wxNotifyEvent_swigregister, METH_VARARGS, NULL},
45629 { (char *)"new_wxScrollEvent", (PyCFunction) _wrap_new_wxScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"wxScrollEvent_GetOrientation", (PyCFunction) _wrap_wxScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"wxScrollEvent_GetPosition", (PyCFunction) _wrap_wxScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"wxScrollEvent_SetOrientation", (PyCFunction) _wrap_wxScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"wxScrollEvent_SetPosition", (PyCFunction) _wrap_wxScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"wxScrollEvent_swigregister", wxScrollEvent_swigregister, METH_VARARGS, NULL},
45635 { (char *)"new_wxScrollWinEvent", (PyCFunction) _wrap_new_wxScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"wxScrollWinEvent_GetOrientation", (PyCFunction) _wrap_wxScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"wxScrollWinEvent_GetPosition", (PyCFunction) _wrap_wxScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"wxScrollWinEvent_SetOrientation", (PyCFunction) _wrap_wxScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"wxScrollWinEvent_SetPosition", (PyCFunction) _wrap_wxScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"wxScrollWinEvent_swigregister", wxScrollWinEvent_swigregister, METH_VARARGS, NULL},
45641 { (char *)"new_wxMouseEvent", (PyCFunction) _wrap_new_wxMouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"wxMouseEvent_IsButton", (PyCFunction) _wrap_wxMouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"wxMouseEvent_ButtonDown", (PyCFunction) _wrap_wxMouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"wxMouseEvent_ButtonDClick", (PyCFunction) _wrap_wxMouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"wxMouseEvent_ButtonUp", (PyCFunction) _wrap_wxMouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"wxMouseEvent_Button", (PyCFunction) _wrap_wxMouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"wxMouseEvent_ButtonIsDown", (PyCFunction) _wrap_wxMouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"wxMouseEvent_GetButton", (PyCFunction) _wrap_wxMouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"wxMouseEvent_ControlDown", (PyCFunction) _wrap_wxMouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"wxMouseEvent_MetaDown", (PyCFunction) _wrap_wxMouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"wxMouseEvent_AltDown", (PyCFunction) _wrap_wxMouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"wxMouseEvent_ShiftDown", (PyCFunction) _wrap_wxMouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"wxMouseEvent_CmdDown", (PyCFunction) _wrap_wxMouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"wxMouseEvent_LeftDown", (PyCFunction) _wrap_wxMouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"wxMouseEvent_MiddleDown", (PyCFunction) _wrap_wxMouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"wxMouseEvent_RightDown", (PyCFunction) _wrap_wxMouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"wxMouseEvent_LeftUp", (PyCFunction) _wrap_wxMouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"wxMouseEvent_MiddleUp", (PyCFunction) _wrap_wxMouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"wxMouseEvent_RightUp", (PyCFunction) _wrap_wxMouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"wxMouseEvent_LeftDClick", (PyCFunction) _wrap_wxMouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"wxMouseEvent_MiddleDClick", (PyCFunction) _wrap_wxMouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"wxMouseEvent_RightDClick", (PyCFunction) _wrap_wxMouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"wxMouseEvent_LeftIsDown", (PyCFunction) _wrap_wxMouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"wxMouseEvent_MiddleIsDown", (PyCFunction) _wrap_wxMouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"wxMouseEvent_RightIsDown", (PyCFunction) _wrap_wxMouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"wxMouseEvent_Dragging", (PyCFunction) _wrap_wxMouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"wxMouseEvent_Moving", (PyCFunction) _wrap_wxMouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"wxMouseEvent_Entering", (PyCFunction) _wrap_wxMouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"wxMouseEvent_Leaving", (PyCFunction) _wrap_wxMouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"wxMouseEvent_GetPosition", (PyCFunction) _wrap_wxMouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"wxMouseEvent_GetPositionTuple", (PyCFunction) _wrap_wxMouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"wxMouseEvent_GetLogicalPosition", (PyCFunction) _wrap_wxMouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"wxMouseEvent_GetX", (PyCFunction) _wrap_wxMouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"wxMouseEvent_GetY", (PyCFunction) _wrap_wxMouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"wxMouseEvent_GetWheelRotation", (PyCFunction) _wrap_wxMouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"wxMouseEvent_GetWheelDelta", (PyCFunction) _wrap_wxMouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"wxMouseEvent_GetLinesPerAction", (PyCFunction) _wrap_wxMouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"wxMouseEvent_IsPageScroll", (PyCFunction) _wrap_wxMouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"wxMouseEvent_m_x_set", (PyCFunction) _wrap_wxMouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"wxMouseEvent_m_x_get", (PyCFunction) _wrap_wxMouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"wxMouseEvent_m_y_set", (PyCFunction) _wrap_wxMouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"wxMouseEvent_m_y_get", (PyCFunction) _wrap_wxMouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"wxMouseEvent_m_leftDown_set", (PyCFunction) _wrap_wxMouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"wxMouseEvent_m_leftDown_get", (PyCFunction) _wrap_wxMouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"wxMouseEvent_m_middleDown_set", (PyCFunction) _wrap_wxMouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"wxMouseEvent_m_middleDown_get", (PyCFunction) _wrap_wxMouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"wxMouseEvent_m_rightDown_set", (PyCFunction) _wrap_wxMouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"wxMouseEvent_m_rightDown_get", (PyCFunction) _wrap_wxMouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"wxMouseEvent_m_controlDown_set", (PyCFunction) _wrap_wxMouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"wxMouseEvent_m_controlDown_get", (PyCFunction) _wrap_wxMouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"wxMouseEvent_m_shiftDown_set", (PyCFunction) _wrap_wxMouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"wxMouseEvent_m_shiftDown_get", (PyCFunction) _wrap_wxMouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"wxMouseEvent_m_altDown_set", (PyCFunction) _wrap_wxMouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"wxMouseEvent_m_altDown_get", (PyCFunction) _wrap_wxMouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"wxMouseEvent_m_metaDown_set", (PyCFunction) _wrap_wxMouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"wxMouseEvent_m_metaDown_get", (PyCFunction) _wrap_wxMouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"wxMouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_wxMouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"wxMouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_wxMouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"wxMouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_wxMouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"wxMouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_wxMouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"wxMouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_wxMouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"wxMouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_wxMouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"wxMouseEvent_swigregister", wxMouseEvent_swigregister, METH_VARARGS, NULL},
45704 { (char *)"new_wxSetCursorEvent", (PyCFunction) _wrap_new_wxSetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"wxSetCursorEvent_GetX", (PyCFunction) _wrap_wxSetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"wxSetCursorEvent_GetY", (PyCFunction) _wrap_wxSetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"wxSetCursorEvent_SetCursor", (PyCFunction) _wrap_wxSetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"wxSetCursorEvent_GetCursor", (PyCFunction) _wrap_wxSetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"wxSetCursorEvent_HasCursor", (PyCFunction) _wrap_wxSetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"wxSetCursorEvent_swigregister", wxSetCursorEvent_swigregister, METH_VARARGS, NULL},
45711 { (char *)"new_wxKeyEvent", (PyCFunction) _wrap_new_wxKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"wxKeyEvent_ControlDown", (PyCFunction) _wrap_wxKeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"wxKeyEvent_MetaDown", (PyCFunction) _wrap_wxKeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"wxKeyEvent_AltDown", (PyCFunction) _wrap_wxKeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"wxKeyEvent_ShiftDown", (PyCFunction) _wrap_wxKeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"wxKeyEvent_CmdDown", (PyCFunction) _wrap_wxKeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"wxKeyEvent_HasModifiers", (PyCFunction) _wrap_wxKeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"wxKeyEvent_GetKeyCode", (PyCFunction) _wrap_wxKeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"wxKeyEvent_GetUnicodeKey", (PyCFunction) _wrap_wxKeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"wxKeyEvent_GetRawKeyCode", (PyCFunction) _wrap_wxKeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"wxKeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_wxKeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"wxKeyEvent_GetPosition", (PyCFunction) _wrap_wxKeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"wxKeyEvent_GetPositionTuple", (PyCFunction) _wrap_wxKeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"wxKeyEvent_GetX", (PyCFunction) _wrap_wxKeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"wxKeyEvent_GetY", (PyCFunction) _wrap_wxKeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"wxKeyEvent_m_x_set", (PyCFunction) _wrap_wxKeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"wxKeyEvent_m_x_get", (PyCFunction) _wrap_wxKeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"wxKeyEvent_m_y_set", (PyCFunction) _wrap_wxKeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"wxKeyEvent_m_y_get", (PyCFunction) _wrap_wxKeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"wxKeyEvent_m_keyCode_set", (PyCFunction) _wrap_wxKeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"wxKeyEvent_m_keyCode_get", (PyCFunction) _wrap_wxKeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"wxKeyEvent_m_controlDown_set", (PyCFunction) _wrap_wxKeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"wxKeyEvent_m_controlDown_get", (PyCFunction) _wrap_wxKeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"wxKeyEvent_m_shiftDown_set", (PyCFunction) _wrap_wxKeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"wxKeyEvent_m_shiftDown_get", (PyCFunction) _wrap_wxKeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"wxKeyEvent_m_altDown_set", (PyCFunction) _wrap_wxKeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"wxKeyEvent_m_altDown_get", (PyCFunction) _wrap_wxKeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"wxKeyEvent_m_metaDown_set", (PyCFunction) _wrap_wxKeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"wxKeyEvent_m_metaDown_get", (PyCFunction) _wrap_wxKeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"wxKeyEvent_m_scanCode_set", (PyCFunction) _wrap_wxKeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"wxKeyEvent_m_scanCode_get", (PyCFunction) _wrap_wxKeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"wxKeyEvent_m_rawCode_set", (PyCFunction) _wrap_wxKeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"wxKeyEvent_m_rawCode_get", (PyCFunction) _wrap_wxKeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"wxKeyEvent_m_rawFlags_set", (PyCFunction) _wrap_wxKeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"wxKeyEvent_m_rawFlags_get", (PyCFunction) _wrap_wxKeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"wxKeyEvent_swigregister", wxKeyEvent_swigregister, METH_VARARGS, NULL},
45747 { (char *)"new_wxSizeEvent", (PyCFunction) _wrap_new_wxSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"wxSizeEvent_GetSize", (PyCFunction) _wrap_wxSizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"wxSizeEvent_GetRect", (PyCFunction) _wrap_wxSizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"wxSizeEvent_SetRect", (PyCFunction) _wrap_wxSizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"wxSizeEvent_SetSize", (PyCFunction) _wrap_wxSizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"wxSizeEvent_m_size_set", (PyCFunction) _wrap_wxSizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"wxSizeEvent_m_size_get", (PyCFunction) _wrap_wxSizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"wxSizeEvent_m_rect_set", (PyCFunction) _wrap_wxSizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"wxSizeEvent_m_rect_get", (PyCFunction) _wrap_wxSizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"wxSizeEvent_swigregister", wxSizeEvent_swigregister, METH_VARARGS, NULL},
45757 { (char *)"new_wxMoveEvent", (PyCFunction) _wrap_new_wxMoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"wxMoveEvent_GetPosition", (PyCFunction) _wrap_wxMoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"wxMoveEvent_GetRect", (PyCFunction) _wrap_wxMoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"wxMoveEvent_SetRect", (PyCFunction) _wrap_wxMoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"wxMoveEvent_SetPosition", (PyCFunction) _wrap_wxMoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"wxMoveEvent_swigregister", wxMoveEvent_swigregister, METH_VARARGS, NULL},
45763 { (char *)"new_wxPaintEvent", (PyCFunction) _wrap_new_wxPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"wxPaintEvent_swigregister", wxPaintEvent_swigregister, METH_VARARGS, NULL},
45765 { (char *)"new_wxNcPaintEvent", (PyCFunction) _wrap_new_wxNcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"wxNcPaintEvent_swigregister", wxNcPaintEvent_swigregister, METH_VARARGS, NULL},
45767 { (char *)"new_wxEraseEvent", (PyCFunction) _wrap_new_wxEraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"wxEraseEvent_GetDC", (PyCFunction) _wrap_wxEraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"wxEraseEvent_swigregister", wxEraseEvent_swigregister, METH_VARARGS, NULL},
45770 { (char *)"new_wxFocusEvent", (PyCFunction) _wrap_new_wxFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"wxFocusEvent_GetWindow", (PyCFunction) _wrap_wxFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"wxFocusEvent_SetWindow", (PyCFunction) _wrap_wxFocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"wxFocusEvent_swigregister", wxFocusEvent_swigregister, METH_VARARGS, NULL},
45774 { (char *)"new_wxChildFocusEvent", (PyCFunction) _wrap_new_wxChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"wxChildFocusEvent_GetWindow", (PyCFunction) _wrap_wxChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"wxChildFocusEvent_swigregister", wxChildFocusEvent_swigregister, METH_VARARGS, NULL},
45777 { (char *)"new_wxActivateEvent", (PyCFunction) _wrap_new_wxActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"wxActivateEvent_GetActive", (PyCFunction) _wrap_wxActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"wxActivateEvent_swigregister", wxActivateEvent_swigregister, METH_VARARGS, NULL},
45780 { (char *)"new_wxInitDialogEvent", (PyCFunction) _wrap_new_wxInitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"wxInitDialogEvent_swigregister", wxInitDialogEvent_swigregister, METH_VARARGS, NULL},
45782 { (char *)"new_wxMenuEvent", (PyCFunction) _wrap_new_wxMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"wxMenuEvent_GetMenuId", (PyCFunction) _wrap_wxMenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"wxMenuEvent_IsPopup", (PyCFunction) _wrap_wxMenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"wxMenuEvent_GetMenu", (PyCFunction) _wrap_wxMenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"wxMenuEvent_swigregister", wxMenuEvent_swigregister, METH_VARARGS, NULL},
45787 { (char *)"new_wxCloseEvent", (PyCFunction) _wrap_new_wxCloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"wxCloseEvent_SetLoggingOff", (PyCFunction) _wrap_wxCloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"wxCloseEvent_GetLoggingOff", (PyCFunction) _wrap_wxCloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"wxCloseEvent_Veto", (PyCFunction) _wrap_wxCloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"wxCloseEvent_SetCanVeto", (PyCFunction) _wrap_wxCloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"wxCloseEvent_CanVeto", (PyCFunction) _wrap_wxCloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"wxCloseEvent_GetVeto", (PyCFunction) _wrap_wxCloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"wxCloseEvent_swigregister", wxCloseEvent_swigregister, METH_VARARGS, NULL},
45795 { (char *)"new_wxShowEvent", (PyCFunction) _wrap_new_wxShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"wxShowEvent_SetShow", (PyCFunction) _wrap_wxShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"wxShowEvent_GetShow", (PyCFunction) _wrap_wxShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"wxShowEvent_swigregister", wxShowEvent_swigregister, METH_VARARGS, NULL},
45799 { (char *)"new_wxIconizeEvent", (PyCFunction) _wrap_new_wxIconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"wxIconizeEvent_Iconized", (PyCFunction) _wrap_wxIconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"wxIconizeEvent_swigregister", wxIconizeEvent_swigregister, METH_VARARGS, NULL},
45802 { (char *)"new_wxMaximizeEvent", (PyCFunction) _wrap_new_wxMaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"wxMaximizeEvent_swigregister", wxMaximizeEvent_swigregister, METH_VARARGS, NULL},
45804 { (char *)"wxDropFilesEvent_GetPosition", (PyCFunction) _wrap_wxDropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"wxDropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_wxDropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"wxDropFilesEvent_GetFiles", (PyCFunction) _wrap_wxDropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"wxDropFilesEvent_swigregister", wxDropFilesEvent_swigregister, METH_VARARGS, NULL},
45808 { (char *)"new_wxUpdateUIEvent", (PyCFunction) _wrap_new_wxUpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"wxUpdateUIEvent_GetChecked", (PyCFunction) _wrap_wxUpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"wxUpdateUIEvent_GetEnabled", (PyCFunction) _wrap_wxUpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"wxUpdateUIEvent_GetText", (PyCFunction) _wrap_wxUpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"wxUpdateUIEvent_GetSetText", (PyCFunction) _wrap_wxUpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"wxUpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_wxUpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"wxUpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_wxUpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"wxUpdateUIEvent_Check", (PyCFunction) _wrap_wxUpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"wxUpdateUIEvent_Enable", (PyCFunction) _wrap_wxUpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"wxUpdateUIEvent_SetText", (PyCFunction) _wrap_wxUpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"wxUpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_wxUpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"wxUpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_wxUpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"wxUpdateUIEvent_CanUpdate", (PyCFunction) _wrap_wxUpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"wxUpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_wxUpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"wxUpdateUIEvent_SetMode", (PyCFunction) _wrap_wxUpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"wxUpdateUIEvent_GetMode", (PyCFunction) _wrap_wxUpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"wxUpdateUIEvent_swigregister", wxUpdateUIEvent_swigregister, METH_VARARGS, NULL},
45825 { (char *)"new_wxSysColourChangedEvent", (PyCFunction) _wrap_new_wxSysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"wxSysColourChangedEvent_swigregister", wxSysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45827 { (char *)"new_wxMouseCaptureChangedEvent", (PyCFunction) _wrap_new_wxMouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"wxMouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_wxMouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"wxMouseCaptureChangedEvent_swigregister", wxMouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45830 { (char *)"new_wxDisplayChangedEvent", (PyCFunction) _wrap_new_wxDisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"wxDisplayChangedEvent_swigregister", wxDisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45832 { (char *)"new_wxPaletteChangedEvent", (PyCFunction) _wrap_new_wxPaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"wxPaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_wxPaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"wxPaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_wxPaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"wxPaletteChangedEvent_swigregister", wxPaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45836 { (char *)"new_wxQueryNewPaletteEvent", (PyCFunction) _wrap_new_wxQueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"wxQueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_wxQueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"wxQueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_wxQueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"wxQueryNewPaletteEvent_swigregister", wxQueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45840 { (char *)"new_wxNavigationKeyEvent", (PyCFunction) _wrap_new_wxNavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"wxNavigationKeyEvent_GetDirection", (PyCFunction) _wrap_wxNavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"wxNavigationKeyEvent_SetDirection", (PyCFunction) _wrap_wxNavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"wxNavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_wxNavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"wxNavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_wxNavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"wxNavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_wxNavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"wxNavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_wxNavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"wxNavigationKeyEvent_SetFlags", (PyCFunction) _wrap_wxNavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"wxNavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_wxNavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"wxNavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_wxNavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"wxNavigationKeyEvent_swigregister", wxNavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45851 { (char *)"new_wxWindowCreateEvent", (PyCFunction) _wrap_new_wxWindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"wxWindowCreateEvent_GetWindow", (PyCFunction) _wrap_wxWindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"wxWindowCreateEvent_swigregister", wxWindowCreateEvent_swigregister, METH_VARARGS, NULL},
45854 { (char *)"new_wxWindowDestroyEvent", (PyCFunction) _wrap_new_wxWindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"wxWindowDestroyEvent_GetWindow", (PyCFunction) _wrap_wxWindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"wxWindowDestroyEvent_swigregister", wxWindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45857 { (char *)"new_wxContextMenuEvent", (PyCFunction) _wrap_new_wxContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"wxContextMenuEvent_GetPosition", (PyCFunction) _wrap_wxContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"wxContextMenuEvent_SetPosition", (PyCFunction) _wrap_wxContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"wxContextMenuEvent_swigregister", wxContextMenuEvent_swigregister, METH_VARARGS, NULL},
45861 { (char *)"new_wxIdleEvent", (PyCFunction) _wrap_new_wxIdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"wxIdleEvent_RequestMore", (PyCFunction) _wrap_wxIdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"wxIdleEvent_MoreRequested", (PyCFunction) _wrap_wxIdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"wxIdleEvent_SetMode", (PyCFunction) _wrap_wxIdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"wxIdleEvent_GetMode", (PyCFunction) _wrap_wxIdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"wxIdleEvent_CanSend", (PyCFunction) _wrap_wxIdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"wxIdleEvent_swigregister", wxIdleEvent_swigregister, METH_VARARGS, NULL},
45868 { (char *)"new_wxPyEvent", (PyCFunction) _wrap_new_wxPyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"delete_wxPyEvent", (PyCFunction) _wrap_delete_wxPyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"wxPyEvent_SetSelf", (PyCFunction) _wrap_wxPyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"wxPyEvent_GetSelf", (PyCFunction) _wrap_wxPyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"wxPyEvent_swigregister", wxPyEvent_swigregister, METH_VARARGS, NULL},
45873 { (char *)"new_wxPyCommandEvent", (PyCFunction) _wrap_new_wxPyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"delete_wxPyCommandEvent", (PyCFunction) _wrap_delete_wxPyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"wxPyCommandEvent_SetSelf", (PyCFunction) _wrap_wxPyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"wxPyCommandEvent_GetSelf", (PyCFunction) _wrap_wxPyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"wxPyCommandEvent_swigregister", wxPyCommandEvent_swigregister, METH_VARARGS, NULL},
45878 { (char *)"new_wxDateEvent", (PyCFunction) _wrap_new_wxDateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"wxDateEvent_GetDate", (PyCFunction) _wrap_wxDateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"wxDateEvent_SetDate", (PyCFunction) _wrap_wxDateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"wxDateEvent_swigregister", wxDateEvent_swigregister, METH_VARARGS, NULL},
45882 { (char *)"new_wxPyApp", (PyCFunction) _wrap_new_wxPyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"delete_wxPyApp", (PyCFunction) _wrap_delete_wxPyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"wxPyApp__setCallbackInfo", (PyCFunction) _wrap_wxPyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"wxPyApp_GetAppName", (PyCFunction) _wrap_wxPyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"wxPyApp_SetAppName", (PyCFunction) _wrap_wxPyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"wxPyApp_GetClassName", (PyCFunction) _wrap_wxPyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"wxPyApp_SetClassName", (PyCFunction) _wrap_wxPyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"wxPyApp_GetVendorName", (PyCFunction) _wrap_wxPyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"wxPyApp_SetVendorName", (PyCFunction) _wrap_wxPyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"wxPyApp_GetTraits", (PyCFunction) _wrap_wxPyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"wxPyApp_ProcessPendingEvents", (PyCFunction) _wrap_wxPyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"wxPyApp_Yield", (PyCFunction) _wrap_wxPyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"wxPyApp_WakeUpIdle", (PyCFunction) _wrap_wxPyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"wxPyApp_IsMainLoopRunning", (PyCFunction) _wrap_wxPyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"wxPyApp_MainLoop", (PyCFunction) _wrap_wxPyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"wxPyApp_Exit", (PyCFunction) _wrap_wxPyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"wxPyApp_ExitMainLoop", (PyCFunction) _wrap_wxPyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"wxPyApp_Pending", (PyCFunction) _wrap_wxPyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"wxPyApp_Dispatch", (PyCFunction) _wrap_wxPyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"wxPyApp_ProcessIdle", (PyCFunction) _wrap_wxPyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"wxPyApp_SendIdleEvents", (PyCFunction) _wrap_wxPyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"wxPyApp_IsActive", (PyCFunction) _wrap_wxPyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"wxPyApp_SetTopWindow", (PyCFunction) _wrap_wxPyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"wxPyApp_GetTopWindow", (PyCFunction) _wrap_wxPyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"wxPyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_wxPyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"wxPyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_wxPyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"wxPyApp_SetUseBestVisual", (PyCFunction) _wrap_wxPyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"wxPyApp_GetUseBestVisual", (PyCFunction) _wrap_wxPyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"wxPyApp_SetPrintMode", (PyCFunction) _wrap_wxPyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"wxPyApp_GetPrintMode", (PyCFunction) _wrap_wxPyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"wxPyApp_SetAssertMode", (PyCFunction) _wrap_wxPyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"wxPyApp_GetAssertMode", (PyCFunction) _wrap_wxPyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"wxPyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_wxPyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"wxPyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_wxPyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"wxPyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_wxPyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"wxPyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_wxPyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"wxPyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_wxPyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"wxPyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_wxPyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"wxPyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_wxPyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"wxPyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_wxPyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"wxPyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_wxPyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"wxPyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_wxPyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"wxPyApp__BootstrapApp", (PyCFunction) _wrap_wxPyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"wxPyApp_GetComCtl32Version", (PyCFunction) _wrap_wxPyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"wxPyApp_swigregister", wxPyApp_swigregister, METH_VARARGS, NULL},
45927 { (char *)"wxExit", (PyCFunction) _wrap_wxExit, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"wxYield", (PyCFunction) _wrap_wxYield, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"wxYieldIfNeeded", (PyCFunction) _wrap_wxYieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"wxSafeYield", (PyCFunction) _wrap_wxSafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"wxWakeUpIdle", (PyCFunction) _wrap_wxWakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"wxPostEvent", (PyCFunction) _wrap_wxPostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"wxApp_CleanUp", (PyCFunction) _wrap_wxApp_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"wxSetDefaultPyEncoding", (PyCFunction) _wrap_wxSetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"wxGetDefaultPyEncoding", (PyCFunction) _wrap_wxGetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"new_wxEventLoop", (PyCFunction) _wrap_new_wxEventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"delete_wxEventLoop", (PyCFunction) _wrap_delete_wxEventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"wxEventLoop_Run", (PyCFunction) _wrap_wxEventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"wxEventLoop_Exit", (PyCFunction) _wrap_wxEventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"wxEventLoop_Pending", (PyCFunction) _wrap_wxEventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"wxEventLoop_Dispatch", (PyCFunction) _wrap_wxEventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"wxEventLoop_IsRunning", (PyCFunction) _wrap_wxEventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"wxEventLoop_GetActive", (PyCFunction) _wrap_wxEventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"wxEventLoop_SetActive", (PyCFunction) _wrap_wxEventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"wxEventLoop_swigregister", wxEventLoop_swigregister, METH_VARARGS, NULL},
45947 { (char *)"new_wxAcceleratorEntry", (PyCFunction) _wrap_new_wxAcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"delete_wxAcceleratorEntry", (PyCFunction) _wrap_delete_wxAcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"wxAcceleratorEntry_Set", (PyCFunction) _wrap_wxAcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"wxAcceleratorEntry_GetFlags", (PyCFunction) _wrap_wxAcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"wxAcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_wxAcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"wxAcceleratorEntry_GetCommand", (PyCFunction) _wrap_wxAcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"wxAcceleratorEntry_swigregister", wxAcceleratorEntry_swigregister, METH_VARARGS, NULL},
45954 { (char *)"new_wxAcceleratorTable", (PyCFunction) _wrap_new_wxAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"delete_wxAcceleratorTable", (PyCFunction) _wrap_delete_wxAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"wxAcceleratorTable_Ok", (PyCFunction) _wrap_wxAcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"wxAcceleratorTable_swigregister", wxAcceleratorTable_swigregister, METH_VARARGS, NULL},
45958 { (char *)"wxGetAccelFromString", (PyCFunction) _wrap_wxGetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"new_wxVisualAttributes", (PyCFunction) _wrap_new_wxVisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"delete_wxVisualAttributes", (PyCFunction) _wrap_delete_wxVisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"wxVisualAttributes_font_set", (PyCFunction) _wrap_wxVisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"wxVisualAttributes_font_get", (PyCFunction) _wrap_wxVisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"wxVisualAttributes_colFg_set", (PyCFunction) _wrap_wxVisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"wxVisualAttributes_colFg_get", (PyCFunction) _wrap_wxVisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"wxVisualAttributes_colBg_set", (PyCFunction) _wrap_wxVisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"wxVisualAttributes_colBg_get", (PyCFunction) _wrap_wxVisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"wxVisualAttributes_swigregister", wxVisualAttributes_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_wxWindow", (PyCFunction) _wrap_new_wxWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"wxWindow_Create", (PyCFunction) _wrap_wxWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"wxWindow_Close", (PyCFunction) _wrap_wxWindow_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"wxWindow_Destroy", (PyCFunction) _wrap_wxWindow_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"wxWindow_DestroyChildren", (PyCFunction) _wrap_wxWindow_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"wxWindow_IsBeingDeleted", (PyCFunction) _wrap_wxWindow_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"wxWindow_SetTitle", (PyCFunction) _wrap_wxWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"wxWindow_GetTitle", (PyCFunction) _wrap_wxWindow_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"wxWindow_SetLabel", (PyCFunction) _wrap_wxWindow_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"wxWindow_GetLabel", (PyCFunction) _wrap_wxWindow_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"wxWindow_SetName", (PyCFunction) _wrap_wxWindow_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"wxWindow_GetName", (PyCFunction) _wrap_wxWindow_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"wxWindow_SetWindowVariant", (PyCFunction) _wrap_wxWindow_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"wxWindow_GetWindowVariant", (PyCFunction) _wrap_wxWindow_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"wxWindow_SetId", (PyCFunction) _wrap_wxWindow_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"wxWindow_GetId", (PyCFunction) _wrap_wxWindow_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"wxWindow_NewControlId", (PyCFunction) _wrap_wxWindow_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"wxWindow_NextControlId", (PyCFunction) _wrap_wxWindow_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"wxWindow_PrevControlId", (PyCFunction) _wrap_wxWindow_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"wxWindow_SetSize", (PyCFunction) _wrap_wxWindow_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"wxWindow_SetDimensions", (PyCFunction) _wrap_wxWindow_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"wxWindow_SetRect", (PyCFunction) _wrap_wxWindow_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"wxWindow_SetSizeWH", (PyCFunction) _wrap_wxWindow_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"wxWindow_Move", (PyCFunction) _wrap_wxWindow_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"wxWindow_MoveXY", (PyCFunction) _wrap_wxWindow_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"wxWindow_SetBestFittingSize", (PyCFunction) _wrap_wxWindow_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"wxWindow_Raise", (PyCFunction) _wrap_wxWindow_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"wxWindow_Lower", (PyCFunction) _wrap_wxWindow_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"wxWindow_SetClientSize", (PyCFunction) _wrap_wxWindow_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"wxWindow_SetClientSizeWH", (PyCFunction) _wrap_wxWindow_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"wxWindow_SetClientRect", (PyCFunction) _wrap_wxWindow_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"wxWindow_GetPosition", (PyCFunction) _wrap_wxWindow_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"wxWindow_GetPositionTuple", (PyCFunction) _wrap_wxWindow_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"wxWindow_GetSize", (PyCFunction) _wrap_wxWindow_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"wxWindow_GetSizeTuple", (PyCFunction) _wrap_wxWindow_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"wxWindow_GetRect", (PyCFunction) _wrap_wxWindow_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"wxWindow_GetClientSize", (PyCFunction) _wrap_wxWindow_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"wxWindow_GetClientSizeTuple", (PyCFunction) _wrap_wxWindow_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"wxWindow_GetClientAreaOrigin", (PyCFunction) _wrap_wxWindow_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"wxWindow_GetClientRect", (PyCFunction) _wrap_wxWindow_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"wxWindow_GetBestSize", (PyCFunction) _wrap_wxWindow_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"wxWindow_GetBestSizeTuple", (PyCFunction) _wrap_wxWindow_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"wxWindow_InvalidateBestSize", (PyCFunction) _wrap_wxWindow_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"wxWindow_GetBestFittingSize", (PyCFunction) _wrap_wxWindow_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"wxWindow_GetAdjustedBestSize", (PyCFunction) _wrap_wxWindow_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"wxWindow_Center", (PyCFunction) _wrap_wxWindow_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"wxWindow_CenterOnScreen", (PyCFunction) _wrap_wxWindow_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"wxWindow_CenterOnParent", (PyCFunction) _wrap_wxWindow_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"wxWindow_Fit", (PyCFunction) _wrap_wxWindow_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"wxWindow_FitInside", (PyCFunction) _wrap_wxWindow_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"wxWindow_SetSizeHints", (PyCFunction) _wrap_wxWindow_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"wxWindow_SetSizeHintsSz", (PyCFunction) _wrap_wxWindow_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"wxWindow_SetVirtualSizeHints", (PyCFunction) _wrap_wxWindow_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"wxWindow_SetVirtualSizeHintsSz", (PyCFunction) _wrap_wxWindow_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"wxWindow_GetMaxSize", (PyCFunction) _wrap_wxWindow_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"wxWindow_GetMinSize", (PyCFunction) _wrap_wxWindow_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"wxWindow_SetMinSize", (PyCFunction) _wrap_wxWindow_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"wxWindow_SetMaxSize", (PyCFunction) _wrap_wxWindow_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"wxWindow_GetMinWidth", (PyCFunction) _wrap_wxWindow_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"wxWindow_GetMinHeight", (PyCFunction) _wrap_wxWindow_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"wxWindow_GetMaxWidth", (PyCFunction) _wrap_wxWindow_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"wxWindow_GetMaxHeight", (PyCFunction) _wrap_wxWindow_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"wxWindow_SetVirtualSize", (PyCFunction) _wrap_wxWindow_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"wxWindow_SetVirtualSizeWH", (PyCFunction) _wrap_wxWindow_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"wxWindow_GetVirtualSize", (PyCFunction) _wrap_wxWindow_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"wxWindow_GetVirtualSizeTuple", (PyCFunction) _wrap_wxWindow_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"wxWindow_GetBestVirtualSize", (PyCFunction) _wrap_wxWindow_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"wxWindow_Show", (PyCFunction) _wrap_wxWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"wxWindow_Hide", (PyCFunction) _wrap_wxWindow_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"wxWindow_Enable", (PyCFunction) _wrap_wxWindow_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"wxWindow_Disable", (PyCFunction) _wrap_wxWindow_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"wxWindow_IsShown", (PyCFunction) _wrap_wxWindow_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"wxWindow_IsEnabled", (PyCFunction) _wrap_wxWindow_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"wxWindow_SetWindowStyleFlag", (PyCFunction) _wrap_wxWindow_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"wxWindow_GetWindowStyleFlag", (PyCFunction) _wrap_wxWindow_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"wxWindow_HasFlag", (PyCFunction) _wrap_wxWindow_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"wxWindow_IsRetained", (PyCFunction) _wrap_wxWindow_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"wxWindow_SetExtraStyle", (PyCFunction) _wrap_wxWindow_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"wxWindow_GetExtraStyle", (PyCFunction) _wrap_wxWindow_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"wxWindow_MakeModal", (PyCFunction) _wrap_wxWindow_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"wxWindow_SetThemeEnabled", (PyCFunction) _wrap_wxWindow_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"wxWindow_GetThemeEnabled", (PyCFunction) _wrap_wxWindow_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"wxWindow_SetFocus", (PyCFunction) _wrap_wxWindow_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"wxWindow_SetFocusFromKbd", (PyCFunction) _wrap_wxWindow_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"wxWindow_FindFocus", (PyCFunction) _wrap_wxWindow_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"wxWindow_AcceptsFocus", (PyCFunction) _wrap_wxWindow_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"wxWindow_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_wxWindow_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"wxWindow_GetDefaultItem", (PyCFunction) _wrap_wxWindow_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"wxWindow_SetDefaultItem", (PyCFunction) _wrap_wxWindow_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"wxWindow_SetTmpDefaultItem", (PyCFunction) _wrap_wxWindow_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"wxWindow_Navigate", (PyCFunction) _wrap_wxWindow_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"wxWindow_MoveAfterInTabOrder", (PyCFunction) _wrap_wxWindow_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"wxWindow_MoveBeforeInTabOrder", (PyCFunction) _wrap_wxWindow_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"wxWindow_GetChildren", (PyCFunction) _wrap_wxWindow_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"wxWindow_GetParent", (PyCFunction) _wrap_wxWindow_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"wxWindow_GetGrandParent", (PyCFunction) _wrap_wxWindow_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"wxWindow_IsTopLevel", (PyCFunction) _wrap_wxWindow_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"wxWindow_Reparent", (PyCFunction) _wrap_wxWindow_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"wxWindow_AddChild", (PyCFunction) _wrap_wxWindow_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"wxWindow_RemoveChild", (PyCFunction) _wrap_wxWindow_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"wxWindow_FindWindowById", (PyCFunction) _wrap_wxWindow_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"wxWindow_FindWindowByName", (PyCFunction) _wrap_wxWindow_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"wxWindow_GetEventHandler", (PyCFunction) _wrap_wxWindow_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"wxWindow_SetEventHandler", (PyCFunction) _wrap_wxWindow_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"wxWindow_PushEventHandler", (PyCFunction) _wrap_wxWindow_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"wxWindow_PopEventHandler", (PyCFunction) _wrap_wxWindow_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"wxWindow_RemoveEventHandler", (PyCFunction) _wrap_wxWindow_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"wxWindow_SetValidator", (PyCFunction) _wrap_wxWindow_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"wxWindow_GetValidator", (PyCFunction) _wrap_wxWindow_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"wxWindow_Validate", (PyCFunction) _wrap_wxWindow_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"wxWindow_TransferDataToWindow", (PyCFunction) _wrap_wxWindow_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"wxWindow_TransferDataFromWindow", (PyCFunction) _wrap_wxWindow_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"wxWindow_InitDialog", (PyCFunction) _wrap_wxWindow_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"wxWindow_SetAcceleratorTable", (PyCFunction) _wrap_wxWindow_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"wxWindow_GetAcceleratorTable", (PyCFunction) _wrap_wxWindow_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"wxWindow_RegisterHotKey", (PyCFunction) _wrap_wxWindow_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"wxWindow_UnregisterHotKey", (PyCFunction) _wrap_wxWindow_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"wxWindow_ConvertDialogPointToPixels", (PyCFunction) _wrap_wxWindow_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"wxWindow_ConvertDialogSizeToPixels", (PyCFunction) _wrap_wxWindow_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"wxWindow_DLG_PNT", (PyCFunction) _wrap_wxWindow_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"wxWindow_DLG_SZE", (PyCFunction) _wrap_wxWindow_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"wxWindow_ConvertPixelPointToDialog", (PyCFunction) _wrap_wxWindow_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"wxWindow_ConvertPixelSizeToDialog", (PyCFunction) _wrap_wxWindow_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"wxWindow_WarpPointer", (PyCFunction) _wrap_wxWindow_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"wxWindow_CaptureMouse", (PyCFunction) _wrap_wxWindow_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"wxWindow_ReleaseMouse", (PyCFunction) _wrap_wxWindow_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"wxWindow_GetCapture", (PyCFunction) _wrap_wxWindow_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"wxWindow_HasCapture", (PyCFunction) _wrap_wxWindow_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"wxWindow_Refresh", (PyCFunction) _wrap_wxWindow_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"wxWindow_RefreshRect", (PyCFunction) _wrap_wxWindow_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"wxWindow_Update", (PyCFunction) _wrap_wxWindow_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"wxWindow_ClearBackground", (PyCFunction) _wrap_wxWindow_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"wxWindow_Freeze", (PyCFunction) _wrap_wxWindow_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"wxWindow_Thaw", (PyCFunction) _wrap_wxWindow_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"wxWindow_PrepareDC", (PyCFunction) _wrap_wxWindow_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"wxWindow_GetUpdateRegion", (PyCFunction) _wrap_wxWindow_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"wxWindow_GetUpdateClientRect", (PyCFunction) _wrap_wxWindow_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"wxWindow_IsExposed", (PyCFunction) _wrap_wxWindow_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"wxWindow_IsExposedPoint", (PyCFunction) _wrap_wxWindow_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"wxWindow_IsExposedRect", (PyCFunction) _wrap_wxWindow_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"wxWindow_GetDefaultAttributes", (PyCFunction) _wrap_wxWindow_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"wxWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_wxWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"wxWindow_SetBackgroundColour", (PyCFunction) _wrap_wxWindow_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"wxWindow_SetOwnBackgroundColour", (PyCFunction) _wrap_wxWindow_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"wxWindow_SetForegroundColour", (PyCFunction) _wrap_wxWindow_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"wxWindow_SetOwnForegroundColour", (PyCFunction) _wrap_wxWindow_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"wxWindow_GetBackgroundColour", (PyCFunction) _wrap_wxWindow_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"wxWindow_GetForegroundColour", (PyCFunction) _wrap_wxWindow_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"wxWindow_InheritsBackgroundColour", (PyCFunction) _wrap_wxWindow_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"wxWindow_UseBgCol", (PyCFunction) _wrap_wxWindow_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"wxWindow_SetBackgroundStyle", (PyCFunction) _wrap_wxWindow_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"wxWindow_GetBackgroundStyle", (PyCFunction) _wrap_wxWindow_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"wxWindow_HasTransparentBackground", (PyCFunction) _wrap_wxWindow_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"wxWindow_SetCursor", (PyCFunction) _wrap_wxWindow_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"wxWindow_GetCursor", (PyCFunction) _wrap_wxWindow_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"wxWindow_SetFont", (PyCFunction) _wrap_wxWindow_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"wxWindow_SetOwnFont", (PyCFunction) _wrap_wxWindow_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"wxWindow_GetFont", (PyCFunction) _wrap_wxWindow_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"wxWindow_SetCaret", (PyCFunction) _wrap_wxWindow_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"wxWindow_GetCaret", (PyCFunction) _wrap_wxWindow_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"wxWindow_GetCharHeight", (PyCFunction) _wrap_wxWindow_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"wxWindow_GetCharWidth", (PyCFunction) _wrap_wxWindow_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"wxWindow_GetTextExtent", (PyCFunction) _wrap_wxWindow_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"wxWindow_GetFullTextExtent", (PyCFunction) _wrap_wxWindow_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"wxWindow_ClientToScreenXY", (PyCFunction) _wrap_wxWindow_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"wxWindow_ScreenToClientXY", (PyCFunction) _wrap_wxWindow_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"wxWindow_ClientToScreen", (PyCFunction) _wrap_wxWindow_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"wxWindow_ScreenToClient", (PyCFunction) _wrap_wxWindow_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"wxWindow_HitTestXY", (PyCFunction) _wrap_wxWindow_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"wxWindow_HitTest", (PyCFunction) _wrap_wxWindow_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"wxWindow_GetBorder", _wrap_wxWindow_GetBorder, METH_VARARGS, NULL},
46140 { (char *)"wxWindow_UpdateWindowUI", (PyCFunction) _wrap_wxWindow_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"wxWindow_PopupMenuXY", (PyCFunction) _wrap_wxWindow_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"wxWindow_PopupMenu", (PyCFunction) _wrap_wxWindow_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"wxWindow_GetHandle", (PyCFunction) _wrap_wxWindow_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"wxWindow_AssociateHandle", (PyCFunction) _wrap_wxWindow_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"wxWindow_DissociateHandle", (PyCFunction) _wrap_wxWindow_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"wxWindow_HasScrollbar", (PyCFunction) _wrap_wxWindow_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"wxWindow_SetScrollbar", (PyCFunction) _wrap_wxWindow_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"wxWindow_SetScrollPos", (PyCFunction) _wrap_wxWindow_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"wxWindow_GetScrollPos", (PyCFunction) _wrap_wxWindow_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"wxWindow_GetScrollThumb", (PyCFunction) _wrap_wxWindow_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"wxWindow_GetScrollRange", (PyCFunction) _wrap_wxWindow_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"wxWindow_ScrollWindow", (PyCFunction) _wrap_wxWindow_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"wxWindow_ScrollLines", (PyCFunction) _wrap_wxWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"wxWindow_ScrollPages", (PyCFunction) _wrap_wxWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"wxWindow_LineUp", (PyCFunction) _wrap_wxWindow_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"wxWindow_LineDown", (PyCFunction) _wrap_wxWindow_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"wxWindow_PageUp", (PyCFunction) _wrap_wxWindow_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"wxWindow_PageDown", (PyCFunction) _wrap_wxWindow_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"wxWindow_SetHelpText", (PyCFunction) _wrap_wxWindow_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"wxWindow_SetHelpTextForId", (PyCFunction) _wrap_wxWindow_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"wxWindow_GetHelpText", (PyCFunction) _wrap_wxWindow_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"wxWindow_SetToolTipString", (PyCFunction) _wrap_wxWindow_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"wxWindow_SetToolTip", (PyCFunction) _wrap_wxWindow_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"wxWindow_GetToolTip", (PyCFunction) _wrap_wxWindow_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"wxWindow_SetDropTarget", (PyCFunction) _wrap_wxWindow_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"wxWindow_GetDropTarget", (PyCFunction) _wrap_wxWindow_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"wxWindow_SetConstraints", (PyCFunction) _wrap_wxWindow_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"wxWindow_GetConstraints", (PyCFunction) _wrap_wxWindow_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"wxWindow_SetAutoLayout", (PyCFunction) _wrap_wxWindow_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"wxWindow_GetAutoLayout", (PyCFunction) _wrap_wxWindow_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"wxWindow_Layout", (PyCFunction) _wrap_wxWindow_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"wxWindow_SetSizer", (PyCFunction) _wrap_wxWindow_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"wxWindow_SetSizerAndFit", (PyCFunction) _wrap_wxWindow_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"wxWindow_GetSizer", (PyCFunction) _wrap_wxWindow_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"wxWindow_SetContainingSizer", (PyCFunction) _wrap_wxWindow_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"wxWindow_GetContainingSizer", (PyCFunction) _wrap_wxWindow_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"wxWindow_InheritAttributes", (PyCFunction) _wrap_wxWindow_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"wxWindow_ShouldInheritColours", (PyCFunction) _wrap_wxWindow_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"wxWindow_swigregister", wxWindow_swigregister, METH_VARARGS, NULL},
46180 { (char *)"wxFindWindowById", (PyCFunction) _wrap_wxFindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"wxFindWindowByName", (PyCFunction) _wrap_wxFindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"wxFindWindowByLabel", (PyCFunction) _wrap_wxFindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"wxWindow_FromHWND", (PyCFunction) _wrap_wxWindow_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"new_wxValidator", (PyCFunction) _wrap_new_wxValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"wxValidator_Clone", (PyCFunction) _wrap_wxValidator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"wxValidator_Validate", (PyCFunction) _wrap_wxValidator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"wxValidator_TransferToWindow", (PyCFunction) _wrap_wxValidator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"wxValidator_TransferFromWindow", (PyCFunction) _wrap_wxValidator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"wxValidator_GetWindow", (PyCFunction) _wrap_wxValidator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"wxValidator_SetWindow", (PyCFunction) _wrap_wxValidator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"wxValidator_IsSilent", (PyCFunction) _wrap_wxValidator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"wxValidator_SetBellOnError", (PyCFunction) _wrap_wxValidator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"wxValidator_swigregister", wxValidator_swigregister, METH_VARARGS, NULL},
46194 { (char *)"new_wxPyValidator", (PyCFunction) _wrap_new_wxPyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"wxPyValidator__setCallbackInfo", (PyCFunction) _wrap_wxPyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"wxPyValidator_swigregister", wxPyValidator_swigregister, METH_VARARGS, NULL},
46197 { (char *)"new_wxMenu", (PyCFunction) _wrap_new_wxMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"wxMenu_Append", (PyCFunction) _wrap_wxMenu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"wxMenu_AppendSeparator", (PyCFunction) _wrap_wxMenu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"wxMenu_AppendCheckItem", (PyCFunction) _wrap_wxMenu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"wxMenu_AppendRadioItem", (PyCFunction) _wrap_wxMenu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"wxMenu_AppendMenu", (PyCFunction) _wrap_wxMenu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"wxMenu_AppendItem", (PyCFunction) _wrap_wxMenu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"wxMenu_Break", (PyCFunction) _wrap_wxMenu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"wxMenu_InsertItem", (PyCFunction) _wrap_wxMenu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"wxMenu_Insert", (PyCFunction) _wrap_wxMenu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"wxMenu_InsertSeparator", (PyCFunction) _wrap_wxMenu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"wxMenu_InsertCheckItem", (PyCFunction) _wrap_wxMenu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"wxMenu_InsertRadioItem", (PyCFunction) _wrap_wxMenu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"wxMenu_InsertMenu", (PyCFunction) _wrap_wxMenu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"wxMenu_PrependItem", (PyCFunction) _wrap_wxMenu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"wxMenu_Prepend", (PyCFunction) _wrap_wxMenu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"wxMenu_PrependSeparator", (PyCFunction) _wrap_wxMenu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"wxMenu_PrependCheckItem", (PyCFunction) _wrap_wxMenu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"wxMenu_PrependRadioItem", (PyCFunction) _wrap_wxMenu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"wxMenu_PrependMenu", (PyCFunction) _wrap_wxMenu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"wxMenu_Remove", (PyCFunction) _wrap_wxMenu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"wxMenu_RemoveItem", (PyCFunction) _wrap_wxMenu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"wxMenu_Delete", (PyCFunction) _wrap_wxMenu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"wxMenu_DeleteItem", (PyCFunction) _wrap_wxMenu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"wxMenu_Destroy", (PyCFunction) _wrap_wxMenu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"wxMenu_DestroyId", (PyCFunction) _wrap_wxMenu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"wxMenu_DestroyItem", (PyCFunction) _wrap_wxMenu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"wxMenu_GetMenuItemCount", (PyCFunction) _wrap_wxMenu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"wxMenu_GetMenuItems", (PyCFunction) _wrap_wxMenu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"wxMenu_FindItem", (PyCFunction) _wrap_wxMenu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"wxMenu_FindItemById", (PyCFunction) _wrap_wxMenu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"wxMenu_FindItemByPosition", (PyCFunction) _wrap_wxMenu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"wxMenu_Enable", (PyCFunction) _wrap_wxMenu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"wxMenu_IsEnabled", (PyCFunction) _wrap_wxMenu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"wxMenu_Check", (PyCFunction) _wrap_wxMenu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"wxMenu_IsChecked", (PyCFunction) _wrap_wxMenu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"wxMenu_SetLabel", (PyCFunction) _wrap_wxMenu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"wxMenu_GetLabel", (PyCFunction) _wrap_wxMenu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"wxMenu_SetHelpString", (PyCFunction) _wrap_wxMenu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"wxMenu_GetHelpString", (PyCFunction) _wrap_wxMenu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"wxMenu_SetTitle", (PyCFunction) _wrap_wxMenu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"wxMenu_GetTitle", (PyCFunction) _wrap_wxMenu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"wxMenu_SetEventHandler", (PyCFunction) _wrap_wxMenu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"wxMenu_GetEventHandler", (PyCFunction) _wrap_wxMenu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"wxMenu_SetInvokingWindow", (PyCFunction) _wrap_wxMenu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"wxMenu_GetInvokingWindow", (PyCFunction) _wrap_wxMenu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"wxMenu_GetStyle", (PyCFunction) _wrap_wxMenu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"wxMenu_UpdateUI", (PyCFunction) _wrap_wxMenu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"wxMenu_GetMenuBar", (PyCFunction) _wrap_wxMenu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"wxMenu_Attach", (PyCFunction) _wrap_wxMenu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"wxMenu_Detach", (PyCFunction) _wrap_wxMenu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"wxMenu_IsAttached", (PyCFunction) _wrap_wxMenu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"wxMenu_SetParent", (PyCFunction) _wrap_wxMenu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"wxMenu_GetParent", (PyCFunction) _wrap_wxMenu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"wxMenu_swigregister", wxMenu_swigregister, METH_VARARGS, NULL},
46252 { (char *)"new_wxMenuBar", (PyCFunction) _wrap_new_wxMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"wxMenuBar_Append", (PyCFunction) _wrap_wxMenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"wxMenuBar_Insert", (PyCFunction) _wrap_wxMenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"wxMenuBar_GetMenuCount", (PyCFunction) _wrap_wxMenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"wxMenuBar_GetMenu", (PyCFunction) _wrap_wxMenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"wxMenuBar_Replace", (PyCFunction) _wrap_wxMenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"wxMenuBar_Remove", (PyCFunction) _wrap_wxMenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"wxMenuBar_EnableTop", (PyCFunction) _wrap_wxMenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"wxMenuBar_IsEnabledTop", (PyCFunction) _wrap_wxMenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"wxMenuBar_SetLabelTop", (PyCFunction) _wrap_wxMenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"wxMenuBar_GetLabelTop", (PyCFunction) _wrap_wxMenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"wxMenuBar_FindMenuItem", (PyCFunction) _wrap_wxMenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"wxMenuBar_FindItemById", (PyCFunction) _wrap_wxMenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"wxMenuBar_FindMenu", (PyCFunction) _wrap_wxMenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"wxMenuBar_Enable", (PyCFunction) _wrap_wxMenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"wxMenuBar_Check", (PyCFunction) _wrap_wxMenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"wxMenuBar_IsChecked", (PyCFunction) _wrap_wxMenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"wxMenuBar_IsEnabled", (PyCFunction) _wrap_wxMenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"wxMenuBar_SetLabel", (PyCFunction) _wrap_wxMenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"wxMenuBar_GetLabel", (PyCFunction) _wrap_wxMenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"wxMenuBar_SetHelpString", (PyCFunction) _wrap_wxMenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"wxMenuBar_GetHelpString", (PyCFunction) _wrap_wxMenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"wxMenuBar_GetFrame", (PyCFunction) _wrap_wxMenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"wxMenuBar_IsAttached", (PyCFunction) _wrap_wxMenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"wxMenuBar_Attach", (PyCFunction) _wrap_wxMenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"wxMenuBar_Detach", (PyCFunction) _wrap_wxMenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"wxMenuBar_swigregister", wxMenuBar_swigregister, METH_VARARGS, NULL},
46279 { (char *)"new_wxMenuItem", (PyCFunction) _wrap_new_wxMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"wxMenuItem_GetMenu", (PyCFunction) _wrap_wxMenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"wxMenuItem_SetMenu", (PyCFunction) _wrap_wxMenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"wxMenuItem_SetId", (PyCFunction) _wrap_wxMenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"wxMenuItem_GetId", (PyCFunction) _wrap_wxMenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"wxMenuItem_IsSeparator", (PyCFunction) _wrap_wxMenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"wxMenuItem_SetText", (PyCFunction) _wrap_wxMenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"wxMenuItem_GetLabel", (PyCFunction) _wrap_wxMenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"wxMenuItem_GetText", (PyCFunction) _wrap_wxMenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"wxMenuItem_GetLabelFromText", (PyCFunction) _wrap_wxMenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"wxMenuItem_GetKind", (PyCFunction) _wrap_wxMenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"wxMenuItem_SetKind", (PyCFunction) _wrap_wxMenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"wxMenuItem_SetCheckable", (PyCFunction) _wrap_wxMenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"wxMenuItem_IsCheckable", (PyCFunction) _wrap_wxMenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"wxMenuItem_IsSubMenu", (PyCFunction) _wrap_wxMenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"wxMenuItem_SetSubMenu", (PyCFunction) _wrap_wxMenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"wxMenuItem_GetSubMenu", (PyCFunction) _wrap_wxMenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"wxMenuItem_Enable", (PyCFunction) _wrap_wxMenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"wxMenuItem_IsEnabled", (PyCFunction) _wrap_wxMenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"wxMenuItem_Check", (PyCFunction) _wrap_wxMenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"wxMenuItem_IsChecked", (PyCFunction) _wrap_wxMenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"wxMenuItem_Toggle", (PyCFunction) _wrap_wxMenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"wxMenuItem_SetHelp", (PyCFunction) _wrap_wxMenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"wxMenuItem_GetHelp", (PyCFunction) _wrap_wxMenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"wxMenuItem_GetAccel", (PyCFunction) _wrap_wxMenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"wxMenuItem_SetAccel", (PyCFunction) _wrap_wxMenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"wxMenuItem_SetFont", (PyCFunction) _wrap_wxMenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"wxMenuItem_GetFont", (PyCFunction) _wrap_wxMenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"wxMenuItem_SetTextColour", (PyCFunction) _wrap_wxMenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"wxMenuItem_GetTextColour", (PyCFunction) _wrap_wxMenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"wxMenuItem_SetBackgroundColour", (PyCFunction) _wrap_wxMenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"wxMenuItem_GetBackgroundColour", (PyCFunction) _wrap_wxMenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"wxMenuItem_SetBitmaps", (PyCFunction) _wrap_wxMenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"wxMenuItem_SetDisabledBitmap", (PyCFunction) _wrap_wxMenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"wxMenuItem_GetDisabledBitmap", (PyCFunction) _wrap_wxMenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"wxMenuItem_SetMarginWidth", (PyCFunction) _wrap_wxMenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"wxMenuItem_GetMarginWidth", (PyCFunction) _wrap_wxMenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"wxMenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_wxMenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"wxMenuItem_IsOwnerDrawn", (PyCFunction) _wrap_wxMenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"wxMenuItem_SetOwnerDrawn", (PyCFunction) _wrap_wxMenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"wxMenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_wxMenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"wxMenuItem_SetBitmap", (PyCFunction) _wrap_wxMenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"wxMenuItem_GetBitmap", (PyCFunction) _wrap_wxMenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"wxMenuItem_swigregister", wxMenuItem_swigregister, METH_VARARGS, NULL},
46323 { (char *)"new_wxControl", (PyCFunction) _wrap_new_wxControl, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"wxControl_Create", (PyCFunction) _wrap_wxControl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"wxControl_Command", (PyCFunction) _wrap_wxControl_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"wxControl_GetLabel", (PyCFunction) _wrap_wxControl_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"wxControl_SetLabel", (PyCFunction) _wrap_wxControl_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"wxControl_GetClassDefaultAttributes", (PyCFunction) _wrap_wxControl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"wxControl_swigregister", wxControl_swigregister, METH_VARARGS, NULL},
46331 { (char *)"wxItemContainer_Append", (PyCFunction) _wrap_wxItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"wxItemContainer_AppendItems", (PyCFunction) _wrap_wxItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"wxItemContainer_Insert", (PyCFunction) _wrap_wxItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"wxItemContainer_Clear", (PyCFunction) _wrap_wxItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"wxItemContainer_Delete", (PyCFunction) _wrap_wxItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"wxItemContainer_GetClientData", (PyCFunction) _wrap_wxItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"wxItemContainer_SetClientData", (PyCFunction) _wrap_wxItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"wxItemContainer_GetCount", (PyCFunction) _wrap_wxItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"wxItemContainer_IsEmpty", (PyCFunction) _wrap_wxItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"wxItemContainer_GetString", (PyCFunction) _wrap_wxItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"wxItemContainer_GetStrings", (PyCFunction) _wrap_wxItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"wxItemContainer_SetString", (PyCFunction) _wrap_wxItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"wxItemContainer_FindString", (PyCFunction) _wrap_wxItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"wxItemContainer_SetSelection", (PyCFunction) _wrap_wxItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"wxItemContainer_GetSelection", (PyCFunction) _wrap_wxItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"wxItemContainer_SetStringSelection", (PyCFunction) _wrap_wxItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"wxItemContainer_GetStringSelection", (PyCFunction) _wrap_wxItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"wxItemContainer_Select", (PyCFunction) _wrap_wxItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"wxItemContainer_swigregister", wxItemContainer_swigregister, METH_VARARGS, NULL},
46350 { (char *)"wxControlWithItems_swigregister", wxControlWithItems_swigregister, METH_VARARGS, NULL},
46351 { (char *)"new_wxSizerItem", (PyCFunction) _wrap_new_wxSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"wxSizerItem_DeleteWindows", (PyCFunction) _wrap_wxSizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"wxSizerItem_DetachSizer", (PyCFunction) _wrap_wxSizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"wxSizerItem_GetSize", (PyCFunction) _wrap_wxSizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"wxSizerItem_CalcMin", (PyCFunction) _wrap_wxSizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"wxSizerItem_SetDimension", (PyCFunction) _wrap_wxSizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"wxSizerItem_GetMinSize", (PyCFunction) _wrap_wxSizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"wxSizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_wxSizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"wxSizerItem_SetInitSize", (PyCFunction) _wrap_wxSizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"wxSizerItem_SetRatioWH", (PyCFunction) _wrap_wxSizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"wxSizerItem_SetRatioSize", (PyCFunction) _wrap_wxSizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"wxSizerItem_SetRatio", (PyCFunction) _wrap_wxSizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"wxSizerItem_GetRatio", (PyCFunction) _wrap_wxSizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"wxSizerItem_GetRect", (PyCFunction) _wrap_wxSizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"wxSizerItem_IsWindow", (PyCFunction) _wrap_wxSizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"wxSizerItem_IsSizer", (PyCFunction) _wrap_wxSizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"wxSizerItem_IsSpacer", (PyCFunction) _wrap_wxSizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"wxSizerItem_SetProportion", (PyCFunction) _wrap_wxSizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"wxSizerItem_GetProportion", (PyCFunction) _wrap_wxSizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"wxSizerItem_SetFlag", (PyCFunction) _wrap_wxSizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"wxSizerItem_GetFlag", (PyCFunction) _wrap_wxSizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"wxSizerItem_SetBorder", (PyCFunction) _wrap_wxSizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"wxSizerItem_GetBorder", (PyCFunction) _wrap_wxSizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"wxSizerItem_GetWindow", (PyCFunction) _wrap_wxSizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"wxSizerItem_SetWindow", (PyCFunction) _wrap_wxSizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"wxSizerItem_GetSizer", (PyCFunction) _wrap_wxSizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"wxSizerItem_SetSizer", (PyCFunction) _wrap_wxSizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"wxSizerItem_GetSpacer", (PyCFunction) _wrap_wxSizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"wxSizerItem_SetSpacer", (PyCFunction) _wrap_wxSizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"wxSizerItem_Show", (PyCFunction) _wrap_wxSizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"wxSizerItem_IsShown", (PyCFunction) _wrap_wxSizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"wxSizerItem_GetPosition", (PyCFunction) _wrap_wxSizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"wxSizerItem_GetUserData", (PyCFunction) _wrap_wxSizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"wxSizerItem_swigregister", wxSizerItem_swigregister, METH_VARARGS, NULL},
46388 { (char *)"wxSizer__setOORInfo", (PyCFunction) _wrap_wxSizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"wxSizer_Add", (PyCFunction) _wrap_wxSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"wxSizer_Insert", (PyCFunction) _wrap_wxSizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"wxSizer_Prepend", (PyCFunction) _wrap_wxSizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"wxSizer_Remove", (PyCFunction) _wrap_wxSizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"wxSizer_Detach", (PyCFunction) _wrap_wxSizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"wxSizer_GetItem", (PyCFunction) _wrap_wxSizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"wxSizer__SetItemMinSize", (PyCFunction) _wrap_wxSizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"wxSizer_AddItem", (PyCFunction) _wrap_wxSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"wxSizer_InsertItem", (PyCFunction) _wrap_wxSizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"wxSizer_PrependItem", (PyCFunction) _wrap_wxSizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"wxSizer_SetDimension", (PyCFunction) _wrap_wxSizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"wxSizer_SetMinSize", (PyCFunction) _wrap_wxSizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"wxSizer_GetSize", (PyCFunction) _wrap_wxSizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"wxSizer_GetPosition", (PyCFunction) _wrap_wxSizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"wxSizer_GetMinSize", (PyCFunction) _wrap_wxSizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"wxSizer_RecalcSizes", (PyCFunction) _wrap_wxSizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"wxSizer_CalcMin", (PyCFunction) _wrap_wxSizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"wxSizer_Layout", (PyCFunction) _wrap_wxSizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"wxSizer_Fit", (PyCFunction) _wrap_wxSizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"wxSizer_FitInside", (PyCFunction) _wrap_wxSizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"wxSizer_SetSizeHints", (PyCFunction) _wrap_wxSizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"wxSizer_SetVirtualSizeHints", (PyCFunction) _wrap_wxSizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"wxSizer_Clear", (PyCFunction) _wrap_wxSizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"wxSizer_DeleteWindows", (PyCFunction) _wrap_wxSizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"wxSizer_GetChildren", (PyCFunction) _wrap_wxSizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"wxSizer_Show", (PyCFunction) _wrap_wxSizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"wxSizer_IsShown", (PyCFunction) _wrap_wxSizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"wxSizer_ShowItems", (PyCFunction) _wrap_wxSizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"wxSizer_swigregister", wxSizer_swigregister, METH_VARARGS, NULL},
46418 { (char *)"new_wxPySizer", (PyCFunction) _wrap_new_wxPySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"wxPySizer__setCallbackInfo", (PyCFunction) _wrap_wxPySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"wxPySizer_swigregister", wxPySizer_swigregister, METH_VARARGS, NULL},
46421 { (char *)"new_wxBoxSizer", (PyCFunction) _wrap_new_wxBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"wxBoxSizer_GetOrientation", (PyCFunction) _wrap_wxBoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"wxBoxSizer_SetOrientation", (PyCFunction) _wrap_wxBoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"wxBoxSizer_swigregister", wxBoxSizer_swigregister, METH_VARARGS, NULL},
46425 { (char *)"new_wxStaticBoxSizer", (PyCFunction) _wrap_new_wxStaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"wxStaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_wxStaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"wxStaticBoxSizer_swigregister", wxStaticBoxSizer_swigregister, METH_VARARGS, NULL},
46428 { (char *)"new_wxGridSizer", (PyCFunction) _wrap_new_wxGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"wxGridSizer_SetCols", (PyCFunction) _wrap_wxGridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"wxGridSizer_SetRows", (PyCFunction) _wrap_wxGridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"wxGridSizer_SetVGap", (PyCFunction) _wrap_wxGridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"wxGridSizer_SetHGap", (PyCFunction) _wrap_wxGridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"wxGridSizer_GetCols", (PyCFunction) _wrap_wxGridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"wxGridSizer_GetRows", (PyCFunction) _wrap_wxGridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"wxGridSizer_GetVGap", (PyCFunction) _wrap_wxGridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"wxGridSizer_GetHGap", (PyCFunction) _wrap_wxGridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"wxGridSizer_swigregister", wxGridSizer_swigregister, METH_VARARGS, NULL},
46438 { (char *)"new_wxFlexGridSizer", (PyCFunction) _wrap_new_wxFlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"wxFlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_wxFlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"wxFlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_wxFlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"wxFlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_wxFlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"wxFlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_wxFlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"wxFlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_wxFlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"wxFlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_wxFlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"wxFlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_wxFlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"wxFlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_wxFlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"wxFlexGridSizer_GetRowHeights", (PyCFunction) _wrap_wxFlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"wxFlexGridSizer_GetColWidths", (PyCFunction) _wrap_wxFlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"wxFlexGridSizer_swigregister", wxFlexGridSizer_swigregister, METH_VARARGS, NULL},
46450 { (char *)"new_wxStdDialogButtonSizer", (PyCFunction) _wrap_new_wxStdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"wxStdDialogButtonSizer_AddButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"wxStdDialogButtonSizer_Realize", (PyCFunction) _wrap_wxStdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"wxStdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"wxStdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"wxStdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"wxStdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"wxStdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"wxStdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"wxStdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"wxStdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_wxStdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"wxStdDialogButtonSizer_swigregister", wxStdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46462 { (char *)"new_wxGBPosition", (PyCFunction) _wrap_new_wxGBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"wxGBPosition_GetRow", (PyCFunction) _wrap_wxGBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"wxGBPosition_GetCol", (PyCFunction) _wrap_wxGBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"wxGBPosition_SetRow", (PyCFunction) _wrap_wxGBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"wxGBPosition_SetCol", (PyCFunction) _wrap_wxGBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"wxGBPosition___eq__", (PyCFunction) _wrap_wxGBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"wxGBPosition___ne__", (PyCFunction) _wrap_wxGBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"wxGBPosition_Set", (PyCFunction) _wrap_wxGBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"wxGBPosition_Get", (PyCFunction) _wrap_wxGBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"wxGBPosition_swigregister", wxGBPosition_swigregister, METH_VARARGS, NULL},
46472 { (char *)"new_wxGBSpan", (PyCFunction) _wrap_new_wxGBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"wxGBSpan_GetRowspan", (PyCFunction) _wrap_wxGBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"wxGBSpan_GetColspan", (PyCFunction) _wrap_wxGBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"wxGBSpan_SetRowspan", (PyCFunction) _wrap_wxGBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"wxGBSpan_SetColspan", (PyCFunction) _wrap_wxGBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"wxGBSpan___eq__", (PyCFunction) _wrap_wxGBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"wxGBSpan___ne__", (PyCFunction) _wrap_wxGBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"wxGBSpan_Set", (PyCFunction) _wrap_wxGBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"wxGBSpan_Get", (PyCFunction) _wrap_wxGBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"wxGBSpan_swigregister", wxGBSpan_swigregister, METH_VARARGS, NULL},
46482 { (char *)"new_wxGBSizerItem", (PyCFunction) _wrap_new_wxGBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"wxGBSizerItem_GetPos", (PyCFunction) _wrap_wxGBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"wxGBSizerItem_GetSpan", (PyCFunction) _wrap_wxGBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"wxGBSizerItem_SetPos", (PyCFunction) _wrap_wxGBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"wxGBSizerItem_SetSpan", (PyCFunction) _wrap_wxGBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"wxGBSizerItem_Intersects", (PyCFunction) _wrap_wxGBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"wxGBSizerItem_IntersectsPos", (PyCFunction) _wrap_wxGBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"wxGBSizerItem_GetEndPos", (PyCFunction) _wrap_wxGBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"wxGBSizerItem_GetGBSizer", (PyCFunction) _wrap_wxGBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"wxGBSizerItem_SetGBSizer", (PyCFunction) _wrap_wxGBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"wxGBSizerItem_swigregister", wxGBSizerItem_swigregister, METH_VARARGS, NULL},
46496 { (char *)"new_wxGridBagSizer", (PyCFunction) _wrap_new_wxGridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"wxGridBagSizer_Add", (PyCFunction) _wrap_wxGridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"wxGridBagSizer_AddItem", (PyCFunction) _wrap_wxGridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"wxGridBagSizer_GetCellSize", (PyCFunction) _wrap_wxGridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"wxGridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_wxGridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"wxGridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_wxGridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"wxGridBagSizer_GetItemPosition", _wrap_wxGridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46503 { (char *)"wxGridBagSizer_SetItemPosition", _wrap_wxGridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46504 { (char *)"wxGridBagSizer_GetItemSpan", _wrap_wxGridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46505 { (char *)"wxGridBagSizer_SetItemSpan", _wrap_wxGridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46506 { (char *)"wxGridBagSizer_FindItem", _wrap_wxGridBagSizer_FindItem, METH_VARARGS, NULL},
46507 { (char *)"wxGridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_wxGridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"wxGridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_wxGridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"wxGridBagSizer_CheckForIntersection", (PyCFunction) _wrap_wxGridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"wxGridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_wxGridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"wxGridBagSizer_swigregister", wxGridBagSizer_swigregister, METH_VARARGS, NULL},
46512 { (char *)"wxIndividualLayoutConstraint_Set", (PyCFunction) _wrap_wxIndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"wxIndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_wxIndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"wxIndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_wxIndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"wxIndividualLayoutConstraint_Above", (PyCFunction) _wrap_wxIndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"wxIndividualLayoutConstraint_Below", (PyCFunction) _wrap_wxIndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"wxIndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"wxIndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_wxIndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"wxIndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_wxIndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"wxIndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_wxIndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"wxIndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_wxIndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"wxIndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"wxIndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"wxIndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"wxIndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"wxIndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"wxIndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"wxIndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"wxIndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"wxIndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"wxIndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"wxIndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"wxIndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"wxIndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"wxIndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_wxIndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"wxIndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_wxIndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"wxIndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_wxIndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"wxIndividualLayoutConstraint_swigregister", wxIndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46539 { (char *)"wxLayoutConstraints_left_get", (PyCFunction) _wrap_wxLayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"wxLayoutConstraints_top_get", (PyCFunction) _wrap_wxLayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"wxLayoutConstraints_right_get", (PyCFunction) _wrap_wxLayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"wxLayoutConstraints_bottom_get", (PyCFunction) _wrap_wxLayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"wxLayoutConstraints_width_get", (PyCFunction) _wrap_wxLayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"wxLayoutConstraints_height_get", (PyCFunction) _wrap_wxLayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"wxLayoutConstraints_centreX_get", (PyCFunction) _wrap_wxLayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"wxLayoutConstraints_centreY_get", (PyCFunction) _wrap_wxLayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"new_wxLayoutConstraints", (PyCFunction) _wrap_new_wxLayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"wxLayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_wxLayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"wxLayoutConstraints_AreSatisfied", (PyCFunction) _wrap_wxLayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"wxLayoutConstraints_swigregister", wxLayoutConstraints_swigregister, METH_VARARGS, NULL},
46551 { NULL, NULL, 0, NULL }
46552 };
46553
46554
46555 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46556
46557 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46558 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46559 }
46560 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46561 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46562 }
46563 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46564 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46565 }
46566 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46567 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46568 }
46569 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46570 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46571 }
46572 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46573 return (void *)((wxSizer *) ((wxGridSizer *) x));
46574 }
46575 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46576 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46577 }
46578 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46579 return (void *)((wxSizer *) ((wxPySizer *) x));
46580 }
46581 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46582 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46583 }
46584 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46585 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46586 }
46587 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46588 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46589 }
46590 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46591 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46592 }
46593 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46594 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46595 }
46596 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46597 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46598 }
46599 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46600 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46601 }
46602 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46603 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46604 }
46605 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46606 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46607 }
46608 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46609 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46610 }
46611 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46612 return (void *)((wxEvent *) ((wxPyEvent *) x));
46613 }
46614 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46615 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46616 }
46617 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46618 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46619 }
46620 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46621 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46622 }
46623 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46624 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46625 }
46626 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46627 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46628 }
46629 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46630 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46631 }
46632 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46633 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46634 }
46635 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46636 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46637 }
46638 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46639 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46640 }
46641 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46642 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46643 }
46644 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46645 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46646 }
46647 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46648 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46649 }
46650 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46651 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46652 }
46653 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46654 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46655 }
46656 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46657 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46658 }
46659 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46660 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46661 }
46662 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46663 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46664 }
46665 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46666 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46667 }
46668 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46669 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46670 }
46671 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46672 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46673 }
46674 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46675 return (void *)((wxEvent *) ((wxShowEvent *) x));
46676 }
46677 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46678 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46679 }
46680 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46681 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46682 }
46683 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46684 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46685 }
46686 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46687 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46688 }
46689 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46690 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46691 }
46692 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46693 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46694 }
46695 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46696 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46697 }
46698 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46699 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46700 }
46701 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46702 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46703 }
46704 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46705 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46706 }
46707 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46708 return (void *)((wxControl *) ((wxControlWithItems *) x));
46709 }
46710 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46711 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46712 }
46713 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46714 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46715 }
46716 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46717 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46718 }
46719 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46720 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46721 }
46722 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46723 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46724 }
46725 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46726 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46727 }
46728 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46729 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46730 }
46731 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46732 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46733 }
46734 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46735 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46736 }
46737 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46738 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46739 }
46740 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46741 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46742 }
46743 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46744 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46745 }
46746 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46747 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46748 }
46749 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46750 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46751 }
46752 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46753 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46754 }
46755 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46756 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46757 }
46758 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46759 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46760 }
46761 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46762 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46763 }
46764 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46765 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46766 }
46767 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46768 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46769 }
46770 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46771 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46772 }
46773 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46774 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46775 }
46776 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46777 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46778 }
46779 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46780 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46781 }
46782 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46783 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46784 }
46785 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46786 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46787 }
46788 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46789 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46790 }
46791 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46792 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46793 }
46794 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46795 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46796 }
46797 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46798 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46799 }
46800 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46801 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46802 }
46803 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46804 return (void *)((wxObject *) ((wxSizerItem *) x));
46805 }
46806 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46807 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46808 }
46809 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46810 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46811 }
46812 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46813 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46814 }
46815 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46816 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46817 }
46818 static void *_p_wxSizerTo_p_wxObject(void *x) {
46819 return (void *)((wxObject *) ((wxSizer *) x));
46820 }
46821 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46822 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46823 }
46824 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46825 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46826 }
46827 static void *_p_wxEventTo_p_wxObject(void *x) {
46828 return (void *)((wxObject *) ((wxEvent *) x));
46829 }
46830 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46831 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46832 }
46833 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46834 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46835 }
46836 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46837 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46838 }
46839 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46840 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46841 }
46842 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46843 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46844 }
46845 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46846 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46847 }
46848 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46849 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46850 }
46851 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46852 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46853 }
46854 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46855 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46856 }
46857 static void *_p_wxControlTo_p_wxObject(void *x) {
46858 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46859 }
46860 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46861 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46862 }
46863 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46864 return (void *)((wxObject *) ((wxFSFile *) x));
46865 }
46866 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46867 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46868 }
46869 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46870 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46871 }
46872 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46873 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46874 }
46875 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46876 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46877 }
46878 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46879 return (void *)((wxObject *) ((wxMenuItem *) x));
46880 }
46881 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46882 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46883 }
46884 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46885 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46886 }
46887 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46888 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46889 }
46890 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46891 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46892 }
46893 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46894 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46895 }
46896 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46897 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46898 }
46899 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46900 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46901 }
46902 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46903 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46904 }
46905 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46906 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46907 }
46908 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46909 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46910 }
46911 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46912 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46913 }
46914 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46915 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46916 }
46917 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46918 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46919 }
46920 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46921 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46922 }
46923 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46924 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46925 }
46926 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46927 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46928 }
46929 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46930 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46931 }
46932 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46933 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46934 }
46935 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46936 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46937 }
46938 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46939 return (void *)((wxObject *) ((wxImageHandler *) x));
46940 }
46941 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46942 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46943 }
46944 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46945 return (void *)((wxObject *) ((wxEvtHandler *) x));
46946 }
46947 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46948 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46949 }
46950 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46951 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46952 }
46953 static void *_p_wxImageTo_p_wxObject(void *x) {
46954 return (void *)((wxObject *) ((wxImage *) x));
46955 }
46956 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46957 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46958 }
46959 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46960 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46961 }
46962 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46963 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46964 }
46965 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46966 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46967 }
46968 static void *_p_wxWindowTo_p_wxObject(void *x) {
46969 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46970 }
46971 static void *_p_wxMenuTo_p_wxObject(void *x) {
46972 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46973 }
46974 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46975 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46976 }
46977 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46978 return (void *)((wxObject *) ((wxFileSystem *) x));
46979 }
46980 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46982 }
46983 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46984 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46985 }
46986 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46987 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46988 }
46989 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46990 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46991 }
46992 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46993 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46994 }
46995 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46996 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46997 }
46998 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46999 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47000 }
47001 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47002 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47003 }
47004 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47005 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47006 }
47007 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47008 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47009 }
47010 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47011 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47012 }
47013 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47014 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47015 }
47016 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47017 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47018 }
47019 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47020 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47021 }
47022 static void *_p_wxControlTo_p_wxWindow(void *x) {
47023 return (void *)((wxWindow *) ((wxControl *) x));
47024 }
47025 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47026 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47027 }
47028 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47029 return (void *)((wxWindow *) ((wxMenuBar *) x));
47030 }
47031 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47032 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47033 }
47034 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47035 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47036 }
47037 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47038 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47039 }
47040 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47041 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47042 }
47043 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47044 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47045 }
47046 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47047 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47048 }
47049 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47050 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47051 }
47052 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47053 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47054 }
47055 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47056 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47057 }
47058 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47059 return (void *)((wxValidator *) ((wxPyValidator *) x));
47060 }
47061 static swig_type_info _swigt__p_wxLayoutConstraints[] = {{"_p_wxLayoutConstraints", 0, "wxLayoutConstraints *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47062 static swig_type_info _swigt__p_wxRealPoint[] = {{"_p_wxRealPoint", 0, "wxRealPoint *", 0, 0, 0, 0},{"_p_wxRealPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47063 static swig_type_info _swigt__p_wxSizerItem[] = {{"_p_wxSizerItem", 0, "wxSizerItem *", 0, 0, 0, 0},{"_p_wxSizerItem", 0, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxSizerItem, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47064 static swig_type_info _swigt__p_wxGBSizerItem[] = {{"_p_wxGBSizerItem", 0, "wxGBSizerItem *", 0, 0, 0, 0},{"_p_wxGBSizerItem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47065 static swig_type_info _swigt__p_wxScrollEvent[] = {{"_p_wxScrollEvent", 0, "wxScrollEvent *", 0, 0, 0, 0},{"_p_wxScrollEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47066 static swig_type_info _swigt__p_wxEventLoop[] = {{"_p_wxEventLoop", 0, "wxEventLoop *", 0, 0, 0, 0},{"_p_wxEventLoop", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47067 static swig_type_info _swigt__p_wxIndividualLayoutConstraint[] = {{"_p_wxIndividualLayoutConstraint", 0, "wxIndividualLayoutConstraint *", 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47068 static swig_type_info _swigt__p_wxSizer[] = {{"_p_wxSizer", 0, "wxSizer *", 0, 0, 0, 0},{"_p_wxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47069 static swig_type_info _swigt__p_wxBoxSizer[] = {{"_p_wxBoxSizer", 0, "wxBoxSizer *", 0, 0, 0, 0},{"_p_wxBoxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxBoxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxBoxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47070 static swig_type_info _swigt__p_wxStaticBoxSizer[] = {{"_p_wxStaticBoxSizer", 0, "wxStaticBoxSizer *", 0, 0, 0, 0},{"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47071 static swig_type_info _swigt__p_wxGridBagSizer[] = {{"_p_wxGridBagSizer", 0, "wxGridBagSizer *", 0, 0, 0, 0},{"_p_wxGridBagSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47072 static swig_type_info _swigt__p_wxAcceleratorEntry[] = {{"_p_wxAcceleratorEntry", 0, "wxAcceleratorEntry *", 0, 0, 0, 0},{"_p_wxAcceleratorEntry", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47073 static swig_type_info _swigt__p_wxUpdateUIEvent[] = {{"_p_wxUpdateUIEvent", 0, "wxUpdateUIEvent *", 0, 0, 0, 0},{"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47074 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47075 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47076 static swig_type_info _swigt__p_wxMenu[] = {{"_p_wxMenu", 0, "wxMenu *", 0, 0, 0, 0},{"_p_wxMenu", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47077 static swig_type_info _swigt__p_wxGridSizer[] = {{"_p_wxGridSizer", 0, "wxGridSizer *", 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxGridSizer, 0, 0, 0, 0, 0},{"_p_wxGridSizer", 0, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxGridSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47078 static swig_type_info _swigt__p_wxFlexGridSizer[] = {{"_p_wxFlexGridSizer", 0, "wxFlexGridSizer *", 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxFlexGridSizer, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47079 static swig_type_info _swigt__p_wxInitDialogEvent[] = {{"_p_wxInitDialogEvent", 0, "wxInitDialogEvent *", 0, 0, 0, 0},{"_p_wxInitDialogEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47080 static swig_type_info _swigt__p_wxItemContainer[] = {{"_p_wxItemContainer", 0, "wxItemContainer *", 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxItemContainer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47081 static swig_type_info _swigt__p_wxNcPaintEvent[] = {{"_p_wxNcPaintEvent", 0, "wxNcPaintEvent *", 0, 0, 0, 0},{"_p_wxNcPaintEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47082 static swig_type_info _swigt__p_wxPaintEvent[] = {{"_p_wxPaintEvent", 0, "wxPaintEvent *", 0, 0, 0, 0},{"_p_wxPaintEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47083 static swig_type_info _swigt__p_wxSysColourChangedEvent[] = {{"_p_wxSysColourChangedEvent", 0, "wxSysColourChangedEvent *", 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47084 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent[] = {{"_p_wxMouseCaptureChangedEvent", 0, "wxMouseCaptureChangedEvent *", 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47085 static swig_type_info _swigt__p_wxDisplayChangedEvent[] = {{"_p_wxDisplayChangedEvent", 0, "wxDisplayChangedEvent *", 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47086 static swig_type_info _swigt__p_wxPaletteChangedEvent[] = {{"_p_wxPaletteChangedEvent", 0, "wxPaletteChangedEvent *", 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47087 static swig_type_info _swigt__p_wxControl[] = {{"_p_wxControl", 0, "wxControl *", 0, 0, 0, 0},{"_p_wxControl", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxControl, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47088 static swig_type_info _swigt__p_wxFont[] = {{"_p_wxFont", 0, "wxFont *", 0, 0, 0, 0},{"_p_wxFont", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47089 static swig_type_info _swigt__p_wxMenuBarBase[] = {{"_p_wxMenuBarBase", 0, "wxMenuBarBase *", 0, 0, 0, 0},{"_p_wxMenuBarBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47090 static swig_type_info _swigt__p_wxSetCursorEvent[] = {{"_p_wxSetCursorEvent", 0, "wxSetCursorEvent *", 0, 0, 0, 0},{"_p_wxSetCursorEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47091 static swig_type_info _swigt__p_wxFSFile[] = {{"_p_wxFSFile", 0, "wxFSFile *", 0, 0, 0, 0},{"_p_wxFSFile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47092 static swig_type_info _swigt__p_wxCaret[] = {{"_p_wxCaret", 0, "wxCaret *", 0, 0, 0, 0},{"_p_wxCaret", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47093 static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47094 static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47095 static swig_type_info _swigt__p_wxRegion[] = {{"_p_wxRegion", 0, "wxRegion *", 0, 0, 0, 0},{"_p_wxRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47096 static swig_type_info _swigt__p_wxPoint2D[] = {{"_p_wxPoint2D", 0, "wxPoint2D *", 0, 0, 0, 0},{"_p_wxPoint2D", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47097 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47098 static swig_type_info _swigt__p_wxSize[] = {{"_p_wxSize", 0, "wxSize *", 0, 0, 0, 0},{"_p_wxSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47099 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47100 static swig_type_info _swigt__p_wxPySizer[] = {{"_p_wxPySizer", 0, "wxPySizer *", 0, 0, 0, 0},{"_p_wxPySizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47101 static swig_type_info _swigt__p_wxVisualAttributes[] = {{"_p_wxVisualAttributes", 0, "wxVisualAttributes *", 0, 0, 0, 0},{"_p_wxVisualAttributes", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47102 static swig_type_info _swigt__p_wxNotifyEvent[] = {{"_p_wxNotifyEvent", 0, "wxNotifyEvent *", 0, 0, 0, 0},{"_p_wxNotifyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47103 static swig_type_info _swigt__p_wxPyEvent[] = {{"_p_wxPyEvent", 0, "wxPyEvent *", 0, 0, 0, 0},{"_p_wxPyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47104 static swig_type_info _swigt__p_wxPropagationDisabler[] = {{"_p_wxPropagationDisabler", 0, "wxPropagationDisabler *", 0, 0, 0, 0},{"_p_wxPropagationDisabler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47105 static swig_type_info _swigt__p_form_ops_t[] = {{"_p_form_ops_t", 0, "enum form_ops_t *|form_ops_t *", 0, 0, 0, 0},{"_p_form_ops_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47106 static swig_type_info _swigt__p_wxAppTraits[] = {{"_p_wxAppTraits", 0, "wxAppTraits *", 0, 0, 0, 0},{"_p_wxAppTraits", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47107 static swig_type_info _swigt__p_wxArrayString[] = {{"_p_wxArrayString", 0, "wxArrayString *", 0, 0, 0, 0},{"_p_wxArrayString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47108 static swig_type_info _swigt__p_wxShowEvent[] = {{"_p_wxShowEvent", 0, "wxShowEvent *", 0, 0, 0, 0},{"_p_wxShowEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47109 static swig_type_info _swigt__p_wxToolTip[] = {{"_p_wxToolTip", 0, "wxToolTip *", 0, 0, 0, 0},{"_p_wxToolTip", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47110 static swig_type_info _swigt__p_wxMoveEvent[] = {{"_p_wxMoveEvent", 0, "wxMoveEvent *", 0, 0, 0, 0},{"_p_wxMoveEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47111 static swig_type_info _swigt__p_wxSizeEvent[] = {{"_p_wxSizeEvent", 0, "wxSizeEvent *", 0, 0, 0, 0},{"_p_wxSizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47112 static swig_type_info _swigt__p_wxActivateEvent[] = {{"_p_wxActivateEvent", 0, "wxActivateEvent *", 0, 0, 0, 0},{"_p_wxActivateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47113 static swig_type_info _swigt__p_wxIconizeEvent[] = {{"_p_wxIconizeEvent", 0, "wxIconizeEvent *", 0, 0, 0, 0},{"_p_wxIconizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47114 static swig_type_info _swigt__p_wxMaximizeEvent[] = {{"_p_wxMaximizeEvent", 0, "wxMaximizeEvent *", 0, 0, 0, 0},{"_p_wxMaximizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47115 static swig_type_info _swigt__p_wxQueryNewPaletteEvent[] = {{"_p_wxQueryNewPaletteEvent", 0, "wxQueryNewPaletteEvent *", 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47116 static swig_type_info _swigt__p_wxWindowCreateEvent[] = {{"_p_wxWindowCreateEvent", 0, "wxWindowCreateEvent *", 0, 0, 0, 0},{"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47117 static swig_type_info _swigt__p_wxIdleEvent[] = {{"_p_wxIdleEvent", 0, "wxIdleEvent *", 0, 0, 0, 0},{"_p_wxIdleEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47118 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47119 static swig_type_info _swigt__p_wxMenuItem[] = {{"_p_wxMenuItem", 0, "wxMenuItem *", 0, 0, 0, 0},{"_p_wxMenuItem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47120 static swig_type_info _swigt__p_wxStaticBox[] = {{"_p_wxStaticBox", 0, "wxStaticBox *", 0, 0, 0, 0},{"_p_wxStaticBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47121 static swig_type_info _swigt__p_long[] = {{"_p_long", 0, "long *", 0, 0, 0, 0},{"_p_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47122 static swig_type_info _swigt__p_wxDuplexMode[] = {{"_p_wxDuplexMode", 0, "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0, 0},{"_p_wxDuplexMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47123 static swig_type_info _swigt__p_wxTIFFHandler[] = {{"_p_wxTIFFHandler", 0, "wxTIFFHandler *", 0, 0, 0, 0},{"_p_wxTIFFHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47124 static swig_type_info _swigt__p_wxXPMHandler[] = {{"_p_wxXPMHandler", 0, "wxXPMHandler *", 0, 0, 0, 0},{"_p_wxXPMHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47125 static swig_type_info _swigt__p_wxPNMHandler[] = {{"_p_wxPNMHandler", 0, "wxPNMHandler *", 0, 0, 0, 0},{"_p_wxPNMHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47126 static swig_type_info _swigt__p_wxJPEGHandler[] = {{"_p_wxJPEGHandler", 0, "wxJPEGHandler *", 0, 0, 0, 0},{"_p_wxJPEGHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47127 static swig_type_info _swigt__p_wxPCXHandler[] = {{"_p_wxPCXHandler", 0, "wxPCXHandler *", 0, 0, 0, 0},{"_p_wxPCXHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47128 static swig_type_info _swigt__p_wxGIFHandler[] = {{"_p_wxGIFHandler", 0, "wxGIFHandler *", 0, 0, 0, 0},{"_p_wxGIFHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47129 static swig_type_info _swigt__p_wxPNGHandler[] = {{"_p_wxPNGHandler", 0, "wxPNGHandler *", 0, 0, 0, 0},{"_p_wxPNGHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47130 static swig_type_info _swigt__p_wxANIHandler[] = {{"_p_wxANIHandler", 0, "wxANIHandler *", 0, 0, 0, 0},{"_p_wxANIHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47131 static swig_type_info _swigt__p_wxMemoryFSHandler[] = {{"_p_wxMemoryFSHandler", 0, "wxMemoryFSHandler *", 0, 0, 0, 0},{"_p_wxMemoryFSHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47132 static swig_type_info _swigt__p_wxZipFSHandler[] = {{"_p_wxZipFSHandler", 0, "wxZipFSHandler *", 0, 0, 0, 0},{"_p_wxZipFSHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47133 static swig_type_info _swigt__p_wxInternetFSHandler[] = {{"_p_wxInternetFSHandler", 0, "wxInternetFSHandler *", 0, 0, 0, 0},{"_p_wxInternetFSHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47134 static swig_type_info _swigt__p_wxPyFileSystemHandler[] = {{"_p_wxPyFileSystemHandler", 0, "wxPyFileSystemHandler *", 0, 0, 0, 0},{"_p_wxPyFileSystemHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47135 static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47136 static swig_type_info _swigt__p_wxCURHandler[] = {{"_p_wxCURHandler", 0, "wxCURHandler *", 0, 0, 0, 0},{"_p_wxCURHandler", 0, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxCURHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47137 static swig_type_info _swigt__p_wxICOHandler[] = {{"_p_wxICOHandler", 0, "wxICOHandler *", 0, 0, 0, 0},{"_p_wxICOHandler", 0, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxICOHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxICOHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47138 static swig_type_info _swigt__p_wxBMPHandler[] = {{"_p_wxBMPHandler", 0, "wxBMPHandler *", 0, 0, 0, 0},{"_p_wxBMPHandler", 0, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxBMPHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxBMPHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxBMPHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47139 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47140 static swig_type_info _swigt__p_wxFileSystemHandler[] = {{"_p_wxFileSystemHandler", 0, "wxFileSystemHandler *", 0, 0, 0, 0},{"_p_wxFileSystemHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyFileSystemHandler", _p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{"_p_wxInternetFSHandler", _p_wxInternetFSHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{"_p_wxZipFSHandler", _p_wxZipFSHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{"_p_wxMemoryFSHandler", _p_wxMemoryFSHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47141 static swig_type_info _swigt__p_wxRect[] = {{"_p_wxRect", 0, "wxRect *", 0, 0, 0, 0},{"_p_wxRect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47142 static swig_type_info _swigt__p_wxButton[] = {{"_p_wxButton", 0, "wxButton *", 0, 0, 0, 0},{"_p_wxButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47143 static swig_type_info _swigt__p_wxGBSpan[] = {{"_p_wxGBSpan", 0, "wxGBSpan *", 0, 0, 0, 0},{"_p_wxGBSpan", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47144 static swig_type_info _swigt__p_wxPropagateOnce[] = {{"_p_wxPropagateOnce", 0, "wxPropagateOnce *", 0, 0, 0, 0},{"_p_wxPropagateOnce", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47145 static swig_type_info _swigt__p_wxAcceleratorTable[] = {{"_p_wxAcceleratorTable", 0, "wxAcceleratorTable *", 0, 0, 0, 0},{"_p_wxAcceleratorTable", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47146 static swig_type_info _swigt__p_wxStdDialogButtonSizer[] = {{"_p_wxStdDialogButtonSizer", 0, "wxStdDialogButtonSizer *", 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47147 static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47148 static swig_type_info _swigt__p_wxGBPosition[] = {{"_p_wxGBPosition", 0, "wxGBPosition *", 0, 0, 0, 0},{"_p_wxGBPosition", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47149 static swig_type_info _swigt__p_wxImage[] = {{"_p_wxImage", 0, "wxImage *", 0, 0, 0, 0},{"_p_wxImage", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47150 static swig_type_info _swigt__p_wxFrame[] = {{"_p_wxFrame", 0, "wxFrame *", 0, 0, 0, 0},{"_p_wxFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47151 static swig_type_info _swigt__p_wxScrollWinEvent[] = {{"_p_wxScrollWinEvent", 0, "wxScrollWinEvent *", 0, 0, 0, 0},{"_p_wxScrollWinEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47152 static swig_type_info _swigt__p_wxPaperSize[] = {{"_p_wxPaperSize", 0, "enum wxPaperSize *|wxPaperSize *", 0, 0, 0, 0},{"_p_wxPaperSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47153 static swig_type_info _swigt__p_wxImageHistogram[] = {{"_p_wxImageHistogram", 0, "wxImageHistogram *", 0, 0, 0, 0},{"_p_wxImageHistogram", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47154 static swig_type_info _swigt__p_wxPoint[] = {{"_p_wxPoint", 0, "wxPoint *", 0, 0, 0, 0},{"_p_wxPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47155 static swig_type_info _swigt__p_wxCursor[] = {{"_p_wxCursor", 0, "wxCursor *", 0, 0, 0, 0},{"_p_wxCursor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47156 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47157 static swig_type_info _swigt__p_wxInputStream[] = {{"_p_wxInputStream", 0, "wxInputStream *", 0, 0, 0, 0},{"_p_wxInputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47158 static swig_type_info _swigt__p_wxOutputStream[] = {{"_p_wxOutputStream", 0, "wxOutputStream *", 0, 0, 0, 0},{"_p_wxOutputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47159 static swig_type_info _swigt__p_wxPyInputStream[] = {{"_p_wxPyInputStream", 0, "wxPyInputStream *", 0, 0, 0, 0},{"_p_wxPyInputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47160 static swig_type_info _swigt__p_wxDateTime[] = {{"_p_wxDateTime", 0, "wxDateTime *", 0, 0, 0, 0},{"_p_wxDateTime", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47161 static swig_type_info _swigt__p_wxKeyEvent[] = {{"_p_wxKeyEvent", 0, "wxKeyEvent *", 0, 0, 0, 0},{"_p_wxKeyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47162 static swig_type_info _swigt__p_wxNavigationKeyEvent[] = {{"_p_wxNavigationKeyEvent", 0, "wxNavigationKeyEvent *", 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47163 static swig_type_info _swigt__p_wxWindowDestroyEvent[] = {{"_p_wxWindowDestroyEvent", 0, "wxWindowDestroyEvent *", 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47164 static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|wxUIntPtr *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47165 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47166 static swig_type_info _swigt__p_wxMenuBar[] = {{"_p_wxMenuBar", 0, "wxMenuBar *", 0, 0, 0, 0},{"_p_wxMenuBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47167 static swig_type_info _swigt__p_wxFileSystem[] = {{"_p_wxFileSystem", 0, "wxFileSystem *", 0, 0, 0, 0},{"_p_wxFileSystem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47168 static swig_type_info _swigt__p_wxBitmap[] = {{"_p_wxBitmap", 0, "wxBitmap *", 0, 0, 0, 0},{"_p_wxBitmap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47169 static swig_type_info _swigt__unsigned_int[] = {{"_unsigned_int", 0, "unsigned int|std::size_t", 0, 0, 0, 0},{"_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47170 static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *|time_t *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47171 static swig_type_info _swigt__p_wxMenuEvent[] = {{"_p_wxMenuEvent", 0, "wxMenuEvent *", 0, 0, 0, 0},{"_p_wxMenuEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47172 static swig_type_info _swigt__p_wxContextMenuEvent[] = {{"_p_wxContextMenuEvent", 0, "wxContextMenuEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47173 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47174 static swig_type_info _swigt__p_wxEraseEvent[] = {{"_p_wxEraseEvent", 0, "wxEraseEvent *", 0, 0, 0, 0},{"_p_wxEraseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47175 static swig_type_info _swigt__p_wxMouseEvent[] = {{"_p_wxMouseEvent", 0, "wxMouseEvent *", 0, 0, 0, 0},{"_p_wxMouseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47176 static swig_type_info _swigt__p_wxCloseEvent[] = {{"_p_wxCloseEvent", 0, "wxCloseEvent *", 0, 0, 0, 0},{"_p_wxCloseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47177 static swig_type_info _swigt__p_wxPyApp[] = {{"_p_wxPyApp", 0, "wxPyApp *", 0, 0, 0, 0},{"_p_wxPyApp", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47178 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47179 static swig_type_info _swigt__p_wxPyCommandEvent[] = {{"_p_wxPyCommandEvent", 0, "wxPyCommandEvent *", 0, 0, 0, 0},{"_p_wxPyCommandEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47180 static swig_type_info _swigt__p_wxPyDropTarget[] = {{"_p_wxPyDropTarget", 0, "wxPyDropTarget *", 0, 0, 0, 0},{"_p_wxPyDropTarget", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47181 static swig_type_info _swigt__p_wxQuantize[] = {{"_p_wxQuantize", 0, "wxQuantize *", 0, 0, 0, 0},{"_p_wxQuantize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47182 static swig_type_info _swigt__p_wxFocusEvent[] = {{"_p_wxFocusEvent", 0, "wxFocusEvent *", 0, 0, 0, 0},{"_p_wxFocusEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47183 static swig_type_info _swigt__p_wxChildFocusEvent[] = {{"_p_wxChildFocusEvent", 0, "wxChildFocusEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47184 static swig_type_info _swigt__p_wxDropFilesEvent[] = {{"_p_wxDropFilesEvent", 0, "wxDropFilesEvent *", 0, 0, 0, 0},{"_p_wxDropFilesEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47185 static swig_type_info _swigt__p_wxControlWithItems[] = {{"_p_wxControlWithItems", 0, "wxControlWithItems *", 0, 0, 0, 0},{"_p_wxControlWithItems", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47186 static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0, 0, 0, 0},{"_p_wxColour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47187 static swig_type_info _swigt__p_wxValidator[] = {{"_p_wxValidator", 0, "wxValidator *", 0, 0, 0, 0},{"_p_wxValidator", 0, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxValidator, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47188 static swig_type_info _swigt__p_wxPyValidator[] = {{"_p_wxPyValidator", 0, "wxPyValidator *", 0, 0, 0, 0},{"_p_wxPyValidator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47189
47190 static swig_type_info *swig_types_initial[] = {
47191 _swigt__p_wxLayoutConstraints,
47192 _swigt__p_wxRealPoint,
47193 _swigt__p_wxSizerItem,
47194 _swigt__p_wxGBSizerItem,
47195 _swigt__p_wxScrollEvent,
47196 _swigt__p_wxEventLoop,
47197 _swigt__p_wxIndividualLayoutConstraint,
47198 _swigt__p_wxSizer,
47199 _swigt__p_wxBoxSizer,
47200 _swigt__p_wxStaticBoxSizer,
47201 _swigt__p_wxGridBagSizer,
47202 _swigt__p_wxAcceleratorEntry,
47203 _swigt__p_wxUpdateUIEvent,
47204 _swigt__p_wxEvent,
47205 _swigt__p_buffer,
47206 _swigt__p_wxMenu,
47207 _swigt__p_wxGridSizer,
47208 _swigt__p_wxFlexGridSizer,
47209 _swigt__p_wxInitDialogEvent,
47210 _swigt__p_wxItemContainer,
47211 _swigt__p_wxNcPaintEvent,
47212 _swigt__p_wxPaintEvent,
47213 _swigt__p_wxSysColourChangedEvent,
47214 _swigt__p_wxMouseCaptureChangedEvent,
47215 _swigt__p_wxDisplayChangedEvent,
47216 _swigt__p_wxPaletteChangedEvent,
47217 _swigt__p_wxControl,
47218 _swigt__p_wxFont,
47219 _swigt__p_wxMenuBarBase,
47220 _swigt__p_wxSetCursorEvent,
47221 _swigt__p_wxFSFile,
47222 _swigt__p_wxCaret,
47223 _swigt__ptrdiff_t,
47224 _swigt__std__ptrdiff_t,
47225 _swigt__p_wxRegion,
47226 _swigt__p_wxPoint2D,
47227 _swigt__p_int,
47228 _swigt__p_wxSize,
47229 _swigt__p_wxDC,
47230 _swigt__p_wxPySizer,
47231 _swigt__p_wxVisualAttributes,
47232 _swigt__p_wxNotifyEvent,
47233 _swigt__p_wxPyEvent,
47234 _swigt__p_wxPropagationDisabler,
47235 _swigt__p_form_ops_t,
47236 _swigt__p_wxAppTraits,
47237 _swigt__p_wxArrayString,
47238 _swigt__p_wxShowEvent,
47239 _swigt__p_wxToolTip,
47240 _swigt__p_wxMoveEvent,
47241 _swigt__p_wxSizeEvent,
47242 _swigt__p_wxActivateEvent,
47243 _swigt__p_wxIconizeEvent,
47244 _swigt__p_wxMaximizeEvent,
47245 _swigt__p_wxQueryNewPaletteEvent,
47246 _swigt__p_wxWindowCreateEvent,
47247 _swigt__p_wxIdleEvent,
47248 _swigt__p_wxDateEvent,
47249 _swigt__p_wxMenuItem,
47250 _swigt__p_wxStaticBox,
47251 _swigt__p_long,
47252 _swigt__p_wxDuplexMode,
47253 _swigt__p_wxTIFFHandler,
47254 _swigt__p_wxXPMHandler,
47255 _swigt__p_wxPNMHandler,
47256 _swigt__p_wxJPEGHandler,
47257 _swigt__p_wxPCXHandler,
47258 _swigt__p_wxGIFHandler,
47259 _swigt__p_wxPNGHandler,
47260 _swigt__p_wxANIHandler,
47261 _swigt__p_wxMemoryFSHandler,
47262 _swigt__p_wxZipFSHandler,
47263 _swigt__p_wxInternetFSHandler,
47264 _swigt__p_wxPyFileSystemHandler,
47265 _swigt__p_wxEvtHandler,
47266 _swigt__p_wxCURHandler,
47267 _swigt__p_wxICOHandler,
47268 _swigt__p_wxBMPHandler,
47269 _swigt__p_wxImageHandler,
47270 _swigt__p_wxFileSystemHandler,
47271 _swigt__p_wxRect,
47272 _swigt__p_wxButton,
47273 _swigt__p_wxGBSpan,
47274 _swigt__p_wxPropagateOnce,
47275 _swigt__p_wxAcceleratorTable,
47276 _swigt__p_wxStdDialogButtonSizer,
47277 _swigt__p_char,
47278 _swigt__p_wxGBPosition,
47279 _swigt__p_wxImage,
47280 _swigt__p_wxFrame,
47281 _swigt__p_wxScrollWinEvent,
47282 _swigt__p_wxPaperSize,
47283 _swigt__p_wxImageHistogram,
47284 _swigt__p_wxPoint,
47285 _swigt__p_wxCursor,
47286 _swigt__p_wxObject,
47287 _swigt__p_wxInputStream,
47288 _swigt__p_wxOutputStream,
47289 _swigt__p_wxPyInputStream,
47290 _swigt__p_wxDateTime,
47291 _swigt__p_wxKeyEvent,
47292 _swigt__p_wxNavigationKeyEvent,
47293 _swigt__p_wxWindowDestroyEvent,
47294 _swigt__p_unsigned_long,
47295 _swigt__p_wxWindow,
47296 _swigt__p_wxMenuBar,
47297 _swigt__p_wxFileSystem,
47298 _swigt__p_wxBitmap,
47299 _swigt__unsigned_int,
47300 _swigt__p_unsigned_int,
47301 _swigt__p_wxMenuEvent,
47302 _swigt__p_wxContextMenuEvent,
47303 _swigt__p_unsigned_char,
47304 _swigt__p_wxEraseEvent,
47305 _swigt__p_wxMouseEvent,
47306 _swigt__p_wxCloseEvent,
47307 _swigt__p_wxPyApp,
47308 _swigt__p_wxCommandEvent,
47309 _swigt__p_wxPyCommandEvent,
47310 _swigt__p_wxPyDropTarget,
47311 _swigt__p_wxQuantize,
47312 _swigt__p_wxFocusEvent,
47313 _swigt__p_wxChildFocusEvent,
47314 _swigt__p_wxDropFilesEvent,
47315 _swigt__p_wxControlWithItems,
47316 _swigt__p_wxColour,
47317 _swigt__p_wxValidator,
47318 _swigt__p_wxPyValidator,
47319 0
47320 };
47321
47322
47323 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47324
47325 static swig_const_info swig_const_table[] = {
47326 {0, 0, 0, 0.0, 0, 0}};
47327
47328 #ifdef __cplusplus
47329 }
47330 #endif
47331
47332
47333 #ifdef __cplusplus
47334 extern "C" {
47335 #endif
47336
47337 /* Python-specific SWIG API */
47338 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47339 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47340 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47341
47342 /* -----------------------------------------------------------------------------
47343 * global variable support code.
47344 * ----------------------------------------------------------------------------- */
47345
47346 typedef struct swig_globalvar {
47347 char *name; /* Name of global variable */
47348 PyObject *(*get_attr)(); /* Return the current value */
47349 int (*set_attr)(PyObject *); /* Set the value */
47350 struct swig_globalvar *next;
47351 } swig_globalvar;
47352
47353 typedef struct swig_varlinkobject {
47354 PyObject_HEAD
47355 swig_globalvar *vars;
47356 } swig_varlinkobject;
47357
47358 static PyObject *
47359 swig_varlink_repr(swig_varlinkobject *v) {
47360 v = v;
47361 return PyString_FromString("<Swig global variables>");
47362 }
47363
47364 static int
47365 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47366 swig_globalvar *var;
47367 flags = flags;
47368 fprintf(fp,"Swig global variables { ");
47369 for (var = v->vars; var; var=var->next) {
47370 fprintf(fp,"%s", var->name);
47371 if (var->next) fprintf(fp,", ");
47372 }
47373 fprintf(fp," }\n");
47374 return 0;
47375 }
47376
47377 static PyObject *
47378 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47379 swig_globalvar *var = v->vars;
47380 while (var) {
47381 if (strcmp(var->name,n) == 0) {
47382 return (*var->get_attr)();
47383 }
47384 var = var->next;
47385 }
47386 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47387 return NULL;
47388 }
47389
47390 static int
47391 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47392 swig_globalvar *var = v->vars;
47393 while (var) {
47394 if (strcmp(var->name,n) == 0) {
47395 return (*var->set_attr)(p);
47396 }
47397 var = var->next;
47398 }
47399 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47400 return 1;
47401 }
47402
47403 static PyTypeObject varlinktype = {
47404 PyObject_HEAD_INIT(0)
47405 0, /* Number of items in variable part (ob_size) */
47406 (char *)"swigvarlink", /* Type name (tp_name) */
47407 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47408 0, /* Itemsize (tp_itemsize) */
47409 0, /* Deallocator (tp_dealloc) */
47410 (printfunc) swig_varlink_print, /* Print (tp_print) */
47411 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47412 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47413 0, /* tp_compare */
47414 (reprfunc) swig_varlink_repr, /* tp_repr */
47415 0, /* tp_as_number */
47416 0, /* tp_as_sequence */
47417 0, /* tp_as_mapping */
47418 0, /* tp_hash */
47419 0, /* tp_call */
47420 0, /* tp_str */
47421 0, /* tp_getattro */
47422 0, /* tp_setattro */
47423 0, /* tp_as_buffer */
47424 0, /* tp_flags */
47425 0, /* tp_doc */
47426 #if PY_VERSION_HEX >= 0x02000000
47427 0, /* tp_traverse */
47428 0, /* tp_clear */
47429 #endif
47430 #if PY_VERSION_HEX >= 0x02010000
47431 0, /* tp_richcompare */
47432 0, /* tp_weaklistoffset */
47433 #endif
47434 #if PY_VERSION_HEX >= 0x02020000
47435 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47436 #endif
47437 #if PY_VERSION_HEX >= 0x02030000
47438 0, /* tp_del */
47439 #endif
47440 #ifdef COUNT_ALLOCS
47441 0,0,0,0 /* tp_alloc -> tp_next */
47442 #endif
47443 };
47444
47445 /* Create a variable linking object for use later */
47446 static PyObject *
47447 SWIG_Python_newvarlink(void) {
47448 swig_varlinkobject *result = 0;
47449 result = PyMem_NEW(swig_varlinkobject,1);
47450 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47451 result->ob_type = &varlinktype;
47452 result->vars = 0;
47453 result->ob_refcnt = 0;
47454 Py_XINCREF((PyObject *) result);
47455 return ((PyObject*) result);
47456 }
47457
47458 static void
47459 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47460 swig_varlinkobject *v;
47461 swig_globalvar *gv;
47462 v= (swig_varlinkobject *) p;
47463 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47464 gv->name = (char *) malloc(strlen(name)+1);
47465 strcpy(gv->name,name);
47466 gv->get_attr = get_attr;
47467 gv->set_attr = set_attr;
47468 gv->next = v->vars;
47469 v->vars = gv;
47470 }
47471
47472 /* -----------------------------------------------------------------------------
47473 * constants/methods manipulation
47474 * ----------------------------------------------------------------------------- */
47475
47476 /* Install Constants */
47477 static void
47478 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47479 PyObject *obj = 0;
47480 size_t i;
47481 for (i = 0; constants[i].type; i++) {
47482 switch(constants[i].type) {
47483 case SWIG_PY_INT:
47484 obj = PyInt_FromLong(constants[i].lvalue);
47485 break;
47486 case SWIG_PY_FLOAT:
47487 obj = PyFloat_FromDouble(constants[i].dvalue);
47488 break;
47489 case SWIG_PY_STRING:
47490 if (constants[i].pvalue) {
47491 obj = PyString_FromString((char *) constants[i].pvalue);
47492 } else {
47493 Py_INCREF(Py_None);
47494 obj = Py_None;
47495 }
47496 break;
47497 case SWIG_PY_POINTER:
47498 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47499 break;
47500 case SWIG_PY_BINARY:
47501 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47502 break;
47503 default:
47504 obj = 0;
47505 break;
47506 }
47507 if (obj) {
47508 PyDict_SetItemString(d,constants[i].name,obj);
47509 Py_DECREF(obj);
47510 }
47511 }
47512 }
47513
47514 /* -----------------------------------------------------------------------------*/
47515 /* Fix SwigMethods to carry the callback ptrs when needed */
47516 /* -----------------------------------------------------------------------------*/
47517
47518 static void
47519 SWIG_Python_FixMethods(PyMethodDef *methods,
47520 swig_const_info *const_table,
47521 swig_type_info **types,
47522 swig_type_info **types_initial) {
47523 size_t i;
47524 for (i = 0; methods[i].ml_name; ++i) {
47525 char *c = methods[i].ml_doc;
47526 if (c && (c = strstr(c, "swig_ptr: "))) {
47527 int j;
47528 swig_const_info *ci = 0;
47529 char *name = c + 10;
47530 for (j = 0; const_table[j].type; j++) {
47531 if (strncmp(const_table[j].name, name,
47532 strlen(const_table[j].name)) == 0) {
47533 ci = &(const_table[j]);
47534 break;
47535 }
47536 }
47537 if (ci) {
47538 size_t shift = (ci->ptype) - types;
47539 swig_type_info *ty = types_initial[shift];
47540 size_t ldoc = (c - methods[i].ml_doc);
47541 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47542 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47543 char *buff = ndoc;
47544 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47545 strncpy(buff, methods[i].ml_doc, ldoc);
47546 buff += ldoc;
47547 strncpy(buff, "swig_ptr: ", 10);
47548 buff += 10;
47549 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47550 methods[i].ml_doc = ndoc;
47551 }
47552 }
47553 }
47554 }
47555
47556 /* -----------------------------------------------------------------------------*
47557 * Initialize type list
47558 * -----------------------------------------------------------------------------*/
47559
47560 #if PY_MAJOR_VERSION < 2
47561 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47562 is copied out of Python/modsupport.c in python version 2.3.4 */
47563 static int
47564 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47565 {
47566 PyObject *dict;
47567 if (!PyModule_Check(m)) {
47568 PyErr_SetString(PyExc_TypeError,
47569 "PyModule_AddObject() needs module as first arg");
47570 return -1;
47571 }
47572 if (!o) {
47573 PyErr_SetString(PyExc_TypeError,
47574 "PyModule_AddObject() needs non-NULL value");
47575 return -1;
47576 }
47577
47578 dict = PyModule_GetDict(m);
47579 if (dict == NULL) {
47580 /* Internal error -- modules must have a dict! */
47581 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47582 PyModule_GetName(m));
47583 return -1;
47584 }
47585 if (PyDict_SetItemString(dict, name, o))
47586 return -1;
47587 Py_DECREF(o);
47588 return 0;
47589 }
47590 #endif
47591
47592 static swig_type_info **
47593 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47594 static PyMethodDef swig_empty_runtime_method_table[] = {
47595 {
47596 NULL, NULL, 0, NULL
47597 }
47598 };/* Sentinel */
47599
47600 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47601 swig_empty_runtime_method_table);
47602 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47603 if (pointer && module) {
47604 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47605 }
47606 return type_list_handle;
47607 }
47608
47609 static swig_type_info **
47610 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47611 swig_type_info **type_pointer;
47612
47613 /* first check if module already created */
47614 type_pointer = SWIG_Python_GetTypeListHandle();
47615 if (type_pointer) {
47616 return type_pointer;
47617 } else {
47618 /* create a new module and variable */
47619 return SWIG_Python_SetTypeListHandle(type_list_handle);
47620 }
47621 }
47622
47623 #ifdef __cplusplus
47624 }
47625 #endif
47626
47627 /* -----------------------------------------------------------------------------*
47628 * Partial Init method
47629 * -----------------------------------------------------------------------------*/
47630
47631 #ifdef SWIG_LINK_RUNTIME
47632 #ifdef __cplusplus
47633 extern "C"
47634 #endif
47635 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47636 #endif
47637
47638 #ifdef __cplusplus
47639 extern "C"
47640 #endif
47641 SWIGEXPORT(void) SWIG_init(void) {
47642 static PyObject *SWIG_globals = 0;
47643 static int typeinit = 0;
47644 PyObject *m, *d;
47645 int i;
47646 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47647
47648 /* Fix SwigMethods to carry the callback ptrs when needed */
47649 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47650
47651 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47652 d = PyModule_GetDict(m);
47653
47654 if (!typeinit) {
47655 #ifdef SWIG_LINK_RUNTIME
47656 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47657 #else
47658 # ifndef SWIG_STATIC_RUNTIME
47659 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47660 # endif
47661 #endif
47662 for (i = 0; swig_types_initial[i]; i++) {
47663 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47664 }
47665 typeinit = 1;
47666 }
47667 SWIG_InstallConstants(d,swig_const_table);
47668
47669
47670 #ifndef wxPyUSE_EXPORT
47671 // Make our API structure a CObject so other modules can import it
47672 // from this module.
47673 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47674 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47675 Py_XDECREF(cobj);
47676 #endif
47677
47678 {
47679 PyDict_SetItemString(d,"wxNOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"wxVSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"wxHSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"wxCAPTION", SWIG_From_int((int)(wxCAPTION)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"wxDOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"wxSUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"wxRAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"wxBORDER", SWIG_From_int((int)(wxBORDER)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"wxSIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"wxSTATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"wxTRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"wxNO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"wxTAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"wxWANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"wxPOPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"wxCENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"wxCENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"wxCENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"wxCLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"wxCLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"wxALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"wxRETAINED", SWIG_From_int((int)(wxRETAINED)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"wxBACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"wxCOLOURED", SWIG_From_int((int)(wxCOLOURED)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"wxFIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"wxLB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"wxLB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"wxLB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"wxLB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"wxLB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"wxLB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"wxLB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"wxLB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"wxPROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"wxPASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"wxCB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"wxCB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"wxCB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"wxCB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"wxRA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"wxRA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"wxRA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"wxRA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"wxRA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"wxRB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"wxRB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"wxSB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"wxSB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"wxRB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"wxST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"wxST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"wxFLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"wxFLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"wxODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"wxWINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"wxTOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"wxTOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"wxTOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"wxTOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"wxOK", SWIG_From_int((int)(wxOK)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"wxYES_NO", SWIG_From_int((int)(wxYES_NO)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"wxCANCEL", SWIG_From_int((int)(wxCANCEL)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"wxYES", SWIG_From_int((int)(wxYES)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"wxNO", SWIG_From_int((int)(wxNO)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"wxNO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"wxYES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"wxICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"wxICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"wxICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"wxICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"wxICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"wxICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"wxICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"wxICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"wxICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"wxFORWARD", SWIG_From_int((int)(wxFORWARD)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"wxBACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"wxRESET", SWIG_From_int((int)(wxRESET)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"wxHELP", SWIG_From_int((int)(wxHELP)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"wxMORE", SWIG_From_int((int)(wxMORE)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"wxSETUP", SWIG_From_int((int)(wxSETUP)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"wxSIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"wxSIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"wxSIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"wxSIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"wxSIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"wxPORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"wxLANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"wxPRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"wxPRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"wxPRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"wxPRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"wxID_ANY", SWIG_From_int((int)(wxID_ANY)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"wxID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"wxID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"wxID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"wxID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"wxID_NEW", SWIG_From_int((int)(wxID_NEW)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"wxID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"wxID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"wxID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"wxID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"wxID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"wxID_REDO", SWIG_From_int((int)(wxID_REDO)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"wxID_HELP", SWIG_From_int((int)(wxID_HELP)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"wxID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"wxID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"wxID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"wxID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"wxID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"wxID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"wxID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"wxID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"wxID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"wxID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"wxID_CUT", SWIG_From_int((int)(wxID_CUT)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"wxID_COPY", SWIG_From_int((int)(wxID_COPY)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"wxID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"wxID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"wxID_FIND", SWIG_From_int((int)(wxID_FIND)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"wxID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"wxID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"wxID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"wxID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"wxID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"wxID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"wxID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"wxID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"wxID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"wxID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"wxID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"wxID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"wxID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"wxID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"wxID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"wxID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"wxID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"wxID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"wxID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"wxID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"wxID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"wxID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"wxID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"wxID_OK", SWIG_From_int((int)(wxID_OK)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"wxID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"wxID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"wxID_YES", SWIG_From_int((int)(wxID_YES)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"wxID_NO", SWIG_From_int((int)(wxID_NO)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"wxID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"wxID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"wxID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"wxID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"wxID_MORE", SWIG_From_int((int)(wxID_MORE)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"wxID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"wxID_RESET", SWIG_From_int((int)(wxID_RESET)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"wxID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"wxID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"wxID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"wxID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"wxID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"wxID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"wxID_ADD", SWIG_From_int((int)(wxID_ADD)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"wxID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"wxID_UP", SWIG_From_int((int)(wxID_UP)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"wxID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"wxID_HOME", SWIG_From_int((int)(wxID_HOME)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"wxID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"wxID_STOP", SWIG_From_int((int)(wxID_STOP)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"wxID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"wxID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"wxID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"wxID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"wxID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"wxID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"wxID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"wxID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"wxID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"wxID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"wxID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"wxID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"wxID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"wxID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"wxID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"wxID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"wxID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"wxOPEN", SWIG_From_int((int)(wxOPEN)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"wxSAVE", SWIG_From_int((int)(wxSAVE)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"wxHIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"wxOVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"wxFILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"wxMULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"wxCHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"wxACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"wxACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"wxACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"wxACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"wxPD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"wxPD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"wxPD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"wxPD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"wxPD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"wxPD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"wxPD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"wxPD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"wxDD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"wxDD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"wxMENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"wxMB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"wxNO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"wxFULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"wxLI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"wxLI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"wxWS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"wxWS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"wxWS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"wxWS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"wxWS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"wxWS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"wxMM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"wxMM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"wxMM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"wxMM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"wxMM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"wxMM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"wxMM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"wxMM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"wxMM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"wxMM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"wxCENTRE", SWIG_From_int((int)(wxCENTRE)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"wxCENTER", SWIG_From_int((int)(wxCENTER)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"wxHORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"wxVERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"wxBOTH", SWIG_From_int((int)(wxBOTH)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"wxLEFT", SWIG_From_int((int)(wxLEFT)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"wxRIGHT", SWIG_From_int((int)(wxRIGHT)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"wxUP", SWIG_From_int((int)(wxUP)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"wxDOWN", SWIG_From_int((int)(wxDOWN)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"wxTOP", SWIG_From_int((int)(wxTOP)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"wxBOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"wxNORTH", SWIG_From_int((int)(wxNORTH)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"wxSOUTH", SWIG_From_int((int)(wxSOUTH)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"wxWEST", SWIG_From_int((int)(wxWEST)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"wxEAST", SWIG_From_int((int)(wxEAST)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"wxALL", SWIG_From_int((int)(wxALL)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"wxALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"wxALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"wxALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"wxALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"wxALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"wxALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"wxALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"wxALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"wxALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"wxALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"wxALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"wxALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"wxSTRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"wxSHRINK", SWIG_From_int((int)(wxSHRINK)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"wxGROW", SWIG_From_int((int)(wxGROW)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"wxEXPAND", SWIG_From_int((int)(wxEXPAND)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"wxSHAPED", SWIG_From_int((int)(wxSHAPED)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"wxFIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"wxTILE", SWIG_From_int((int)(wxTILE)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"wxADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"wxBORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"wxBORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"wxBORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"wxBORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"wxBORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"wxBORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"wxBORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"wxBORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"wxBG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"wxBG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"wxBG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"wxDEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"wxDECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"wxROMAN", SWIG_From_int((int)(wxROMAN)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"wxSCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"wxSWISS", SWIG_From_int((int)(wxSWISS)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"wxMODERN", SWIG_From_int((int)(wxMODERN)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"wxTELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"wxVARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"wxFIXED", SWIG_From_int((int)(wxFIXED)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"wxNORMAL", SWIG_From_int((int)(wxNORMAL)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"wxLIGHT", SWIG_From_int((int)(wxLIGHT)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"wxBOLD", SWIG_From_int((int)(wxBOLD)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"wxITALIC", SWIG_From_int((int)(wxITALIC)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"wxSLANT", SWIG_From_int((int)(wxSLANT)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"wxSOLID", SWIG_From_int((int)(wxSOLID)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"wxDOT", SWIG_From_int((int)(wxDOT)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"wxLONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"wxSHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"wxDOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"wxUSER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"wxTRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"wxSTIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"wxBDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"wxCROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"wxFDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"wxCROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"wxHORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"wxVERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"wxJOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"wxJOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"wxJOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"wxCAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"wxCAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"wxCAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"wxCLEAR", SWIG_From_int((int)(wxCLEAR)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"wxXOR", SWIG_From_int((int)(wxXOR)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"wxINVERT", SWIG_From_int((int)(wxINVERT)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"wxOR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"wxAND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"wxCOPY", SWIG_From_int((int)(wxCOPY)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"wxAND", SWIG_From_int((int)(wxAND)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"wxAND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"wxNO_OP", SWIG_From_int((int)(wxNO_OP)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"wxNOR", SWIG_From_int((int)(wxNOR)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"wxEQUIV", SWIG_From_int((int)(wxEQUIV)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"wxSRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"wxOR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"wxNAND", SWIG_From_int((int)(wxNAND)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"wxOR", SWIG_From_int((int)(wxOR)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"wxSET", SWIG_From_int((int)(wxSET)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"wxPAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"wxPAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"wxPAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"wxPAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"wxPAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"wxPAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"wxPAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"wxPAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"wxPAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"wxPAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"wxPAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"wxPAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"wxPAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"wxPAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"wxPAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"wxPAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"wxPAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"wxPAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"wxPAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"wxPAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"wxPAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"wxPAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"wxPAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"wxPAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"wxPAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"wxPAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"wxPAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"wxPAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"wxPAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"wxPAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"wxPAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"wxPAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"wxPAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"wxPAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"wxPAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"wxPAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"wxPAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"wxPAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"wxPAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"wxPAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"wxPAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"wxPAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"wxPAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"wxPAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"wxPAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"wxPAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"wxPAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"wxPAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"wxPAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"wxPAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"wxPAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"wxPAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"wxPAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"wxPAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"wxPAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"wxPAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"wxPAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"wxPAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"wxPAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"wxPAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"wxPAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"wxPAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"wxPAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"wxPAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"wxPAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"wxPAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"wxPAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"wxDUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"wxDUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"wxDUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"wxITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"wxITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"wxITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"wxITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"wxITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"wxHT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"wxHT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"wxHT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"wxHT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"wxHT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"wxHT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"wxHT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"wxHT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"wxHT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"wxHT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"wxHT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"wxHT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"wxMOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"wxMOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"wxMOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"wxMOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"wxMOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"wxUPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"wxUPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"wxUPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49330 }
49331 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49332 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49333 {
49334 PyDict_SetItemString(d,"wxBITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"wxBITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"wxBITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"wxBITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"wxBITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"wxBITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"wxBITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"wxBITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"wxBITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"wxBITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"wxBITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"wxBITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"wxBITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"wxBITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"wxBITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"wxBITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"wxBITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"wxBITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"wxBITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"wxBITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"wxCURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"wxCURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"wxCURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"wxCURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"wxCURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"wxCURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"wxCURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"wxCURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"wxCURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"wxCURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"wxCURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"wxCURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"wxCURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"wxCURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"wxCURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"wxCURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"wxCURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"wxCURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"wxCURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"wxCURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"wxCURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"wxCURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"wxCURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"wxCURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"wxCURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"wxCURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"wxCURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"wxCURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"wxCURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"wxCURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"wxCURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49485 }
49486 SWIG_addvarlink(SWIG_globals,(char*)"wxDefaultPosition",_wrap_wxDefaultPosition_get, _wrap_wxDefaultPosition_set);
49487 SWIG_addvarlink(SWIG_globals,(char*)"wxDefaultSize",_wrap_wxDefaultSize_get, _wrap_wxDefaultSize_set);
49488 {
49489 PyDict_SetItemString(d,"wxFromStart", SWIG_From_int((int)(wxFromStart)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"wxFromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"wxFromEnd", SWIG_From_int((int)(wxFromEnd)));
49496 }
49497
49498 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49499
49500
49501 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49502
49503 SWIG_addvarlink(SWIG_globals,(char*)"wxNullImage",_wrap_wxNullImage_get, _wrap_wxNullImage_set);
49504 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49505 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49506 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49507 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49508 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49509 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49510 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49511 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49512 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49513 {
49514 PyDict_SetItemString(d,"wxIMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"wxIMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49518 }
49519 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49520 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49521 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49522 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49523 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49524 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49525 {
49526 PyDict_SetItemString(d,"wxPNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"wxPNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"wxPNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"wxBMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"wxBMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"wxBMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"wxBMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"wxBMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"wxBMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"wxBMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"wxBMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"wxBMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"wxQUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"wxQUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"wxEVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"wxEVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49572 }
49573 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49574 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49575 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49576 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49577 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49578 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49579 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49580 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49581 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49582 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49583 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49584 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49585 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49586 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49587 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49588 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49589 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49590 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49591 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49592 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49593 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49594 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49595 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49596 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49597 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49598 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49599 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49600 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49601 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49602 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49603 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49604 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49605 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49606 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49607 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49608 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49609 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49610 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49611 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49612 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49613 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49614 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49615 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49616 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49617 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49618 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49619 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49620 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49621 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49622 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49623 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49624 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49625 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49626 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49627 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49628 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49629 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49630 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49631 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49632 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49633 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49634 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49635 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49636 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49637 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49638 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49639 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49640 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49641 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49642 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49643 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49644 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49645 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49646 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49647 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49648 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49649 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49650 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49651 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49652 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49653 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49654 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49655 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49656 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49657 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49658 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49659 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49660 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49661 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49662 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49663 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49664 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49665 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49666 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49667 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49668 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49669 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49670 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49671 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49672 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49673 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49674 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49675 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49676 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49677 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49678 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49679 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49680 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49681 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49682 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49683 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49684 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49685 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49686 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49687 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49688 {
49689 PyDict_SetItemString(d,"wxMOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"wxMOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"wxMOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"wxMOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"wxMOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"wxUPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"wxUPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"wxNavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"wxNavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"wxNavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"wxNavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"wxIDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"wxIDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49726 }
49727 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49728 {
49729 PyDict_SetItemString(d,"wxPYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"wxPYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"wxPYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"wxPYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"wxPRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"wxPRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49745 }
49746 SWIG_addvarlink(SWIG_globals,(char*)"wxNullAcceleratorTable",_wrap_wxNullAcceleratorTable_get, _wrap_wxNullAcceleratorTable_set);
49747 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49748 {
49749 PyDict_SetItemString(d,"wxWINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"wxWINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"wxWINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"wxWINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"wxWINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49762 }
49763 SWIG_addvarlink(SWIG_globals,(char*)"wxDefaultValidator",_wrap_wxDefaultValidator_get, _wrap_wxDefaultValidator_set);
49764 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49765 {
49766 PyDict_SetItemString(d,"wxFLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"wxFLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"wxFLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49773 }
49774 SWIG_addvarlink(SWIG_globals,(char*)"wxDefaultSpan",_wrap_wxDefaultSpan_get, _wrap_wxDefaultSpan_set);
49775 {
49776 PyDict_SetItemString(d,"wxLeft", SWIG_From_int((int)(wxLeft)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"wxTop", SWIG_From_int((int)(wxTop)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"wxRight", SWIG_From_int((int)(wxRight)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"wxBottom", SWIG_From_int((int)(wxBottom)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"wxWidth", SWIG_From_int((int)(wxWidth)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"wxHeight", SWIG_From_int((int)(wxHeight)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"wxCentre", SWIG_From_int((int)(wxCentre)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"wxCenter", SWIG_From_int((int)(wxCenter)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"wxCentreX", SWIG_From_int((int)(wxCentreX)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"wxCentreY", SWIG_From_int((int)(wxCentreY)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"wxUnconstrained", SWIG_From_int((int)(wxUnconstrained)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"wxAsIs", SWIG_From_int((int)(wxAsIs)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"wxPercentOf", SWIG_From_int((int)(wxPercentOf)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"wxAbove", SWIG_From_int((int)(wxAbove)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"wxBelow", SWIG_From_int((int)(wxBelow)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"wxLeftOf", SWIG_From_int((int)(wxLeftOf)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"wxRightOf", SWIG_From_int((int)(wxRightOf)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"wxSameAs", SWIG_From_int((int)(wxSameAs)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"wxAbsolute", SWIG_From_int((int)(wxAbsolute)));
49831 }
49832
49833 // Initialize threading, some globals and such
49834 __wxPyPreStart(d);
49835
49836
49837 // Although these are defined in __version__ they need to be here too so
49838 // that an assert can be done to ensure that the wxPython and the wxWindows
49839 // versions match.
49840 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49841 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49842 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49843
49844 }
49845
wxWidgets (Impactor)