]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Bumped subrelease number
[wxWidgets.git] / wxPython / src / msw / _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_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2305 if (width > 0 && height > 0)
2306 return new wxImage(width, height, clear);
2307 else
2308 return new wxImage;
2309 }
2310 static wxImage *new_wxImage(wxBitmap const &bitmap){
2311 return new wxImage(bitmap.ConvertToImage());
2312 }
2313 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2314 // Copy the source data so the wxImage can clean it up later
2315 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2316 if (copy == NULL) {
2317 PyErr_NoMemory();
2318 return NULL;
2319 }
2320 memcpy(copy, data, width*height*3);
2321 return new wxImage(width, height, copy, false);
2322 }
2323 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2324 // Copy the source data so the wxImage can clean it up later
2325 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2326 if (dcopy == NULL) {
2327 PyErr_NoMemory();
2328 return NULL;
2329 }
2330 memcpy(dcopy, data, width*height*3);
2331 unsigned char* acopy = (unsigned char*)malloc(width*height);
2332 if (acopy == NULL) {
2333 PyErr_NoMemory();
2334 return NULL;
2335 }
2336 memcpy(acopy, alpha, width*height);
2337
2338 return new wxImage(width, height, dcopy, acopy, false);
2339 }
2340 static wxSize wxImage_GetSize(wxImage *self){
2341 wxSize size(self->GetWidth(), self->GetHeight());
2342 return size;
2343 }
2344 static PyObject *wxImage_GetData(wxImage *self){
2345 unsigned char* data = self->GetData();
2346 int len = self->GetWidth() * self->GetHeight() * 3;
2347 PyObject* rv;
2348 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2349 return rv;
2350 }
2351 static void wxImage_SetData(wxImage *self,PyObject *data){
2352 unsigned char* dataPtr;
2353
2354 if (! PyString_Check(data)) {
2355 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2356 "Expected string object"));
2357 return /* NULL */ ;
2358 }
2359
2360 size_t len = self->GetWidth() * self->GetHeight() * 3;
2361 dataPtr = (unsigned char*) malloc(len);
2362 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2363 self->SetData(dataPtr);
2364 // wxImage takes ownership of dataPtr...
2365 }
2366 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2367 unsigned char* data = self->GetData();
2368 int len = self->GetWidth() * self->GetHeight() * 3;
2369 PyObject* rv;
2370 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2371 return rv;
2372 }
2373 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2374 unsigned char* buffer;
2375 int size;
2376
2377 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2378 if (!PyArg_Parse(data, "t#", &buffer, &size))
2379 goto done;
2380
2381 if (size != self->GetWidth() * self->GetHeight() * 3) {
2382 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2383 goto done;
2384 }
2385 self->SetData(buffer);
2386 done:
2387 wxPyEndBlockThreads(blocked);
2388 }
2389 static PyObject *wxImage_GetAlphaData(wxImage *self){
2390 unsigned char* data = self->GetAlpha();
2391 if (! data) {
2392 RETURN_NONE();
2393 } else {
2394 int len = self->GetWidth() * self->GetHeight();
2395 PyObject* rv;
2396 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2397 return rv;
2398 }
2399 }
2400 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2401 unsigned char* dataPtr;
2402
2403 if (! PyString_Check(data)) {
2404 PyErr_SetString(PyExc_TypeError, "Expected string object");
2405 return /* NULL */ ;
2406 }
2407
2408 size_t len = self->GetWidth() * self->GetHeight();
2409 dataPtr = (unsigned char*) malloc(len);
2410 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2411 self->SetAlpha(dataPtr);
2412 // wxImage takes ownership of dataPtr...
2413 }
2414 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2415 unsigned char* data = self->GetAlpha();
2416 int len = self->GetWidth() * self->GetHeight();
2417 PyObject* rv;
2418 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2419 return rv;
2420 }
2421 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2422 unsigned char* buffer;
2423 int size;
2424
2425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2426 if (!PyArg_Parse(data, "t#", &buffer, &size))
2427 goto done;
2428
2429 if (size != self->GetWidth() * self->GetHeight()) {
2430 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2431 goto done;
2432 }
2433 self->SetAlpha(buffer);
2434 done:
2435 wxPyEndBlockThreads(blocked);
2436 }
2437
2438 SWIGINTERNSHORT unsigned long
2439 SWIG_As_unsigned_SS_long(PyObject* obj)
2440 {
2441 unsigned long v;
2442 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2443 /*
2444 this is needed to make valgrind/purify happier.
2445 */
2446 memset((void*)&v, 0, sizeof(unsigned long));
2447 }
2448 return v;
2449 }
2450
2451
2452 SWIGINTERNSHORT int
2453 SWIG_Check_unsigned_SS_long(PyObject* obj)
2454 {
2455 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2456 }
2457
2458 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2459 wxBitmap bitmap(*self, depth);
2460 return bitmap;
2461 }
2462 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2463 wxImage mono = self->ConvertToMono( red, green, blue );
2464 wxBitmap bitmap( mono, 1 );
2465 return bitmap;
2466 }
2467 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2468 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2470 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2474 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2475 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2476 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2477 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2478 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2479 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2480 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2481 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2482
2483 #include <wx/quantize.h>
2484
2485 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2486 return wxQuantize::Quantize(src, dest,
2487 //NULL, // palette
2488 desiredNoColours,
2489 NULL, // eightBitData
2490 flags);
2491 }
2492 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2493 if (PyCallable_Check(func)) {
2494 self->Connect(id, lastId, eventType,
2495 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2496 new wxPyCallback(func));
2497 }
2498 else if (func == Py_None) {
2499 self->Disconnect(id, lastId, eventType,
2500 (wxObjectEventFunction)
2501 &wxPyCallback::EventThunker);
2502 }
2503 else {
2504 wxPyBLOCK_THREADS(
2505 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2506 }
2507 }
2508 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2509 return self->Disconnect(id, lastId, eventType,
2510 (wxObjectEventFunction)
2511 &wxPyCallback::EventThunker);
2512 }
2513 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2514 if (_self && _self != Py_None) {
2515 self->SetClientObject(new wxPyOORClientData(_self, incref));
2516 }
2517 else {
2518 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2519 if (data) {
2520 self->SetClientObject(NULL); // This will delete it too
2521 }
2522 }
2523 }
2524
2525 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2526 #if wxUSE_UNICODE
2527 return self->GetUnicodeKey();
2528 #else
2529 return 0;
2530 #endif
2531 }
2532
2533 #if UINT_MAX < LONG_MAX
2534 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_long
2536 /*@@*/
2537 #else
2538 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2539 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2540 /*@@*/
2541 #endif
2542
2543
2544 #if UINT_MAX != ULONG_MAX
2545 SWIGINTERN int
2546 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2547 {
2548 const char* errmsg = val ? "unsigned int" : (char*)0;
2549 unsigned long v;
2550 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2551 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2552 if (val) *val = (unsigned int)(v);
2553 return 1;
2554 }
2555 } else {
2556 PyErr_Clear();
2557 }
2558 if (val) {
2559 SWIG_type_error(errmsg, obj);
2560 }
2561 return 0;
2562 }
2563 #else
2564 SWIGINTERNSHORT unsigned int
2565 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2566 {
2567 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2568 }
2569 #endif
2570
2571
2572 SWIGINTERNSHORT unsigned int
2573 SWIG_As_unsigned_SS_int(PyObject* obj)
2574 {
2575 unsigned int v;
2576 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2577 /*
2578 this is needed to make valgrind/purify happier.
2579 */
2580 memset((void*)&v, 0, sizeof(unsigned int));
2581 }
2582 return v;
2583 }
2584
2585
2586 SWIGINTERNSHORT int
2587 SWIG_Check_unsigned_SS_int(PyObject* obj)
2588 {
2589 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2590 }
2591
2592 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2593 self->m_size = size;
2594 }
2595 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2596 int count = self->GetNumberOfFiles();
2597 wxString* files = self->GetFiles();
2598 PyObject* list = PyList_New(count);
2599
2600 if (!list) {
2601 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2602 return NULL;
2603 }
2604
2605 for (int i=0; i<count; i++) {
2606 PyList_SetItem(list, i, wx2PyString(files[i]));
2607 }
2608 return list;
2609 }
2610
2611
2612 static wxPyApp *new_wxPyApp(){
2613 wxPythonApp = new wxPyApp();
2614 return wxPythonApp;
2615 }
2616
2617 void wxApp_CleanUp() {
2618 __wxPyCleanup();
2619 }
2620
2621
2622 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2623
2624
2625 SWIGINTERNSHORT int
2626 SWIG_AsCharPtr(PyObject *obj, char **val)
2627 {
2628 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2629 return 1;
2630 }
2631 if (val) {
2632 PyErr_Clear();
2633 SWIG_type_error("char *", obj);
2634 }
2635 return 0;
2636 }
2637
2638
2639 SWIGINTERN PyObject *
2640 SWIG_FromCharPtr(const char* cptr)
2641 {
2642 if (cptr) {
2643 size_t size = strlen(cptr);
2644 if (size > INT_MAX) {
2645 return SWIG_NewPointerObj((char*)(cptr),
2646 SWIG_TypeQuery("char *"), 0);
2647 } else {
2648 if (size != 0) {
2649 return PyString_FromStringAndSize(cptr, size);
2650 } else {
2651 return PyString_FromString(cptr);
2652 }
2653 }
2654 }
2655 Py_INCREF(Py_None);
2656 return Py_None;
2657 }
2658
2659
2660 #ifdef __WXMAC__
2661
2662 // A dummy class that raises an exception if used...
2663 class wxEventLoop
2664 {
2665 public:
2666 wxEventLoop() { wxPyRaiseNotImplemented(); }
2667 int Run() { return 0; }
2668 void Exit(int rc = 0) {}
2669 bool Pending() const { return false; }
2670 bool Dispatch() { return false; }
2671 bool IsRunning() const { return false; }
2672 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2673 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2674 };
2675
2676 #else
2677
2678 #include <wx/evtloop.h>
2679
2680 #endif
2681
2682
2683
2684 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2685 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2686 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2687 static PyObject *wxWindow_GetChildren(wxWindow *self){
2688 wxWindowList& list = self->GetChildren();
2689 return wxPy_ConvertList(&list);
2690 }
2691 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2692 #if wxUSE_HOTKEY
2693 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2694 #else
2695 return false;
2696 #endif
2697 }
2698 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2699
2700
2701
2702 return false;
2703
2704 }
2705 static long wxWindow_GetHandle(wxWindow *self){
2706 return wxPyGetWinHandle(self);
2707 }
2708 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2709 self->AssociateHandle((WXWidget)handle);
2710 }
2711
2712 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2713 return wxWindow::FindWindowById(id, parent);
2714 }
2715
2716 wxWindow* wxFindWindowByName( const wxString& name,
2717 const wxWindow *parent = NULL ) {
2718 return wxWindow::FindWindowByName(name, parent);
2719 }
2720
2721 wxWindow* wxFindWindowByLabel( const wxString& label,
2722 const wxWindow *parent = NULL ) {
2723 return wxWindow::FindWindowByLabel(label, parent);
2724 }
2725
2726
2727 #ifdef __WXMSW__
2728 #include <wx/msw/private.h> // to get wxGetWindowId
2729 #endif
2730
2731
2732 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2733 #ifdef __WXMSW__
2734 WXHWND hWnd = (WXHWND)_hWnd;
2735 long id = wxGetWindowId(hWnd);
2736 wxWindow* win = new wxWindow;
2737 parent->AddChild(win);
2738 win->SetEventHandler(win);
2739 win->SetHWND(hWnd);
2740 win->SetId(id);
2741 win->SubclassWin(hWnd);
2742 win->AdoptAttributesFromHWND();
2743 win->SetupColours();
2744 return win;
2745 #else
2746 wxPyRaiseNotImplemented();
2747 return NULL;
2748 #endif
2749 }
2750
2751
2752 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2755
2756 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2757
2758 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2759 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2760 wxMenuItemList& list = self->GetMenuItems();
2761 return wxPy_ConvertList(&list);
2762 }
2763 static const wxString wxPyControlNameStr(wxControlNameStr);
2764 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2765 if (clientData) {
2766 wxPyClientData* data = new wxPyClientData(clientData);
2767 return self->Append(item, data);
2768 } else
2769 return self->Append(item);
2770 }
2771 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2772 if (clientData) {
2773 wxPyClientData* data = new wxPyClientData(clientData);
2774 return self->Insert(item, pos, data);
2775 } else
2776 return self->Insert(item, pos);
2777 }
2778 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2779 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2780 if (data) {
2781 Py_INCREF(data->m_obj);
2782 return data->m_obj;
2783 } else {
2784 Py_INCREF(Py_None);
2785 return Py_None;
2786 }
2787 }
2788 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2789 wxPyClientData* data = new wxPyClientData(clientData);
2790 self->SetClientObject(n, data);
2791 }
2792
2793
2794 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2795 wxPyUserData* data = NULL;
2796 if ( userData ) {
2797 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2798 data = new wxPyUserData(userData);
2799 wxPyEndBlockThreads(blocked);
2800 }
2801 return new wxSizerItem(window, proportion, flag, border, data);
2802 }
2803 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2804 wxPyUserData* data = NULL;
2805 if ( userData ) {
2806 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2807 data = new wxPyUserData(userData);
2808 wxPyEndBlockThreads(blocked);
2809 }
2810 return new wxSizerItem(width, height, proportion, flag, border, data);
2811 }
2812 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2813 wxPyUserData* data = NULL;
2814 if ( userData ) {
2815 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2816 data = new wxPyUserData(userData);
2817 wxPyEndBlockThreads(blocked);
2818 }
2819 return new wxSizerItem(sizer, proportion, flag, border, data);
2820 }
2821
2822 #include <float.h>
2823 SWIGINTERN int
2824 SWIG_CheckDoubleInRange(double value, double min_value,
2825 double max_value, const char* errmsg)
2826 {
2827 if (value < min_value) {
2828 if (errmsg) {
2829 PyErr_Format(PyExc_OverflowError,
2830 "value %g is less than %s minimum %g",
2831 value, errmsg, min_value);
2832 }
2833 return 0;
2834 } else if (value > max_value) {
2835 if (errmsg) {
2836 PyErr_Format(PyExc_OverflowError,
2837 "value %g is greater than %s maximum %g",
2838 value, errmsg, max_value);
2839 }
2840 return 0;
2841 }
2842 return 1;
2843 }
2844
2845
2846 SWIGINTERN int
2847 SWIG_AsVal_float(PyObject *obj, float *val)
2848 {
2849 const char* errmsg = val ? "float" : (char*)0;
2850 double v;
2851 if (SWIG_AsVal_double(obj, &v)) {
2852 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2853 if (val) *val = (float)(v);
2854 return 1;
2855 } else {
2856 return 0;
2857 }
2858 } else {
2859 PyErr_Clear();
2860 }
2861 if (val) {
2862 SWIG_type_error(errmsg, obj);
2863 }
2864 return 0;
2865 }
2866
2867
2868 SWIGINTERNSHORT float
2869 SWIG_As_float(PyObject* obj)
2870 {
2871 float v;
2872 if (!SWIG_AsVal_float(obj, &v)) {
2873 /*
2874 this is needed to make valgrind/purify happier.
2875 */
2876 memset((void*)&v, 0, sizeof(float));
2877 }
2878 return v;
2879 }
2880
2881
2882 SWIGINTERNSHORT int
2883 SWIG_Check_float(PyObject* obj)
2884 {
2885 return SWIG_AsVal_float(obj, (float*)0);
2886 }
2887
2888
2889 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2890 #define SWIG_From_float PyFloat_FromDouble
2891 /*@@*/
2892
2893 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2894 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2895 if (data) {
2896 Py_INCREF(data->m_obj);
2897 return data->m_obj;
2898 } else {
2899 Py_INCREF(Py_None);
2900 return Py_None;
2901 }
2902 }
2903
2904 // Figure out the type of the sizer item
2905
2906 struct wxPySizerItemInfo {
2907 wxPySizerItemInfo()
2908 : window(NULL), sizer(NULL), gotSize(false),
2909 size(wxDefaultSize), gotPos(false), pos(-1)
2910 {}
2911
2912 wxWindow* window;
2913 wxSizer* sizer;
2914 bool gotSize;
2915 wxSize size;
2916 bool gotPos;
2917 int pos;
2918 };
2919
2920 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2921
2922 wxPySizerItemInfo info;
2923 wxSize size;
2924 wxSize* sizePtr = &size;
2925
2926 // Find out what the type of the item is
2927 // try wxWindow
2928 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2929 PyErr_Clear();
2930 info.window = NULL;
2931
2932 // try wxSizer
2933 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2934 PyErr_Clear();
2935 info.sizer = NULL;
2936
2937 // try wxSize or (w,h)
2938 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2939 info.size = *sizePtr;
2940 info.gotSize = true;
2941 }
2942
2943 // or a single int
2944 if (checkIdx && PyInt_Check(item)) {
2945 info.pos = PyInt_AsLong(item);
2946 info.gotPos = true;
2947 }
2948 }
2949 }
2950
2951 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2952 // no expected type, figure out what kind of error message to generate
2953 if ( !checkSize && !checkIdx )
2954 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2955 else if ( checkSize && !checkIdx )
2956 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2957 else if ( !checkSize && checkIdx)
2958 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2959 else
2960 // can this one happen?
2961 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2962 }
2963
2964 return info;
2965 }
2966
2967 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2968 if (!self->GetClientObject())
2969 self->SetClientObject(new wxPyOORClientData(_self));
2970 }
2971 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2972
2973 wxPyUserData* data = NULL;
2974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2975 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2976 if ( userData && (info.window || info.sizer || info.gotSize) )
2977 data = new wxPyUserData(userData);
2978 wxPyEndBlockThreads(blocked);
2979
2980 // Now call the real Add method if a valid item type was found
2981 if ( info.window )
2982 return self->Add(info.window, proportion, flag, border, data);
2983 else if ( info.sizer )
2984 return self->Add(info.sizer, proportion, flag, border, data);
2985 else if (info.gotSize)
2986 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2987 proportion, flag, border, data);
2988 else
2989 return NULL;
2990 }
2991 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2992
2993 wxPyUserData* data = NULL;
2994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2995 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2996 if ( userData && (info.window || info.sizer || info.gotSize) )
2997 data = new wxPyUserData(userData);
2998 wxPyEndBlockThreads(blocked);
2999
3000 // Now call the real Insert method if a valid item type was found
3001 if ( info.window )
3002 return self->Insert(before, info.window, proportion, flag, border, data);
3003 else if ( info.sizer )
3004 return self->Insert(before, info.sizer, proportion, flag, border, data);
3005 else if (info.gotSize)
3006 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3007 proportion, flag, border, data);
3008 else
3009 return NULL;
3010 }
3011 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3012
3013 wxPyUserData* data = NULL;
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3016 if ( userData && (info.window || info.sizer || info.gotSize) )
3017 data = new wxPyUserData(userData);
3018 wxPyEndBlockThreads(blocked);
3019
3020 // Now call the real Prepend method if a valid item type was found
3021 if ( info.window )
3022 return self->Prepend(info.window, proportion, flag, border, data);
3023 else if ( info.sizer )
3024 return self->Prepend(info.sizer, proportion, flag, border, data);
3025 else if (info.gotSize)
3026 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3027 proportion, flag, border, data);
3028 else
3029 return NULL;
3030 }
3031 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3033 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3034 wxPyEndBlockThreads(blocked);
3035 if ( info.window )
3036 return self->Remove(info.window);
3037 else if ( info.sizer )
3038 return self->Remove(info.sizer);
3039 else if ( info.gotPos )
3040 return self->Remove(info.pos);
3041 else
3042 return false;
3043 }
3044 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3046 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3047 wxPyEndBlockThreads(blocked);
3048 if ( info.window )
3049 return self->Detach(info.window);
3050 else if ( info.sizer )
3051 return self->Detach(info.sizer);
3052 else if ( info.gotPos )
3053 return self->Detach(info.pos);
3054 else
3055 return false;
3056 }
3057 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3058 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3059 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3060 wxPyEndBlockThreads(blocked);
3061 if ( info.window )
3062 return self->GetItem(info.window);
3063 else if ( info.sizer )
3064 return self->GetItem(info.sizer);
3065 else if ( info.gotPos )
3066 return self->GetItem(info.pos);
3067 else
3068 return NULL;
3069 }
3070 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3072 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3073 wxPyEndBlockThreads(blocked);
3074 if ( info.window )
3075 self->SetItemMinSize(info.window, size);
3076 else if ( info.sizer )
3077 self->SetItemMinSize(info.sizer, size);
3078 else if ( info.gotPos )
3079 self->SetItemMinSize(info.pos, size);
3080 }
3081 static PyObject *wxSizer_GetChildren(wxSizer *self){
3082 wxSizerItemList& list = self->GetChildren();
3083 return wxPy_ConvertList(&list);
3084 }
3085 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3086 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3088 wxPyEndBlockThreads(blocked);
3089 if ( info.window )
3090 return self->Show(info.window, show, recursive);
3091 else if ( info.sizer )
3092 return self->Show(info.sizer, show, recursive);
3093 else if ( info.gotPos )
3094 return self->Show(info.pos, show);
3095 else
3096 return false;
3097 }
3098 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3099 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3100 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3101 wxPyEndBlockThreads(blocked);
3102 if ( info.window )
3103 return self->IsShown(info.window);
3104 else if ( info.sizer )
3105 return self->IsShown(info.sizer);
3106 else if ( info.gotPos )
3107 return self->IsShown(info.pos);
3108 else
3109 return false;
3110 }
3111
3112 // See pyclasses.h
3113 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3114 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3115 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3116
3117
3118
3119
3120 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3121 {
3122 if (source == Py_None) {
3123 **obj = wxGBPosition(-1,-1);
3124 return true;
3125 }
3126 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3127 }
3128
3129 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3130 {
3131 if (source == Py_None) {
3132 **obj = wxGBSpan(-1,-1);
3133 return true;
3134 }
3135 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3136 }
3137
3138
3139 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3140 self->SetRow(row);
3141 self->SetCol(col);
3142 }
3143 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3145 PyObject* tup = PyTuple_New(2);
3146 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3147 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3148 wxPyEndBlockThreads(blocked);
3149 return tup;
3150 }
3151 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3152 self->SetRowspan(rowspan);
3153 self->SetColspan(colspan);
3154 }
3155 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3157 PyObject* tup = PyTuple_New(2);
3158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3160 wxPyEndBlockThreads(blocked);
3161 return tup;
3162 }
3163 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3164 wxPyUserData* data = NULL;
3165 if ( userData ) {
3166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3167 data = new wxPyUserData(userData);
3168 wxPyEndBlockThreads(blocked);
3169 }
3170 return new wxGBSizerItem(window, pos, span, flag, border, data);
3171 }
3172 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3173 wxPyUserData* data = NULL;
3174 if ( userData ) {
3175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3176 data = new wxPyUserData(userData);
3177 wxPyEndBlockThreads(blocked);
3178 }
3179 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3180 }
3181 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3182 wxPyUserData* data = NULL;
3183 if ( userData ) {
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 data = new wxPyUserData(userData);
3186 wxPyEndBlockThreads(blocked);
3187 }
3188 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3189 }
3190 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3191 int row, col;
3192 self->GetEndPos(row, col);
3193 return wxGBPosition(row, col);
3194 }
3195 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3196
3197 wxPyUserData* data = NULL;
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3200 if ( userData && (info.window || info.sizer || info.gotSize) )
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203
3204 // Now call the real Add method if a valid item type was found
3205 if ( info.window )
3206 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3207 else if ( info.sizer )
3208 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3209 else if (info.gotSize)
3210 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3211 pos, span, flag, border, data);
3212 return NULL;
3213 }
3214
3215
3216 #ifdef __cplusplus
3217 extern "C" {
3218 #endif
3219 static int _wrap_EmptyString_set(PyObject *) {
3220 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3221 return 1;
3222 }
3223
3224
3225 static PyObject *_wrap_EmptyString_get(void) {
3226 PyObject *pyobj;
3227
3228 {
3229 #if wxUSE_UNICODE
3230 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3231 #else
3232 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3233 #endif
3234 }
3235 return pyobj;
3236 }
3237
3238
3239 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxObject *arg1 = (wxObject *) 0 ;
3242 wxString result;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "self", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3250 if (SWIG_arg_fail(1)) SWIG_fail;
3251 {
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 result = wxObject_GetClassName(arg1);
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 {
3259 #if wxUSE_UNICODE
3260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3261 #else
3262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3263 #endif
3264 }
3265 return resultobj;
3266 fail:
3267 return NULL;
3268 }
3269
3270
3271 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 PyObject * obj0 = 0 ;
3275 char *kwnames[] = {
3276 (char *) "self", NULL
3277 };
3278
3279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3281 if (SWIG_arg_fail(1)) SWIG_fail;
3282 {
3283 PyThreadState* __tstate = wxPyBeginAllowThreads();
3284 wxObject_Destroy(arg1);
3285
3286 wxPyEndAllowThreads(__tstate);
3287 if (PyErr_Occurred()) SWIG_fail;
3288 }
3289 Py_INCREF(Py_None); resultobj = Py_None;
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
3296 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3297 PyObject *obj;
3298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3299 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3300 Py_INCREF(obj);
3301 return Py_BuildValue((char *)"");
3302 }
3303 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxSize *arg1 = (wxSize *) 0 ;
3306 int arg2 ;
3307 PyObject * obj0 = 0 ;
3308 PyObject * obj1 = 0 ;
3309 char *kwnames[] = {
3310 (char *) "self",(char *) "x", NULL
3311 };
3312
3313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3315 if (SWIG_arg_fail(1)) SWIG_fail;
3316 {
3317 arg2 = (int)(SWIG_As_int(obj1));
3318 if (SWIG_arg_fail(2)) SWIG_fail;
3319 }
3320 if (arg1) (arg1)->x = arg2;
3321
3322 Py_INCREF(Py_None); resultobj = Py_None;
3323 return resultobj;
3324 fail:
3325 return NULL;
3326 }
3327
3328
3329 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3330 PyObject *resultobj;
3331 wxSize *arg1 = (wxSize *) 0 ;
3332 int result;
3333 PyObject * obj0 = 0 ;
3334 char *kwnames[] = {
3335 (char *) "self", NULL
3336 };
3337
3338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3340 if (SWIG_arg_fail(1)) SWIG_fail;
3341 result = (int) ((arg1)->x);
3342
3343 {
3344 resultobj = SWIG_From_int((int)(result));
3345 }
3346 return resultobj;
3347 fail:
3348 return NULL;
3349 }
3350
3351
3352 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3353 PyObject *resultobj;
3354 wxSize *arg1 = (wxSize *) 0 ;
3355 int arg2 ;
3356 PyObject * obj0 = 0 ;
3357 PyObject * obj1 = 0 ;
3358 char *kwnames[] = {
3359 (char *) "self",(char *) "y", NULL
3360 };
3361
3362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3364 if (SWIG_arg_fail(1)) SWIG_fail;
3365 {
3366 arg2 = (int)(SWIG_As_int(obj1));
3367 if (SWIG_arg_fail(2)) SWIG_fail;
3368 }
3369 if (arg1) (arg1)->y = arg2;
3370
3371 Py_INCREF(Py_None); resultobj = Py_None;
3372 return resultobj;
3373 fail:
3374 return NULL;
3375 }
3376
3377
3378 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3379 PyObject *resultobj;
3380 wxSize *arg1 = (wxSize *) 0 ;
3381 int result;
3382 PyObject * obj0 = 0 ;
3383 char *kwnames[] = {
3384 (char *) "self", NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3389 if (SWIG_arg_fail(1)) SWIG_fail;
3390 result = (int) ((arg1)->y);
3391
3392 {
3393 resultobj = SWIG_From_int((int)(result));
3394 }
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 int arg1 = (int) 0 ;
3404 int arg2 = (int) 0 ;
3405 wxSize *result;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "w",(char *) "h", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3413 if (obj0) {
3414 {
3415 arg1 = (int)(SWIG_As_int(obj0));
3416 if (SWIG_arg_fail(1)) SWIG_fail;
3417 }
3418 }
3419 if (obj1) {
3420 {
3421 arg2 = (int)(SWIG_As_int(obj1));
3422 if (SWIG_arg_fail(2)) SWIG_fail;
3423 }
3424 }
3425 {
3426 PyThreadState* __tstate = wxPyBeginAllowThreads();
3427 result = (wxSize *)new wxSize(arg1,arg2);
3428
3429 wxPyEndAllowThreads(__tstate);
3430 if (PyErr_Occurred()) SWIG_fail;
3431 }
3432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3433 return resultobj;
3434 fail:
3435 return NULL;
3436 }
3437
3438
3439 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3440 PyObject *resultobj;
3441 wxSize *arg1 = (wxSize *) 0 ;
3442 PyObject * obj0 = 0 ;
3443 char *kwnames[] = {
3444 (char *) "self", NULL
3445 };
3446
3447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3449 if (SWIG_arg_fail(1)) SWIG_fail;
3450 {
3451 PyThreadState* __tstate = wxPyBeginAllowThreads();
3452 delete arg1;
3453
3454 wxPyEndAllowThreads(__tstate);
3455 if (PyErr_Occurred()) SWIG_fail;
3456 }
3457 Py_INCREF(Py_None); resultobj = Py_None;
3458 return resultobj;
3459 fail:
3460 return NULL;
3461 }
3462
3463
3464 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3465 PyObject *resultobj;
3466 wxSize *arg1 = (wxSize *) 0 ;
3467 wxSize *arg2 = 0 ;
3468 bool result;
3469 wxSize temp2 ;
3470 PyObject * obj0 = 0 ;
3471 PyObject * obj1 = 0 ;
3472 char *kwnames[] = {
3473 (char *) "self",(char *) "sz", NULL
3474 };
3475
3476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3478 if (SWIG_arg_fail(1)) SWIG_fail;
3479 {
3480 arg2 = &temp2;
3481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3482 }
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 {
3491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3492 }
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 wxSize *arg1 = (wxSize *) 0 ;
3502 wxSize *arg2 = 0 ;
3503 bool result;
3504 wxSize temp2 ;
3505 PyObject * obj0 = 0 ;
3506 PyObject * obj1 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "self",(char *) "sz", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3513 if (SWIG_arg_fail(1)) SWIG_fail;
3514 {
3515 arg2 = &temp2;
3516 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3517 }
3518 {
3519 PyThreadState* __tstate = wxPyBeginAllowThreads();
3520 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3521
3522 wxPyEndAllowThreads(__tstate);
3523 if (PyErr_Occurred()) SWIG_fail;
3524 }
3525 {
3526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3527 }
3528 return resultobj;
3529 fail:
3530 return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3535 PyObject *resultobj;
3536 wxSize *arg1 = (wxSize *) 0 ;
3537 wxSize *arg2 = 0 ;
3538 wxSize result;
3539 wxSize temp2 ;
3540 PyObject * obj0 = 0 ;
3541 PyObject * obj1 = 0 ;
3542 char *kwnames[] = {
3543 (char *) "self",(char *) "sz", NULL
3544 };
3545
3546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 {
3550 arg2 = &temp2;
3551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3552 }
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (arg1)->operator +((wxSize const &)*arg2);
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 wxSize * resultptr;
3562 resultptr = new wxSize((wxSize &)(result));
3563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 wxSize *arg1 = (wxSize *) 0 ;
3574 wxSize *arg2 = 0 ;
3575 wxSize result;
3576 wxSize temp2 ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "self",(char *) "sz", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 {
3587 arg2 = &temp2;
3588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (arg1)->operator -((wxSize const &)*arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 wxSize * resultptr;
3599 resultptr = new wxSize((wxSize &)(result));
3600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3601 }
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 wxSize *arg1 = (wxSize *) 0 ;
3611 wxSize *arg2 = 0 ;
3612 wxSize temp2 ;
3613 PyObject * obj0 = 0 ;
3614 PyObject * obj1 = 0 ;
3615 char *kwnames[] = {
3616 (char *) "self",(char *) "sz", NULL
3617 };
3618
3619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3621 if (SWIG_arg_fail(1)) SWIG_fail;
3622 {
3623 arg2 = &temp2;
3624 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3625 }
3626 {
3627 PyThreadState* __tstate = wxPyBeginAllowThreads();
3628 (arg1)->IncTo((wxSize const &)*arg2);
3629
3630 wxPyEndAllowThreads(__tstate);
3631 if (PyErr_Occurred()) SWIG_fail;
3632 }
3633 Py_INCREF(Py_None); resultobj = Py_None;
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_Size_DecTo(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:Size_DecTo",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)->DecTo((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_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 int arg2 ;
3676 int arg3 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 PyObject * obj2 = 0 ;
3680 char *kwnames[] = {
3681 (char *) "self",(char *) "w",(char *) "h", NULL
3682 };
3683
3684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 {
3688 arg2 = (int)(SWIG_As_int(obj1));
3689 if (SWIG_arg_fail(2)) SWIG_fail;
3690 }
3691 {
3692 arg3 = (int)(SWIG_As_int(obj2));
3693 if (SWIG_arg_fail(3)) SWIG_fail;
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 (arg1)->Set(arg2,arg3);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 Py_INCREF(Py_None); resultobj = Py_None;
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 wxSize *arg1 = (wxSize *) 0 ;
3712 int arg2 ;
3713 PyObject * obj0 = 0 ;
3714 PyObject * obj1 = 0 ;
3715 char *kwnames[] = {
3716 (char *) "self",(char *) "w", NULL
3717 };
3718
3719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3721 if (SWIG_arg_fail(1)) SWIG_fail;
3722 {
3723 arg2 = (int)(SWIG_As_int(obj1));
3724 if (SWIG_arg_fail(2)) SWIG_fail;
3725 }
3726 {
3727 PyThreadState* __tstate = wxPyBeginAllowThreads();
3728 (arg1)->SetWidth(arg2);
3729
3730 wxPyEndAllowThreads(__tstate);
3731 if (PyErr_Occurred()) SWIG_fail;
3732 }
3733 Py_INCREF(Py_None); resultobj = Py_None;
3734 return resultobj;
3735 fail:
3736 return NULL;
3737 }
3738
3739
3740 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3741 PyObject *resultobj;
3742 wxSize *arg1 = (wxSize *) 0 ;
3743 int arg2 ;
3744 PyObject * obj0 = 0 ;
3745 PyObject * obj1 = 0 ;
3746 char *kwnames[] = {
3747 (char *) "self",(char *) "h", NULL
3748 };
3749
3750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3752 if (SWIG_arg_fail(1)) SWIG_fail;
3753 {
3754 arg2 = (int)(SWIG_As_int(obj1));
3755 if (SWIG_arg_fail(2)) SWIG_fail;
3756 }
3757 {
3758 PyThreadState* __tstate = wxPyBeginAllowThreads();
3759 (arg1)->SetHeight(arg2);
3760
3761 wxPyEndAllowThreads(__tstate);
3762 if (PyErr_Occurred()) SWIG_fail;
3763 }
3764 Py_INCREF(Py_None); resultobj = Py_None;
3765 return resultobj;
3766 fail:
3767 return NULL;
3768 }
3769
3770
3771 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3772 PyObject *resultobj;
3773 wxSize *arg1 = (wxSize *) 0 ;
3774 int result;
3775 PyObject * obj0 = 0 ;
3776 char *kwnames[] = {
3777 (char *) "self", NULL
3778 };
3779
3780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3782 if (SWIG_arg_fail(1)) SWIG_fail;
3783 {
3784 PyThreadState* __tstate = wxPyBeginAllowThreads();
3785 result = (int)((wxSize const *)arg1)->GetWidth();
3786
3787 wxPyEndAllowThreads(__tstate);
3788 if (PyErr_Occurred()) SWIG_fail;
3789 }
3790 {
3791 resultobj = SWIG_From_int((int)(result));
3792 }
3793 return resultobj;
3794 fail:
3795 return NULL;
3796 }
3797
3798
3799 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3800 PyObject *resultobj;
3801 wxSize *arg1 = (wxSize *) 0 ;
3802 int result;
3803 PyObject * obj0 = 0 ;
3804 char *kwnames[] = {
3805 (char *) "self", NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3810 if (SWIG_arg_fail(1)) SWIG_fail;
3811 {
3812 PyThreadState* __tstate = wxPyBeginAllowThreads();
3813 result = (int)((wxSize const *)arg1)->GetHeight();
3814
3815 wxPyEndAllowThreads(__tstate);
3816 if (PyErr_Occurred()) SWIG_fail;
3817 }
3818 {
3819 resultobj = SWIG_From_int((int)(result));
3820 }
3821 return resultobj;
3822 fail:
3823 return NULL;
3824 }
3825
3826
3827 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3828 PyObject *resultobj;
3829 wxSize *arg1 = (wxSize *) 0 ;
3830 bool result;
3831 PyObject * obj0 = 0 ;
3832 char *kwnames[] = {
3833 (char *) "self", NULL
3834 };
3835
3836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3838 if (SWIG_arg_fail(1)) SWIG_fail;
3839 {
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 {
3847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3848 }
3849 return resultobj;
3850 fail:
3851 return NULL;
3852 }
3853
3854
3855 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3856 PyObject *resultobj;
3857 wxSize *arg1 = (wxSize *) 0 ;
3858 wxSize *arg2 = 0 ;
3859 wxSize temp2 ;
3860 PyObject * obj0 = 0 ;
3861 PyObject * obj1 = 0 ;
3862 char *kwnames[] = {
3863 (char *) "self",(char *) "size", NULL
3864 };
3865
3866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3868 if (SWIG_arg_fail(1)) SWIG_fail;
3869 {
3870 arg2 = &temp2;
3871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3872 }
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 (arg1)->SetDefaults((wxSize const &)*arg2);
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 Py_INCREF(Py_None); resultobj = Py_None;
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 PyObject *result;
3891 PyObject * obj0 = 0 ;
3892 char *kwnames[] = {
3893 (char *) "self", NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3898 if (SWIG_arg_fail(1)) SWIG_fail;
3899 {
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 result = (PyObject *)wxSize_Get(arg1);
3902
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 resultobj = result;
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3914 PyObject *obj;
3915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3916 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3917 Py_INCREF(obj);
3918 return Py_BuildValue((char *)"");
3919 }
3920 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3921 PyObject *resultobj;
3922 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3923 double arg2 ;
3924 PyObject * obj0 = 0 ;
3925 PyObject * obj1 = 0 ;
3926 char *kwnames[] = {
3927 (char *) "self",(char *) "x", NULL
3928 };
3929
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3932 if (SWIG_arg_fail(1)) SWIG_fail;
3933 {
3934 arg2 = (double)(SWIG_As_double(obj1));
3935 if (SWIG_arg_fail(2)) SWIG_fail;
3936 }
3937 if (arg1) (arg1)->x = arg2;
3938
3939 Py_INCREF(Py_None); resultobj = Py_None;
3940 return resultobj;
3941 fail:
3942 return NULL;
3943 }
3944
3945
3946 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3947 PyObject *resultobj;
3948 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3949 double result;
3950 PyObject * obj0 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "self", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3957 if (SWIG_arg_fail(1)) SWIG_fail;
3958 result = (double) ((arg1)->x);
3959
3960 {
3961 resultobj = SWIG_From_double((double)(result));
3962 }
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3972 double arg2 ;
3973 PyObject * obj0 = 0 ;
3974 PyObject * obj1 = 0 ;
3975 char *kwnames[] = {
3976 (char *) "self",(char *) "y", NULL
3977 };
3978
3979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3981 if (SWIG_arg_fail(1)) SWIG_fail;
3982 {
3983 arg2 = (double)(SWIG_As_double(obj1));
3984 if (SWIG_arg_fail(2)) SWIG_fail;
3985 }
3986 if (arg1) (arg1)->y = arg2;
3987
3988 Py_INCREF(Py_None); resultobj = Py_None;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3998 double result;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 result = (double) ((arg1)->y);
4008
4009 {
4010 resultobj = SWIG_From_double((double)(result));
4011 }
4012 return resultobj;
4013 fail:
4014 return NULL;
4015 }
4016
4017
4018 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4019 PyObject *resultobj;
4020 double arg1 = (double) 0.0 ;
4021 double arg2 = (double) 0.0 ;
4022 wxRealPoint *result;
4023 PyObject * obj0 = 0 ;
4024 PyObject * obj1 = 0 ;
4025 char *kwnames[] = {
4026 (char *) "x",(char *) "y", NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4030 if (obj0) {
4031 {
4032 arg1 = (double)(SWIG_As_double(obj0));
4033 if (SWIG_arg_fail(1)) SWIG_fail;
4034 }
4035 }
4036 if (obj1) {
4037 {
4038 arg2 = (double)(SWIG_As_double(obj1));
4039 if (SWIG_arg_fail(2)) SWIG_fail;
4040 }
4041 }
4042 {
4043 PyThreadState* __tstate = wxPyBeginAllowThreads();
4044 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4045
4046 wxPyEndAllowThreads(__tstate);
4047 if (PyErr_Occurred()) SWIG_fail;
4048 }
4049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4050 return resultobj;
4051 fail:
4052 return NULL;
4053 }
4054
4055
4056 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4057 PyObject *resultobj;
4058 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4059 PyObject * obj0 = 0 ;
4060 char *kwnames[] = {
4061 (char *) "self", NULL
4062 };
4063
4064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 delete arg1;
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 Py_INCREF(Py_None); resultobj = Py_None;
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4084 wxRealPoint *arg2 = 0 ;
4085 bool result;
4086 wxRealPoint temp2 ;
4087 PyObject * obj0 = 0 ;
4088 PyObject * obj1 = 0 ;
4089 char *kwnames[] = {
4090 (char *) "self",(char *) "pt", NULL
4091 };
4092
4093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4095 if (SWIG_arg_fail(1)) SWIG_fail;
4096 {
4097 arg2 = &temp2;
4098 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4099 }
4100 {
4101 PyThreadState* __tstate = wxPyBeginAllowThreads();
4102 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4103
4104 wxPyEndAllowThreads(__tstate);
4105 if (PyErr_Occurred()) SWIG_fail;
4106 }
4107 {
4108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4109 }
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj;
4118 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4119 wxRealPoint *arg2 = 0 ;
4120 bool result;
4121 wxRealPoint temp2 ;
4122 PyObject * obj0 = 0 ;
4123 PyObject * obj1 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "self",(char *) "pt", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4130 if (SWIG_arg_fail(1)) SWIG_fail;
4131 {
4132 arg2 = &temp2;
4133 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4134 }
4135 {
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4138
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 {
4143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4144 }
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4154 wxRealPoint *arg2 = 0 ;
4155 wxRealPoint result;
4156 wxRealPoint temp2 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "self",(char *) "pt", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4165 if (SWIG_arg_fail(1)) SWIG_fail;
4166 {
4167 arg2 = &temp2;
4168 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 wxRealPoint * resultptr;
4179 resultptr = new wxRealPoint((wxRealPoint &)(result));
4180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4191 wxRealPoint *arg2 = 0 ;
4192 wxRealPoint result;
4193 wxRealPoint temp2 ;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "self",(char *) "pt", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(1)) SWIG_fail;
4203 {
4204 arg2 = &temp2;
4205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 wxRealPoint * resultptr;
4216 resultptr = new wxRealPoint((wxRealPoint &)(result));
4217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4228 double arg2 ;
4229 double arg3 ;
4230 PyObject * obj0 = 0 ;
4231 PyObject * obj1 = 0 ;
4232 PyObject * obj2 = 0 ;
4233 char *kwnames[] = {
4234 (char *) "self",(char *) "x",(char *) "y", NULL
4235 };
4236
4237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4239 if (SWIG_arg_fail(1)) SWIG_fail;
4240 {
4241 arg2 = (double)(SWIG_As_double(obj1));
4242 if (SWIG_arg_fail(2)) SWIG_fail;
4243 }
4244 {
4245 arg3 = (double)(SWIG_As_double(obj2));
4246 if (SWIG_arg_fail(3)) SWIG_fail;
4247 }
4248 {
4249 PyThreadState* __tstate = wxPyBeginAllowThreads();
4250 wxRealPoint_Set(arg1,arg2,arg3);
4251
4252 wxPyEndAllowThreads(__tstate);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 Py_INCREF(Py_None); resultobj = Py_None;
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4265 PyObject *result;
4266 PyObject * obj0 = 0 ;
4267 char *kwnames[] = {
4268 (char *) "self", NULL
4269 };
4270
4271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4273 if (SWIG_arg_fail(1)) SWIG_fail;
4274 {
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 result = (PyObject *)wxRealPoint_Get(arg1);
4277
4278 wxPyEndAllowThreads(__tstate);
4279 if (PyErr_Occurred()) SWIG_fail;
4280 }
4281 resultobj = result;
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4289 PyObject *obj;
4290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4291 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4292 Py_INCREF(obj);
4293 return Py_BuildValue((char *)"");
4294 }
4295 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4296 PyObject *resultobj;
4297 wxPoint *arg1 = (wxPoint *) 0 ;
4298 int arg2 ;
4299 PyObject * obj0 = 0 ;
4300 PyObject * obj1 = 0 ;
4301 char *kwnames[] = {
4302 (char *) "self",(char *) "x", NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4307 if (SWIG_arg_fail(1)) SWIG_fail;
4308 {
4309 arg2 = (int)(SWIG_As_int(obj1));
4310 if (SWIG_arg_fail(2)) SWIG_fail;
4311 }
4312 if (arg1) (arg1)->x = arg2;
4313
4314 Py_INCREF(Py_None); resultobj = Py_None;
4315 return resultobj;
4316 fail:
4317 return NULL;
4318 }
4319
4320
4321 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4322 PyObject *resultobj;
4323 wxPoint *arg1 = (wxPoint *) 0 ;
4324 int result;
4325 PyObject * obj0 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "self", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4332 if (SWIG_arg_fail(1)) SWIG_fail;
4333 result = (int) ((arg1)->x);
4334
4335 {
4336 resultobj = SWIG_From_int((int)(result));
4337 }
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj;
4346 wxPoint *arg1 = (wxPoint *) 0 ;
4347 int arg2 ;
4348 PyObject * obj0 = 0 ;
4349 PyObject * obj1 = 0 ;
4350 char *kwnames[] = {
4351 (char *) "self",(char *) "y", NULL
4352 };
4353
4354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4356 if (SWIG_arg_fail(1)) SWIG_fail;
4357 {
4358 arg2 = (int)(SWIG_As_int(obj1));
4359 if (SWIG_arg_fail(2)) SWIG_fail;
4360 }
4361 if (arg1) (arg1)->y = arg2;
4362
4363 Py_INCREF(Py_None); resultobj = Py_None;
4364 return resultobj;
4365 fail:
4366 return NULL;
4367 }
4368
4369
4370 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj;
4372 wxPoint *arg1 = (wxPoint *) 0 ;
4373 int result;
4374 PyObject * obj0 = 0 ;
4375 char *kwnames[] = {
4376 (char *) "self", NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4381 if (SWIG_arg_fail(1)) SWIG_fail;
4382 result = (int) ((arg1)->y);
4383
4384 {
4385 resultobj = SWIG_From_int((int)(result));
4386 }
4387 return resultobj;
4388 fail:
4389 return NULL;
4390 }
4391
4392
4393 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4394 PyObject *resultobj;
4395 int arg1 = (int) 0 ;
4396 int arg2 = (int) 0 ;
4397 wxPoint *result;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "x",(char *) "y", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4405 if (obj0) {
4406 {
4407 arg1 = (int)(SWIG_As_int(obj0));
4408 if (SWIG_arg_fail(1)) SWIG_fail;
4409 }
4410 }
4411 if (obj1) {
4412 {
4413 arg2 = (int)(SWIG_As_int(obj1));
4414 if (SWIG_arg_fail(2)) SWIG_fail;
4415 }
4416 }
4417 {
4418 PyThreadState* __tstate = wxPyBeginAllowThreads();
4419 result = (wxPoint *)new wxPoint(arg1,arg2);
4420
4421 wxPyEndAllowThreads(__tstate);
4422 if (PyErr_Occurred()) SWIG_fail;
4423 }
4424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj;
4433 wxPoint *arg1 = (wxPoint *) 0 ;
4434 PyObject * obj0 = 0 ;
4435 char *kwnames[] = {
4436 (char *) "self", NULL
4437 };
4438
4439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4441 if (SWIG_arg_fail(1)) SWIG_fail;
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 delete arg1;
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 Py_INCREF(Py_None); resultobj = Py_None;
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj;
4458 wxPoint *arg1 = (wxPoint *) 0 ;
4459 wxPoint *arg2 = 0 ;
4460 bool result;
4461 wxPoint temp2 ;
4462 PyObject * obj0 = 0 ;
4463 PyObject * obj1 = 0 ;
4464 char *kwnames[] = {
4465 (char *) "self",(char *) "pt", NULL
4466 };
4467
4468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4470 if (SWIG_arg_fail(1)) SWIG_fail;
4471 {
4472 arg2 = &temp2;
4473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4474 }
4475 {
4476 PyThreadState* __tstate = wxPyBeginAllowThreads();
4477 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4478
4479 wxPyEndAllowThreads(__tstate);
4480 if (PyErr_Occurred()) SWIG_fail;
4481 }
4482 {
4483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4492 PyObject *resultobj;
4493 wxPoint *arg1 = (wxPoint *) 0 ;
4494 wxPoint *arg2 = 0 ;
4495 bool result;
4496 wxPoint temp2 ;
4497 PyObject * obj0 = 0 ;
4498 PyObject * obj1 = 0 ;
4499 char *kwnames[] = {
4500 (char *) "self",(char *) "pt", NULL
4501 };
4502
4503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4505 if (SWIG_arg_fail(1)) SWIG_fail;
4506 {
4507 arg2 = &temp2;
4508 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4509 }
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4513
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxPoint *arg1 = (wxPoint *) 0 ;
4529 wxPoint *arg2 = 0 ;
4530 wxPoint result;
4531 wxPoint temp2 ;
4532 PyObject * obj0 = 0 ;
4533 PyObject * obj1 = 0 ;
4534 char *kwnames[] = {
4535 (char *) "self",(char *) "pt", NULL
4536 };
4537
4538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4540 if (SWIG_arg_fail(1)) SWIG_fail;
4541 {
4542 arg2 = &temp2;
4543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4544 }
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = (arg1)->operator +((wxPoint const &)*arg2);
4548
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 wxPoint * resultptr;
4554 resultptr = new wxPoint((wxPoint &)(result));
4555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj;
4565 wxPoint *arg1 = (wxPoint *) 0 ;
4566 wxPoint *arg2 = 0 ;
4567 wxPoint result;
4568 wxPoint temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "self",(char *) "pt", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4577 if (SWIG_arg_fail(1)) SWIG_fail;
4578 {
4579 arg2 = &temp2;
4580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (arg1)->operator -((wxPoint const &)*arg2);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 wxPoint * resultptr;
4591 resultptr = new wxPoint((wxPoint &)(result));
4592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4593 }
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxPoint *arg1 = (wxPoint *) 0 ;
4603 wxPoint *arg2 = 0 ;
4604 wxPoint *result;
4605 wxPoint temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char *kwnames[] = {
4609 (char *) "self",(char *) "pt", NULL
4610 };
4611
4612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4614 if (SWIG_arg_fail(1)) SWIG_fail;
4615 {
4616 arg2 = &temp2;
4617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 {
4622 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4623 result = (wxPoint *) &_result_ref;
4624 }
4625
4626 wxPyEndAllowThreads(__tstate);
4627 if (PyErr_Occurred()) SWIG_fail;
4628 }
4629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4637 PyObject *resultobj;
4638 wxPoint *arg1 = (wxPoint *) 0 ;
4639 wxPoint *arg2 = 0 ;
4640 wxPoint *result;
4641 wxPoint temp2 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char *kwnames[] = {
4645 (char *) "self",(char *) "pt", NULL
4646 };
4647
4648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4650 if (SWIG_arg_fail(1)) SWIG_fail;
4651 {
4652 arg2 = &temp2;
4653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4654 }
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 {
4658 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4659 result = (wxPoint *) &_result_ref;
4660 }
4661
4662 wxPyEndAllowThreads(__tstate);
4663 if (PyErr_Occurred()) SWIG_fail;
4664 }
4665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj;
4674 wxPoint *arg1 = (wxPoint *) 0 ;
4675 long arg2 ;
4676 long arg3 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 PyObject * obj2 = 0 ;
4680 char *kwnames[] = {
4681 (char *) "self",(char *) "x",(char *) "y", NULL
4682 };
4683
4684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4686 if (SWIG_arg_fail(1)) SWIG_fail;
4687 {
4688 arg2 = (long)(SWIG_As_long(obj1));
4689 if (SWIG_arg_fail(2)) SWIG_fail;
4690 }
4691 {
4692 arg3 = (long)(SWIG_As_long(obj2));
4693 if (SWIG_arg_fail(3)) SWIG_fail;
4694 }
4695 {
4696 PyThreadState* __tstate = wxPyBeginAllowThreads();
4697 wxPoint_Set(arg1,arg2,arg3);
4698
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 Py_INCREF(Py_None); resultobj = Py_None;
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj;
4711 wxPoint *arg1 = (wxPoint *) 0 ;
4712 PyObject *result;
4713 PyObject * obj0 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (PyObject *)wxPoint_Get(arg1);
4724
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 resultobj = result;
4729 return resultobj;
4730 fail:
4731 return NULL;
4732 }
4733
4734
4735 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4736 PyObject *obj;
4737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4738 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4739 Py_INCREF(obj);
4740 return Py_BuildValue((char *)"");
4741 }
4742 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj;
4744 int arg1 = (int) 0 ;
4745 int arg2 = (int) 0 ;
4746 int arg3 = (int) 0 ;
4747 int arg4 = (int) 0 ;
4748 wxRect *result;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 PyObject * obj2 = 0 ;
4752 PyObject * obj3 = 0 ;
4753 char *kwnames[] = {
4754 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4755 };
4756
4757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4758 if (obj0) {
4759 {
4760 arg1 = (int)(SWIG_As_int(obj0));
4761 if (SWIG_arg_fail(1)) SWIG_fail;
4762 }
4763 }
4764 if (obj1) {
4765 {
4766 arg2 = (int)(SWIG_As_int(obj1));
4767 if (SWIG_arg_fail(2)) SWIG_fail;
4768 }
4769 }
4770 if (obj2) {
4771 {
4772 arg3 = (int)(SWIG_As_int(obj2));
4773 if (SWIG_arg_fail(3)) SWIG_fail;
4774 }
4775 }
4776 if (obj3) {
4777 {
4778 arg4 = (int)(SWIG_As_int(obj3));
4779 if (SWIG_arg_fail(4)) SWIG_fail;
4780 }
4781 }
4782 {
4783 PyThreadState* __tstate = wxPyBeginAllowThreads();
4784 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4785
4786 wxPyEndAllowThreads(__tstate);
4787 if (PyErr_Occurred()) SWIG_fail;
4788 }
4789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4790 return resultobj;
4791 fail:
4792 return NULL;
4793 }
4794
4795
4796 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj;
4798 wxPoint *arg1 = 0 ;
4799 wxPoint *arg2 = 0 ;
4800 wxRect *result;
4801 wxPoint temp1 ;
4802 wxPoint temp2 ;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char *kwnames[] = {
4806 (char *) "topLeft",(char *) "bottomRight", NULL
4807 };
4808
4809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4810 {
4811 arg1 = &temp1;
4812 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4813 }
4814 {
4815 arg2 = &temp2;
4816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4817 }
4818 {
4819 PyThreadState* __tstate = wxPyBeginAllowThreads();
4820 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4821
4822 wxPyEndAllowThreads(__tstate);
4823 if (PyErr_Occurred()) SWIG_fail;
4824 }
4825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4826 return resultobj;
4827 fail:
4828 return NULL;
4829 }
4830
4831
4832 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4833 PyObject *resultobj;
4834 wxPoint *arg1 = 0 ;
4835 wxSize *arg2 = 0 ;
4836 wxRect *result;
4837 wxPoint temp1 ;
4838 wxSize temp2 ;
4839 PyObject * obj0 = 0 ;
4840 PyObject * obj1 = 0 ;
4841 char *kwnames[] = {
4842 (char *) "pos",(char *) "size", NULL
4843 };
4844
4845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4846 {
4847 arg1 = &temp1;
4848 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4849 }
4850 {
4851 arg2 = &temp2;
4852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4853 }
4854 {
4855 PyThreadState* __tstate = wxPyBeginAllowThreads();
4856 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4857
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj;
4870 wxSize *arg1 = 0 ;
4871 wxRect *result;
4872 wxSize temp1 ;
4873 PyObject * obj0 = 0 ;
4874 char *kwnames[] = {
4875 (char *) "size", NULL
4876 };
4877
4878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4879 {
4880 arg1 = &temp1;
4881 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4882 }
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4886
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj;
4899 wxRect *arg1 = (wxRect *) 0 ;
4900 PyObject * obj0 = 0 ;
4901 char *kwnames[] = {
4902 (char *) "self", NULL
4903 };
4904
4905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4907 if (SWIG_arg_fail(1)) SWIG_fail;
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 delete arg1;
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 Py_INCREF(Py_None); resultobj = Py_None;
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxRect *arg1 = (wxRect *) 0 ;
4925 int result;
4926 PyObject * obj0 = 0 ;
4927 char *kwnames[] = {
4928 (char *) "self", NULL
4929 };
4930
4931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4933 if (SWIG_arg_fail(1)) SWIG_fail;
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 result = (int)((wxRect const *)arg1)->GetX();
4937
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 {
4942 resultobj = SWIG_From_int((int)(result));
4943 }
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj;
4952 wxRect *arg1 = (wxRect *) 0 ;
4953 int arg2 ;
4954 PyObject * obj0 = 0 ;
4955 PyObject * obj1 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "self",(char *) "x", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4962 if (SWIG_arg_fail(1)) SWIG_fail;
4963 {
4964 arg2 = (int)(SWIG_As_int(obj1));
4965 if (SWIG_arg_fail(2)) SWIG_fail;
4966 }
4967 {
4968 PyThreadState* __tstate = wxPyBeginAllowThreads();
4969 (arg1)->SetX(arg2);
4970
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 Py_INCREF(Py_None); resultobj = Py_None;
4975 return resultobj;
4976 fail:
4977 return NULL;
4978 }
4979
4980
4981 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4982 PyObject *resultobj;
4983 wxRect *arg1 = (wxRect *) 0 ;
4984 int result;
4985 PyObject * obj0 = 0 ;
4986 char *kwnames[] = {
4987 (char *) "self", NULL
4988 };
4989
4990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4992 if (SWIG_arg_fail(1)) SWIG_fail;
4993 {
4994 PyThreadState* __tstate = wxPyBeginAllowThreads();
4995 result = (int)(arg1)->GetY();
4996
4997 wxPyEndAllowThreads(__tstate);
4998 if (PyErr_Occurred()) SWIG_fail;
4999 }
5000 {
5001 resultobj = SWIG_From_int((int)(result));
5002 }
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj;
5011 wxRect *arg1 = (wxRect *) 0 ;
5012 int arg2 ;
5013 PyObject * obj0 = 0 ;
5014 PyObject * obj1 = 0 ;
5015 char *kwnames[] = {
5016 (char *) "self",(char *) "y", NULL
5017 };
5018
5019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5021 if (SWIG_arg_fail(1)) SWIG_fail;
5022 {
5023 arg2 = (int)(SWIG_As_int(obj1));
5024 if (SWIG_arg_fail(2)) SWIG_fail;
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetY(arg2);
5029
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 Py_INCREF(Py_None); resultobj = Py_None;
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5041 PyObject *resultobj;
5042 wxRect *arg1 = (wxRect *) 0 ;
5043 int result;
5044 PyObject * obj0 = 0 ;
5045 char *kwnames[] = {
5046 (char *) "self", NULL
5047 };
5048
5049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5051 if (SWIG_arg_fail(1)) SWIG_fail;
5052 {
5053 PyThreadState* __tstate = wxPyBeginAllowThreads();
5054 result = (int)((wxRect const *)arg1)->GetWidth();
5055
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 {
5060 resultobj = SWIG_From_int((int)(result));
5061 }
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5069 PyObject *resultobj;
5070 wxRect *arg1 = (wxRect *) 0 ;
5071 int arg2 ;
5072 PyObject * obj0 = 0 ;
5073 PyObject * obj1 = 0 ;
5074 char *kwnames[] = {
5075 (char *) "self",(char *) "w", NULL
5076 };
5077
5078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5080 if (SWIG_arg_fail(1)) SWIG_fail;
5081 {
5082 arg2 = (int)(SWIG_As_int(obj1));
5083 if (SWIG_arg_fail(2)) SWIG_fail;
5084 }
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 (arg1)->SetWidth(arg2);
5088
5089 wxPyEndAllowThreads(__tstate);
5090 if (PyErr_Occurred()) SWIG_fail;
5091 }
5092 Py_INCREF(Py_None); resultobj = Py_None;
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5100 PyObject *resultobj;
5101 wxRect *arg1 = (wxRect *) 0 ;
5102 int result;
5103 PyObject * obj0 = 0 ;
5104 char *kwnames[] = {
5105 (char *) "self", NULL
5106 };
5107
5108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5110 if (SWIG_arg_fail(1)) SWIG_fail;
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (int)((wxRect const *)arg1)->GetHeight();
5114
5115 wxPyEndAllowThreads(__tstate);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 {
5119 resultobj = SWIG_From_int((int)(result));
5120 }
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj;
5129 wxRect *arg1 = (wxRect *) 0 ;
5130 int arg2 ;
5131 PyObject * obj0 = 0 ;
5132 PyObject * obj1 = 0 ;
5133 char *kwnames[] = {
5134 (char *) "self",(char *) "h", NULL
5135 };
5136
5137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5139 if (SWIG_arg_fail(1)) SWIG_fail;
5140 {
5141 arg2 = (int)(SWIG_As_int(obj1));
5142 if (SWIG_arg_fail(2)) SWIG_fail;
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 (arg1)->SetHeight(arg2);
5147
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 Py_INCREF(Py_None); resultobj = Py_None;
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj;
5160 wxRect *arg1 = (wxRect *) 0 ;
5161 wxPoint result;
5162 PyObject * obj0 = 0 ;
5163 char *kwnames[] = {
5164 (char *) "self", NULL
5165 };
5166
5167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5169 if (SWIG_arg_fail(1)) SWIG_fail;
5170 {
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 result = ((wxRect const *)arg1)->GetPosition();
5173
5174 wxPyEndAllowThreads(__tstate);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 {
5178 wxPoint * resultptr;
5179 resultptr = new wxPoint((wxPoint &)(result));
5180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj;
5190 wxRect *arg1 = (wxRect *) 0 ;
5191 wxPoint *arg2 = 0 ;
5192 wxPoint temp2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self",(char *) "p", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5205 }
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 (arg1)->SetPosition((wxPoint const &)*arg2);
5209
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 Py_INCREF(Py_None); resultobj = Py_None;
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxSize result;
5224 PyObject * obj0 = 0 ;
5225 char *kwnames[] = {
5226 (char *) "self", NULL
5227 };
5228
5229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5231 if (SWIG_arg_fail(1)) SWIG_fail;
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 result = ((wxRect const *)arg1)->GetSize();
5235
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 {
5240 wxSize * resultptr;
5241 resultptr = new wxSize((wxSize &)(result));
5242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5243 }
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj;
5252 wxRect *arg1 = (wxRect *) 0 ;
5253 wxSize *arg2 = 0 ;
5254 wxSize temp2 ;
5255 PyObject * obj0 = 0 ;
5256 PyObject * obj1 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self",(char *) "s", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5266 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5267 }
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 (arg1)->SetSize((wxSize const &)*arg2);
5271
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 Py_INCREF(Py_None); resultobj = Py_None;
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 bool result;
5286 PyObject * obj0 = 0 ;
5287 char *kwnames[] = {
5288 (char *) "self", NULL
5289 };
5290
5291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5293 if (SWIG_arg_fail(1)) SWIG_fail;
5294 {
5295 PyThreadState* __tstate = wxPyBeginAllowThreads();
5296 result = (bool)((wxRect const *)arg1)->IsEmpty();
5297
5298 wxPyEndAllowThreads(__tstate);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 {
5302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5303 }
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj;
5312 wxRect *arg1 = (wxRect *) 0 ;
5313 wxPoint result;
5314 PyObject * obj0 = 0 ;
5315 char *kwnames[] = {
5316 (char *) "self", NULL
5317 };
5318
5319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5321 if (SWIG_arg_fail(1)) SWIG_fail;
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = ((wxRect const *)arg1)->GetTopLeft();
5325
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 {
5330 wxPoint * resultptr;
5331 resultptr = new wxPoint((wxPoint &)(result));
5332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5333 }
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5341 PyObject *resultobj;
5342 wxRect *arg1 = (wxRect *) 0 ;
5343 wxPoint *arg2 = 0 ;
5344 wxPoint temp2 ;
5345 PyObject * obj0 = 0 ;
5346 PyObject * obj1 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self",(char *) "p", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5356 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5357 }
5358 {
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5361
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 Py_INCREF(Py_None); resultobj = Py_None;
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint result;
5376 PyObject * obj0 = 0 ;
5377 char *kwnames[] = {
5378 (char *) "self", NULL
5379 };
5380
5381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5383 if (SWIG_arg_fail(1)) SWIG_fail;
5384 {
5385 PyThreadState* __tstate = wxPyBeginAllowThreads();
5386 result = ((wxRect const *)arg1)->GetBottomRight();
5387
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 {
5392 wxPoint * resultptr;
5393 resultptr = new wxPoint((wxPoint &)(result));
5394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5395 }
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj;
5404 wxRect *arg1 = (wxRect *) 0 ;
5405 wxPoint *arg2 = 0 ;
5406 wxPoint temp2 ;
5407 PyObject * obj0 = 0 ;
5408 PyObject * obj1 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self",(char *) "p", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5419 }
5420 {
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5423
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 Py_INCREF(Py_None); resultobj = Py_None;
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 int result;
5438 PyObject * obj0 = 0 ;
5439 char *kwnames[] = {
5440 (char *) "self", NULL
5441 };
5442
5443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5445 if (SWIG_arg_fail(1)) SWIG_fail;
5446 {
5447 PyThreadState* __tstate = wxPyBeginAllowThreads();
5448 result = (int)((wxRect const *)arg1)->GetLeft();
5449
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 {
5454 resultobj = SWIG_From_int((int)(result));
5455 }
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj;
5464 wxRect *arg1 = (wxRect *) 0 ;
5465 int result;
5466 PyObject * obj0 = 0 ;
5467 char *kwnames[] = {
5468 (char *) "self", NULL
5469 };
5470
5471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(1)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 result = (int)((wxRect const *)arg1)->GetTop();
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 {
5482 resultobj = SWIG_From_int((int)(result));
5483 }
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5491 PyObject *resultobj;
5492 wxRect *arg1 = (wxRect *) 0 ;
5493 int result;
5494 PyObject * obj0 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "self", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5501 if (SWIG_arg_fail(1)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (int)((wxRect const *)arg1)->GetBottom();
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 resultobj = SWIG_From_int((int)(result));
5511 }
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj;
5520 wxRect *arg1 = (wxRect *) 0 ;
5521 int result;
5522 PyObject * obj0 = 0 ;
5523 char *kwnames[] = {
5524 (char *) "self", NULL
5525 };
5526
5527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5529 if (SWIG_arg_fail(1)) SWIG_fail;
5530 {
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = (int)((wxRect const *)arg1)->GetRight();
5533
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 {
5538 resultobj = SWIG_From_int((int)(result));
5539 }
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5547 PyObject *resultobj;
5548 wxRect *arg1 = (wxRect *) 0 ;
5549 int arg2 ;
5550 PyObject * obj0 = 0 ;
5551 PyObject * obj1 = 0 ;
5552 char *kwnames[] = {
5553 (char *) "self",(char *) "left", NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5558 if (SWIG_arg_fail(1)) SWIG_fail;
5559 {
5560 arg2 = (int)(SWIG_As_int(obj1));
5561 if (SWIG_arg_fail(2)) SWIG_fail;
5562 }
5563 {
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 (arg1)->SetLeft(arg2);
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 Py_INCREF(Py_None); resultobj = Py_None;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj;
5579 wxRect *arg1 = (wxRect *) 0 ;
5580 int arg2 ;
5581 PyObject * obj0 = 0 ;
5582 PyObject * obj1 = 0 ;
5583 char *kwnames[] = {
5584 (char *) "self",(char *) "right", NULL
5585 };
5586
5587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5589 if (SWIG_arg_fail(1)) SWIG_fail;
5590 {
5591 arg2 = (int)(SWIG_As_int(obj1));
5592 if (SWIG_arg_fail(2)) SWIG_fail;
5593 }
5594 {
5595 PyThreadState* __tstate = wxPyBeginAllowThreads();
5596 (arg1)->SetRight(arg2);
5597
5598 wxPyEndAllowThreads(__tstate);
5599 if (PyErr_Occurred()) SWIG_fail;
5600 }
5601 Py_INCREF(Py_None); resultobj = Py_None;
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5609 PyObject *resultobj;
5610 wxRect *arg1 = (wxRect *) 0 ;
5611 int arg2 ;
5612 PyObject * obj0 = 0 ;
5613 PyObject * obj1 = 0 ;
5614 char *kwnames[] = {
5615 (char *) "self",(char *) "top", NULL
5616 };
5617
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5620 if (SWIG_arg_fail(1)) SWIG_fail;
5621 {
5622 arg2 = (int)(SWIG_As_int(obj1));
5623 if (SWIG_arg_fail(2)) SWIG_fail;
5624 }
5625 {
5626 PyThreadState* __tstate = wxPyBeginAllowThreads();
5627 (arg1)->SetTop(arg2);
5628
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 Py_INCREF(Py_None); resultobj = Py_None;
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj;
5641 wxRect *arg1 = (wxRect *) 0 ;
5642 int arg2 ;
5643 PyObject * obj0 = 0 ;
5644 PyObject * obj1 = 0 ;
5645 char *kwnames[] = {
5646 (char *) "self",(char *) "bottom", NULL
5647 };
5648
5649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5651 if (SWIG_arg_fail(1)) SWIG_fail;
5652 {
5653 arg2 = (int)(SWIG_As_int(obj1));
5654 if (SWIG_arg_fail(2)) SWIG_fail;
5655 }
5656 {
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 (arg1)->SetBottom(arg2);
5659
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 Py_INCREF(Py_None); resultobj = Py_None;
5664 return resultobj;
5665 fail:
5666 return NULL;
5667 }
5668
5669
5670 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5671 PyObject *resultobj;
5672 wxRect *arg1 = (wxRect *) 0 ;
5673 int arg2 ;
5674 int arg3 ;
5675 wxRect *result;
5676 PyObject * obj0 = 0 ;
5677 PyObject * obj1 = 0 ;
5678 PyObject * obj2 = 0 ;
5679 char *kwnames[] = {
5680 (char *) "self",(char *) "dx",(char *) "dy", NULL
5681 };
5682
5683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5685 if (SWIG_arg_fail(1)) SWIG_fail;
5686 {
5687 arg2 = (int)(SWIG_As_int(obj1));
5688 if (SWIG_arg_fail(2)) SWIG_fail;
5689 }
5690 {
5691 arg3 = (int)(SWIG_As_int(obj2));
5692 if (SWIG_arg_fail(3)) SWIG_fail;
5693 }
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 {
5697 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5698 result = (wxRect *) &_result_ref;
5699 }
5700
5701 wxPyEndAllowThreads(__tstate);
5702 if (PyErr_Occurred()) SWIG_fail;
5703 }
5704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 wxRect *arg1 = (wxRect *) 0 ;
5714 int arg2 ;
5715 int arg3 ;
5716 wxRect *result;
5717 PyObject * obj0 = 0 ;
5718 PyObject * obj1 = 0 ;
5719 PyObject * obj2 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "self",(char *) "dx",(char *) "dy", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5726 if (SWIG_arg_fail(1)) SWIG_fail;
5727 {
5728 arg2 = (int)(SWIG_As_int(obj1));
5729 if (SWIG_arg_fail(2)) SWIG_fail;
5730 }
5731 {
5732 arg3 = (int)(SWIG_As_int(obj2));
5733 if (SWIG_arg_fail(3)) SWIG_fail;
5734 }
5735 {
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 {
5738 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5739 result = (wxRect *) &_result_ref;
5740 }
5741
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxRect *arg1 = (wxRect *) 0 ;
5755 int arg2 ;
5756 int arg3 ;
5757 PyObject * obj0 = 0 ;
5758 PyObject * obj1 = 0 ;
5759 PyObject * obj2 = 0 ;
5760 char *kwnames[] = {
5761 (char *) "self",(char *) "dx",(char *) "dy", NULL
5762 };
5763
5764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5766 if (SWIG_arg_fail(1)) SWIG_fail;
5767 {
5768 arg2 = (int)(SWIG_As_int(obj1));
5769 if (SWIG_arg_fail(2)) SWIG_fail;
5770 }
5771 {
5772 arg3 = (int)(SWIG_As_int(obj2));
5773 if (SWIG_arg_fail(3)) SWIG_fail;
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 (arg1)->Offset(arg2,arg3);
5778
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 Py_INCREF(Py_None); resultobj = Py_None;
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj;
5791 wxRect *arg1 = (wxRect *) 0 ;
5792 wxPoint *arg2 = 0 ;
5793 wxPoint temp2 ;
5794 PyObject * obj0 = 0 ;
5795 PyObject * obj1 = 0 ;
5796 char *kwnames[] = {
5797 (char *) "self",(char *) "pt", NULL
5798 };
5799
5800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5802 if (SWIG_arg_fail(1)) SWIG_fail;
5803 {
5804 arg2 = &temp2;
5805 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->Offset((wxPoint const &)*arg2);
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_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxRect *arg2 = 0 ;
5825 wxRect result;
5826 wxRect temp2 ;
5827 PyObject * obj0 = 0 ;
5828 PyObject * obj1 = 0 ;
5829 char *kwnames[] = {
5830 (char *) "self",(char *) "rect", NULL
5831 };
5832
5833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5835 if (SWIG_arg_fail(1)) SWIG_fail;
5836 {
5837 arg2 = &temp2;
5838 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 result = (arg1)->Intersect((wxRect const &)*arg2);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 {
5848 wxRect * resultptr;
5849 resultptr = new wxRect((wxRect &)(result));
5850 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5851 }
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj;
5860 wxRect *arg1 = (wxRect *) 0 ;
5861 wxRect *arg2 = 0 ;
5862 wxRect result;
5863 wxRect temp2 ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "self",(char *) "rect", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = (arg1)->Union((wxRect const &)*arg2);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 {
5885 wxRect * resultptr;
5886 resultptr = new wxRect((wxRect &)(result));
5887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5888 }
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj;
5897 wxRect *arg1 = (wxRect *) 0 ;
5898 wxRect *arg2 = 0 ;
5899 wxRect result;
5900 wxRect temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "self",(char *) "rect", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5909 if (SWIG_arg_fail(1)) SWIG_fail;
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 wxRect * resultptr;
5923 resultptr = new wxRect((wxRect &)(result));
5924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5925 }
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj;
5934 wxRect *arg1 = (wxRect *) 0 ;
5935 wxRect *arg2 = 0 ;
5936 wxRect *result;
5937 wxRect temp2 ;
5938 PyObject * obj0 = 0 ;
5939 PyObject * obj1 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "self",(char *) "rect", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 {
5954 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5955 result = (wxRect *) &_result_ref;
5956 }
5957
5958 wxPyEndAllowThreads(__tstate);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
5968 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5969 PyObject *resultobj;
5970 wxRect *arg1 = (wxRect *) 0 ;
5971 wxRect *arg2 = 0 ;
5972 bool result;
5973 wxRect temp2 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 char *kwnames[] = {
5977 (char *) "self",(char *) "rect", NULL
5978 };
5979
5980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5982 if (SWIG_arg_fail(1)) SWIG_fail;
5983 {
5984 arg2 = &temp2;
5985 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5986 }
5987 {
5988 PyThreadState* __tstate = wxPyBeginAllowThreads();
5989 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5990
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 {
5995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5996 }
5997 return resultobj;
5998 fail:
5999 return NULL;
6000 }
6001
6002
6003 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6004 PyObject *resultobj;
6005 wxRect *arg1 = (wxRect *) 0 ;
6006 wxRect *arg2 = 0 ;
6007 bool result;
6008 wxRect temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char *kwnames[] = {
6012 (char *) "self",(char *) "rect", NULL
6013 };
6014
6015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6017 if (SWIG_arg_fail(1)) SWIG_fail;
6018 {
6019 arg2 = &temp2;
6020 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6021 }
6022 {
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 {
6030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6031 }
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 wxRect *arg1 = (wxRect *) 0 ;
6041 int arg2 ;
6042 int arg3 ;
6043 bool result;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 PyObject * obj2 = 0 ;
6047 char *kwnames[] = {
6048 (char *) "self",(char *) "x",(char *) "y", NULL
6049 };
6050
6051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6053 if (SWIG_arg_fail(1)) SWIG_fail;
6054 {
6055 arg2 = (int)(SWIG_As_int(obj1));
6056 if (SWIG_arg_fail(2)) SWIG_fail;
6057 }
6058 {
6059 arg3 = (int)(SWIG_As_int(obj2));
6060 if (SWIG_arg_fail(3)) SWIG_fail;
6061 }
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6065
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 {
6070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6071 }
6072 return resultobj;
6073 fail:
6074 return NULL;
6075 }
6076
6077
6078 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6079 PyObject *resultobj;
6080 wxRect *arg1 = (wxRect *) 0 ;
6081 wxPoint *arg2 = 0 ;
6082 bool result;
6083 wxPoint temp2 ;
6084 PyObject * obj0 = 0 ;
6085 PyObject * obj1 = 0 ;
6086 char *kwnames[] = {
6087 (char *) "self",(char *) "pt", NULL
6088 };
6089
6090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6092 if (SWIG_arg_fail(1)) SWIG_fail;
6093 {
6094 arg2 = &temp2;
6095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6096 }
6097 {
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6100
6101 wxPyEndAllowThreads(__tstate);
6102 if (PyErr_Occurred()) SWIG_fail;
6103 }
6104 {
6105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6106 }
6107 return resultobj;
6108 fail:
6109 return NULL;
6110 }
6111
6112
6113 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6114 PyObject *resultobj;
6115 wxRect *arg1 = (wxRect *) 0 ;
6116 wxRect *arg2 = 0 ;
6117 bool result;
6118 wxRect temp2 ;
6119 PyObject * obj0 = 0 ;
6120 PyObject * obj1 = 0 ;
6121 char *kwnames[] = {
6122 (char *) "self",(char *) "rect", NULL
6123 };
6124
6125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6127 if (SWIG_arg_fail(1)) SWIG_fail;
6128 {
6129 arg2 = &temp2;
6130 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6131 }
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6141 }
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxRect *arg1 = (wxRect *) 0 ;
6151 int arg2 ;
6152 PyObject * obj0 = 0 ;
6153 PyObject * obj1 = 0 ;
6154 char *kwnames[] = {
6155 (char *) "self",(char *) "x", NULL
6156 };
6157
6158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6160 if (SWIG_arg_fail(1)) SWIG_fail;
6161 {
6162 arg2 = (int)(SWIG_As_int(obj1));
6163 if (SWIG_arg_fail(2)) SWIG_fail;
6164 }
6165 if (arg1) (arg1)->x = arg2;
6166
6167 Py_INCREF(Py_None); resultobj = Py_None;
6168 return resultobj;
6169 fail:
6170 return NULL;
6171 }
6172
6173
6174 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6175 PyObject *resultobj;
6176 wxRect *arg1 = (wxRect *) 0 ;
6177 int result;
6178 PyObject * obj0 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "self", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6185 if (SWIG_arg_fail(1)) SWIG_fail;
6186 result = (int) ((arg1)->x);
6187
6188 {
6189 resultobj = SWIG_From_int((int)(result));
6190 }
6191 return resultobj;
6192 fail:
6193 return NULL;
6194 }
6195
6196
6197 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6198 PyObject *resultobj;
6199 wxRect *arg1 = (wxRect *) 0 ;
6200 int arg2 ;
6201 PyObject * obj0 = 0 ;
6202 PyObject * obj1 = 0 ;
6203 char *kwnames[] = {
6204 (char *) "self",(char *) "y", NULL
6205 };
6206
6207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6209 if (SWIG_arg_fail(1)) SWIG_fail;
6210 {
6211 arg2 = (int)(SWIG_As_int(obj1));
6212 if (SWIG_arg_fail(2)) SWIG_fail;
6213 }
6214 if (arg1) (arg1)->y = arg2;
6215
6216 Py_INCREF(Py_None); resultobj = Py_None;
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj;
6225 wxRect *arg1 = (wxRect *) 0 ;
6226 int result;
6227 PyObject * obj0 = 0 ;
6228 char *kwnames[] = {
6229 (char *) "self", NULL
6230 };
6231
6232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6234 if (SWIG_arg_fail(1)) SWIG_fail;
6235 result = (int) ((arg1)->y);
6236
6237 {
6238 resultobj = SWIG_From_int((int)(result));
6239 }
6240 return resultobj;
6241 fail:
6242 return NULL;
6243 }
6244
6245
6246 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj;
6248 wxRect *arg1 = (wxRect *) 0 ;
6249 int arg2 ;
6250 PyObject * obj0 = 0 ;
6251 PyObject * obj1 = 0 ;
6252 char *kwnames[] = {
6253 (char *) "self",(char *) "width", NULL
6254 };
6255
6256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6258 if (SWIG_arg_fail(1)) SWIG_fail;
6259 {
6260 arg2 = (int)(SWIG_As_int(obj1));
6261 if (SWIG_arg_fail(2)) SWIG_fail;
6262 }
6263 if (arg1) (arg1)->width = arg2;
6264
6265 Py_INCREF(Py_None); resultobj = Py_None;
6266 return resultobj;
6267 fail:
6268 return NULL;
6269 }
6270
6271
6272 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6273 PyObject *resultobj;
6274 wxRect *arg1 = (wxRect *) 0 ;
6275 int result;
6276 PyObject * obj0 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "self", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6283 if (SWIG_arg_fail(1)) SWIG_fail;
6284 result = (int) ((arg1)->width);
6285
6286 {
6287 resultobj = SWIG_From_int((int)(result));
6288 }
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj;
6297 wxRect *arg1 = (wxRect *) 0 ;
6298 int arg2 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "self",(char *) "height", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 {
6309 arg2 = (int)(SWIG_As_int(obj1));
6310 if (SWIG_arg_fail(2)) SWIG_fail;
6311 }
6312 if (arg1) (arg1)->height = arg2;
6313
6314 Py_INCREF(Py_None); resultobj = Py_None;
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj;
6323 wxRect *arg1 = (wxRect *) 0 ;
6324 int result;
6325 PyObject * obj0 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 result = (int) ((arg1)->height);
6334
6335 {
6336 resultobj = SWIG_From_int((int)(result));
6337 }
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int arg2 = (int) 0 ;
6348 int arg3 = (int) 0 ;
6349 int arg4 = (int) 0 ;
6350 int arg5 = (int) 0 ;
6351 PyObject * obj0 = 0 ;
6352 PyObject * obj1 = 0 ;
6353 PyObject * obj2 = 0 ;
6354 PyObject * obj3 = 0 ;
6355 PyObject * obj4 = 0 ;
6356 char *kwnames[] = {
6357 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6358 };
6359
6360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6362 if (SWIG_arg_fail(1)) SWIG_fail;
6363 if (obj1) {
6364 {
6365 arg2 = (int)(SWIG_As_int(obj1));
6366 if (SWIG_arg_fail(2)) SWIG_fail;
6367 }
6368 }
6369 if (obj2) {
6370 {
6371 arg3 = (int)(SWIG_As_int(obj2));
6372 if (SWIG_arg_fail(3)) SWIG_fail;
6373 }
6374 }
6375 if (obj3) {
6376 {
6377 arg4 = (int)(SWIG_As_int(obj3));
6378 if (SWIG_arg_fail(4)) SWIG_fail;
6379 }
6380 }
6381 if (obj4) {
6382 {
6383 arg5 = (int)(SWIG_As_int(obj4));
6384 if (SWIG_arg_fail(5)) SWIG_fail;
6385 }
6386 }
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 Py_INCREF(Py_None); resultobj = Py_None;
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 PyObject *result;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (PyObject *)wxRect_Get(arg1);
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 resultobj = result;
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6428 PyObject *obj;
6429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6430 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6431 Py_INCREF(obj);
6432 return Py_BuildValue((char *)"");
6433 }
6434 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6435 PyObject *resultobj;
6436 wxRect *arg1 = (wxRect *) 0 ;
6437 wxRect *arg2 = (wxRect *) 0 ;
6438 PyObject *result;
6439 PyObject * obj0 = 0 ;
6440 PyObject * obj1 = 0 ;
6441 char *kwnames[] = {
6442 (char *) "r1",(char *) "r2", NULL
6443 };
6444
6445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6447 if (SWIG_arg_fail(1)) SWIG_fail;
6448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(2)) SWIG_fail;
6450 {
6451 if (!wxPyCheckForApp()) SWIG_fail;
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (PyObject *)wxIntersectRect(arg1,arg2);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = result;
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 double arg1 = (double) 0.0 ;
6468 double arg2 = (double) 0.0 ;
6469 wxPoint2D *result;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char *kwnames[] = {
6473 (char *) "x",(char *) "y", NULL
6474 };
6475
6476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6477 if (obj0) {
6478 {
6479 arg1 = (double)(SWIG_As_double(obj0));
6480 if (SWIG_arg_fail(1)) SWIG_fail;
6481 }
6482 }
6483 if (obj1) {
6484 {
6485 arg2 = (double)(SWIG_As_double(obj1));
6486 if (SWIG_arg_fail(2)) SWIG_fail;
6487 }
6488 }
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 wxPoint2D *arg1 = 0 ;
6506 wxPoint2D *result;
6507 wxPoint2D temp1 ;
6508 PyObject * obj0 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "pt", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6514 {
6515 arg1 = &temp1;
6516 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6517 }
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6521
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj;
6534 wxPoint *arg1 = 0 ;
6535 wxPoint2D *result;
6536 wxPoint temp1 ;
6537 PyObject * obj0 = 0 ;
6538 char *kwnames[] = {
6539 (char *) "pt", NULL
6540 };
6541
6542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6543 {
6544 arg1 = &temp1;
6545 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6546 }
6547 {
6548 PyThreadState* __tstate = wxPyBeginAllowThreads();
6549 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6550
6551 wxPyEndAllowThreads(__tstate);
6552 if (PyErr_Occurred()) SWIG_fail;
6553 }
6554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj;
6563 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6564 int *arg2 = (int *) 0 ;
6565 int *arg3 = (int *) 0 ;
6566 int temp2 ;
6567 int res2 = 0 ;
6568 int temp3 ;
6569 int res3 = 0 ;
6570 PyObject * obj0 = 0 ;
6571 char *kwnames[] = {
6572 (char *) "self", NULL
6573 };
6574
6575 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6576 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6583
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 Py_INCREF(Py_None); resultobj = Py_None;
6588 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6589 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6591 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6601 int *arg2 = (int *) 0 ;
6602 int *arg3 = (int *) 0 ;
6603 int temp2 ;
6604 int res2 = 0 ;
6605 int temp3 ;
6606 int res3 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "self", NULL
6610 };
6611
6612 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6613 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 Py_INCREF(Py_None); resultobj = Py_None;
6625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6627 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6628 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6638 double result;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6646 if (SWIG_arg_fail(1)) SWIG_fail;
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6650
6651 wxPyEndAllowThreads(__tstate);
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 {
6655 resultobj = SWIG_From_double((double)(result));
6656 }
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj;
6665 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6666 double result;
6667 PyObject * obj0 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "self", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 {
6683 resultobj = SWIG_From_double((double)(result));
6684 }
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6692 PyObject *resultobj;
6693 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6694 double arg2 ;
6695 PyObject * obj0 = 0 ;
6696 PyObject * obj1 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "self",(char *) "length", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 arg2 = (double)(SWIG_As_double(obj1));
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 (arg1)->SetVectorLength(arg2);
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 Py_INCREF(Py_None); resultobj = Py_None;
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj;
6724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6725 double arg2 ;
6726 PyObject * obj0 = 0 ;
6727 PyObject * obj1 = 0 ;
6728 char *kwnames[] = {
6729 (char *) "self",(char *) "degrees", NULL
6730 };
6731
6732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6734 if (SWIG_arg_fail(1)) SWIG_fail;
6735 {
6736 arg2 = (double)(SWIG_As_double(obj1));
6737 if (SWIG_arg_fail(2)) SWIG_fail;
6738 }
6739 {
6740 PyThreadState* __tstate = wxPyBeginAllowThreads();
6741 (arg1)->SetVectorAngle(arg2);
6742
6743 wxPyEndAllowThreads(__tstate);
6744 if (PyErr_Occurred()) SWIG_fail;
6745 }
6746 Py_INCREF(Py_None); resultobj = Py_None;
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6754 PyObject *resultobj;
6755 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6756 wxPoint2D *arg2 = 0 ;
6757 double result;
6758 wxPoint2D temp2 ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 char *kwnames[] = {
6762 (char *) "self",(char *) "pt", NULL
6763 };
6764
6765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6767 if (SWIG_arg_fail(1)) SWIG_fail;
6768 {
6769 arg2 = &temp2;
6770 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6771 }
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6775
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 {
6780 resultobj = SWIG_From_double((double)(result));
6781 }
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj;
6790 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6791 wxPoint2D *arg2 = 0 ;
6792 double result;
6793 wxPoint2D temp2 ;
6794 PyObject * obj0 = 0 ;
6795 PyObject * obj1 = 0 ;
6796 char *kwnames[] = {
6797 (char *) "self",(char *) "pt", NULL
6798 };
6799
6800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6802 if (SWIG_arg_fail(1)) SWIG_fail;
6803 {
6804 arg2 = &temp2;
6805 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6806 }
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6810
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 {
6815 resultobj = SWIG_From_double((double)(result));
6816 }
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj;
6825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6826 wxPoint2D *arg2 = 0 ;
6827 double result;
6828 wxPoint2D temp2 ;
6829 PyObject * obj0 = 0 ;
6830 PyObject * obj1 = 0 ;
6831 char *kwnames[] = {
6832 (char *) "self",(char *) "vec", NULL
6833 };
6834
6835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6837 if (SWIG_arg_fail(1)) SWIG_fail;
6838 {
6839 arg2 = &temp2;
6840 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = SWIG_From_double((double)(result));
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6859 PyObject *resultobj;
6860 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6861 wxPoint2D *arg2 = 0 ;
6862 double result;
6863 wxPoint2D temp2 ;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 char *kwnames[] = {
6867 (char *) "self",(char *) "vec", NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6872 if (SWIG_arg_fail(1)) SWIG_fail;
6873 {
6874 arg2 = &temp2;
6875 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6876 }
6877 {
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6880
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 {
6885 resultobj = SWIG_From_double((double)(result));
6886 }
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj;
6895 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6896 wxPoint2D result;
6897 PyObject * obj0 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "self", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
6907 result = (arg1)->operator -();
6908
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 {
6913 wxPoint2D * resultptr;
6914 resultptr = new wxPoint2D((wxPoint2D &)(result));
6915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6916 }
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj;
6925 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6926 wxPoint2D *arg2 = 0 ;
6927 wxPoint2D *result;
6928 wxPoint2D temp2 ;
6929 PyObject * obj0 = 0 ;
6930 PyObject * obj1 = 0 ;
6931 char *kwnames[] = {
6932 (char *) "self",(char *) "pt", NULL
6933 };
6934
6935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6937 if (SWIG_arg_fail(1)) SWIG_fail;
6938 {
6939 arg2 = &temp2;
6940 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6941 }
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 {
6945 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6946 result = (wxPoint2D *) &_result_ref;
6947 }
6948
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj;
6961 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6962 wxPoint2D *arg2 = 0 ;
6963 wxPoint2D *result;
6964 wxPoint2D temp2 ;
6965 PyObject * obj0 = 0 ;
6966 PyObject * obj1 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "self",(char *) "pt", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 {
6975 arg2 = &temp2;
6976 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6977 }
6978 {
6979 PyThreadState* __tstate = wxPyBeginAllowThreads();
6980 {
6981 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6982 result = (wxPoint2D *) &_result_ref;
6983 }
6984
6985 wxPyEndAllowThreads(__tstate);
6986 if (PyErr_Occurred()) SWIG_fail;
6987 }
6988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6998 wxPoint2D *arg2 = 0 ;
6999 wxPoint2D *result;
7000 wxPoint2D temp2 ;
7001 PyObject * obj0 = 0 ;
7002 PyObject * obj1 = 0 ;
7003 char *kwnames[] = {
7004 (char *) "self",(char *) "pt", NULL
7005 };
7006
7007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7009 if (SWIG_arg_fail(1)) SWIG_fail;
7010 {
7011 arg2 = &temp2;
7012 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7013 }
7014 {
7015 PyThreadState* __tstate = wxPyBeginAllowThreads();
7016 {
7017 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7018 result = (wxPoint2D *) &_result_ref;
7019 }
7020
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7025 return resultobj;
7026 fail:
7027 return NULL;
7028 }
7029
7030
7031 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7032 PyObject *resultobj;
7033 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7034 wxPoint2D *arg2 = 0 ;
7035 wxPoint2D *result;
7036 wxPoint2D temp2 ;
7037 PyObject * obj0 = 0 ;
7038 PyObject * obj1 = 0 ;
7039 char *kwnames[] = {
7040 (char *) "self",(char *) "pt", NULL
7041 };
7042
7043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7045 if (SWIG_arg_fail(1)) SWIG_fail;
7046 {
7047 arg2 = &temp2;
7048 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7049 }
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 {
7053 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7054 result = (wxPoint2D *) &_result_ref;
7055 }
7056
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7061 return resultobj;
7062 fail:
7063 return NULL;
7064 }
7065
7066
7067 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj;
7069 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7070 wxPoint2D *arg2 = 0 ;
7071 bool result;
7072 wxPoint2D temp2 ;
7073 PyObject * obj0 = 0 ;
7074 PyObject * obj1 = 0 ;
7075 char *kwnames[] = {
7076 (char *) "self",(char *) "pt", NULL
7077 };
7078
7079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7081 if (SWIG_arg_fail(1)) SWIG_fail;
7082 {
7083 arg2 = &temp2;
7084 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7089
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 {
7094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7095 }
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7103 PyObject *resultobj;
7104 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7105 wxPoint2D *arg2 = 0 ;
7106 bool result;
7107 wxPoint2D temp2 ;
7108 PyObject * obj0 = 0 ;
7109 PyObject * obj1 = 0 ;
7110 char *kwnames[] = {
7111 (char *) "self",(char *) "pt", NULL
7112 };
7113
7114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7116 if (SWIG_arg_fail(1)) SWIG_fail;
7117 {
7118 arg2 = &temp2;
7119 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7120 }
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7124
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 {
7129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7130 }
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7138 PyObject *resultobj;
7139 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7140 double arg2 ;
7141 PyObject * obj0 = 0 ;
7142 PyObject * obj1 = 0 ;
7143 char *kwnames[] = {
7144 (char *) "self",(char *) "m_x", NULL
7145 };
7146
7147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7149 if (SWIG_arg_fail(1)) SWIG_fail;
7150 {
7151 arg2 = (double)(SWIG_As_double(obj1));
7152 if (SWIG_arg_fail(2)) SWIG_fail;
7153 }
7154 if (arg1) (arg1)->m_x = arg2;
7155
7156 Py_INCREF(Py_None); resultobj = Py_None;
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj;
7165 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7166 double result;
7167 PyObject * obj0 = 0 ;
7168 char *kwnames[] = {
7169 (char *) "self", NULL
7170 };
7171
7172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7174 if (SWIG_arg_fail(1)) SWIG_fail;
7175 result = (double) ((arg1)->m_x);
7176
7177 {
7178 resultobj = SWIG_From_double((double)(result));
7179 }
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj;
7188 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7189 double arg2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char *kwnames[] = {
7193 (char *) "self",(char *) "m_y", NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7198 if (SWIG_arg_fail(1)) SWIG_fail;
7199 {
7200 arg2 = (double)(SWIG_As_double(obj1));
7201 if (SWIG_arg_fail(2)) SWIG_fail;
7202 }
7203 if (arg1) (arg1)->m_y = arg2;
7204
7205 Py_INCREF(Py_None); resultobj = Py_None;
7206 return resultobj;
7207 fail:
7208 return NULL;
7209 }
7210
7211
7212 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7213 PyObject *resultobj;
7214 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7215 double result;
7216 PyObject * obj0 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 result = (double) ((arg1)->m_y);
7225
7226 {
7227 resultobj = SWIG_From_double((double)(result));
7228 }
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj;
7237 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7238 double arg2 = (double) 0 ;
7239 double arg3 = (double) 0 ;
7240 PyObject * obj0 = 0 ;
7241 PyObject * obj1 = 0 ;
7242 PyObject * obj2 = 0 ;
7243 char *kwnames[] = {
7244 (char *) "self",(char *) "x",(char *) "y", NULL
7245 };
7246
7247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 if (obj1) {
7251 {
7252 arg2 = (double)(SWIG_As_double(obj1));
7253 if (SWIG_arg_fail(2)) SWIG_fail;
7254 }
7255 }
7256 if (obj2) {
7257 {
7258 arg3 = (double)(SWIG_As_double(obj2));
7259 if (SWIG_arg_fail(3)) SWIG_fail;
7260 }
7261 }
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 wxPoint2D_Set(arg1,arg2,arg3);
7265
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 Py_INCREF(Py_None); resultobj = Py_None;
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj;
7278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7279 PyObject *result;
7280 PyObject * obj0 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = (PyObject *)wxPoint2D_Get(arg1);
7291
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 resultobj = result;
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7303 PyObject *obj;
7304 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7305 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7306 Py_INCREF(obj);
7307 return Py_BuildValue((char *)"");
7308 }
7309 static int _wrap_DefaultPosition_set(PyObject *) {
7310 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7311 return 1;
7312 }
7313
7314
7315 static PyObject *_wrap_DefaultPosition_get(void) {
7316 PyObject *pyobj;
7317
7318 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7319 return pyobj;
7320 }
7321
7322
7323 static int _wrap_DefaultSize_set(PyObject *) {
7324 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7325 return 1;
7326 }
7327
7328
7329 static PyObject *_wrap_DefaultSize_get(void) {
7330 PyObject *pyobj;
7331
7332 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7333 return pyobj;
7334 }
7335
7336
7337 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7338 PyObject *resultobj;
7339 PyObject *arg1 = (PyObject *) 0 ;
7340 wxPyInputStream *result;
7341 PyObject * obj0 = 0 ;
7342 char *kwnames[] = {
7343 (char *) "p", NULL
7344 };
7345
7346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7347 arg1 = obj0;
7348 {
7349 PyThreadState* __tstate = wxPyBeginAllowThreads();
7350 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7351
7352 wxPyEndAllowThreads(__tstate);
7353 if (PyErr_Occurred()) SWIG_fail;
7354 }
7355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7356 return resultobj;
7357 fail:
7358 return NULL;
7359 }
7360
7361
7362 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7363 PyObject *resultobj;
7364 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7365 PyObject * obj0 = 0 ;
7366 char *kwnames[] = {
7367 (char *) "self", NULL
7368 };
7369
7370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7372 if (SWIG_arg_fail(1)) SWIG_fail;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 delete arg1;
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 Py_INCREF(Py_None); resultobj = Py_None;
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7390 PyObject * obj0 = 0 ;
7391 char *kwnames[] = {
7392 (char *) "self", NULL
7393 };
7394
7395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7397 if (SWIG_arg_fail(1)) SWIG_fail;
7398 {
7399 PyThreadState* __tstate = wxPyBeginAllowThreads();
7400 (arg1)->close();
7401
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 Py_INCREF(Py_None); resultobj = Py_None;
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj;
7414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7415 PyObject * obj0 = 0 ;
7416 char *kwnames[] = {
7417 (char *) "self", NULL
7418 };
7419
7420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7422 if (SWIG_arg_fail(1)) SWIG_fail;
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 (arg1)->flush();
7426
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 Py_INCREF(Py_None); resultobj = Py_None;
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj;
7439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7440 bool result;
7441 PyObject * obj0 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->eof();
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj;
7467 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7468 int arg2 = (int) -1 ;
7469 PyObject *result;
7470 PyObject * obj0 = 0 ;
7471 PyObject * obj1 = 0 ;
7472 char *kwnames[] = {
7473 (char *) "self",(char *) "size", NULL
7474 };
7475
7476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7478 if (SWIG_arg_fail(1)) SWIG_fail;
7479 if (obj1) {
7480 {
7481 arg2 = (int)(SWIG_As_int(obj1));
7482 if (SWIG_arg_fail(2)) SWIG_fail;
7483 }
7484 }
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 result = (PyObject *)(arg1)->read(arg2);
7488
7489 wxPyEndAllowThreads(__tstate);
7490 if (PyErr_Occurred()) SWIG_fail;
7491 }
7492 resultobj = result;
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7500 PyObject *resultobj;
7501 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7502 int arg2 = (int) -1 ;
7503 PyObject *result;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self",(char *) "size", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 if (obj1) {
7514 {
7515 arg2 = (int)(SWIG_As_int(obj1));
7516 if (SWIG_arg_fail(2)) SWIG_fail;
7517 }
7518 }
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (PyObject *)(arg1)->readline(arg2);
7522
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 resultobj = result;
7527 return resultobj;
7528 fail:
7529 return NULL;
7530 }
7531
7532
7533 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7534 PyObject *resultobj;
7535 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7536 int arg2 = (int) -1 ;
7537 PyObject *result;
7538 PyObject * obj0 = 0 ;
7539 PyObject * obj1 = 0 ;
7540 char *kwnames[] = {
7541 (char *) "self",(char *) "sizehint", NULL
7542 };
7543
7544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7546 if (SWIG_arg_fail(1)) SWIG_fail;
7547 if (obj1) {
7548 {
7549 arg2 = (int)(SWIG_As_int(obj1));
7550 if (SWIG_arg_fail(2)) SWIG_fail;
7551 }
7552 }
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 result = (PyObject *)(arg1)->readlines(arg2);
7556
7557 wxPyEndAllowThreads(__tstate);
7558 if (PyErr_Occurred()) SWIG_fail;
7559 }
7560 resultobj = result;
7561 return resultobj;
7562 fail:
7563 return NULL;
7564 }
7565
7566
7567 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7568 PyObject *resultobj;
7569 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7570 int arg2 ;
7571 int arg3 = (int) 0 ;
7572 PyObject * obj0 = 0 ;
7573 PyObject * obj1 = 0 ;
7574 PyObject * obj2 = 0 ;
7575 char *kwnames[] = {
7576 (char *) "self",(char *) "offset",(char *) "whence", NULL
7577 };
7578
7579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7581 if (SWIG_arg_fail(1)) SWIG_fail;
7582 {
7583 arg2 = (int)(SWIG_As_int(obj1));
7584 if (SWIG_arg_fail(2)) SWIG_fail;
7585 }
7586 if (obj2) {
7587 {
7588 arg3 = (int)(SWIG_As_int(obj2));
7589 if (SWIG_arg_fail(3)) SWIG_fail;
7590 }
7591 }
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 (arg1)->seek(arg2,arg3);
7595
7596 wxPyEndAllowThreads(__tstate);
7597 if (PyErr_Occurred()) SWIG_fail;
7598 }
7599 Py_INCREF(Py_None); resultobj = Py_None;
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj;
7608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7609 int result;
7610 PyObject * obj0 = 0 ;
7611 char *kwnames[] = {
7612 (char *) "self", NULL
7613 };
7614
7615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7617 if (SWIG_arg_fail(1)) SWIG_fail;
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 result = (int)(arg1)->tell();
7621
7622 wxPyEndAllowThreads(__tstate);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 {
7626 resultobj = SWIG_From_int((int)(result));
7627 }
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7637 char result;
7638 PyObject * obj0 = 0 ;
7639 char *kwnames[] = {
7640 (char *) "self", NULL
7641 };
7642
7643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7645 if (SWIG_arg_fail(1)) SWIG_fail;
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (char)(arg1)->Peek();
7649
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = SWIG_From_char((char)(result));
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj;
7664 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7665 char result;
7666 PyObject * obj0 = 0 ;
7667 char *kwnames[] = {
7668 (char *) "self", NULL
7669 };
7670
7671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7673 if (SWIG_arg_fail(1)) SWIG_fail;
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 result = (char)(arg1)->GetC();
7677
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = SWIG_From_char((char)(result));
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj;
7692 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7693 size_t result;
7694 PyObject * obj0 = 0 ;
7695 char *kwnames[] = {
7696 (char *) "self", NULL
7697 };
7698
7699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7701 if (SWIG_arg_fail(1)) SWIG_fail;
7702 {
7703 PyThreadState* __tstate = wxPyBeginAllowThreads();
7704 result = (size_t)(arg1)->LastRead();
7705
7706 wxPyEndAllowThreads(__tstate);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7721 bool result;
7722 PyObject * obj0 = 0 ;
7723 char *kwnames[] = {
7724 (char *) "self", NULL
7725 };
7726
7727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7729 if (SWIG_arg_fail(1)) SWIG_fail;
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 result = (bool)(arg1)->CanRead();
7733
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 {
7738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7739 }
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj;
7748 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7749 bool result;
7750 PyObject * obj0 = 0 ;
7751 char *kwnames[] = {
7752 (char *) "self", NULL
7753 };
7754
7755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7757 if (SWIG_arg_fail(1)) SWIG_fail;
7758 {
7759 PyThreadState* __tstate = wxPyBeginAllowThreads();
7760 result = (bool)(arg1)->Eof();
7761
7762 wxPyEndAllowThreads(__tstate);
7763 if (PyErr_Occurred()) SWIG_fail;
7764 }
7765 {
7766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7767 }
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj;
7776 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7777 char arg2 ;
7778 bool result;
7779 PyObject * obj0 = 0 ;
7780 PyObject * obj1 = 0 ;
7781 char *kwnames[] = {
7782 (char *) "self",(char *) "c", NULL
7783 };
7784
7785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7787 if (SWIG_arg_fail(1)) SWIG_fail;
7788 {
7789 arg2 = (char)(SWIG_As_char(obj1));
7790 if (SWIG_arg_fail(2)) SWIG_fail;
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)(arg1)->Ungetch(arg2);
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7811 long arg2 ;
7812 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7813 long result;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 PyObject * obj2 = 0 ;
7817 char *kwnames[] = {
7818 (char *) "self",(char *) "pos",(char *) "mode", NULL
7819 };
7820
7821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7823 if (SWIG_arg_fail(1)) SWIG_fail;
7824 {
7825 arg2 = (long)(SWIG_As_long(obj1));
7826 if (SWIG_arg_fail(2)) SWIG_fail;
7827 }
7828 if (obj2) {
7829 {
7830 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7831 if (SWIG_arg_fail(3)) SWIG_fail;
7832 }
7833 }
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = SWIG_From_long((long)(result));
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 long result;
7854 PyObject * obj0 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "self", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (long)(arg1)->TellI();
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 {
7870 resultobj = SWIG_From_long((long)(result));
7871 }
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7879 PyObject *obj;
7880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7881 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7882 Py_INCREF(obj);
7883 return Py_BuildValue((char *)"");
7884 }
7885 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7886 PyObject *resultobj;
7887 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7888 PyObject *arg2 = (PyObject *) 0 ;
7889 PyObject * obj0 = 0 ;
7890 PyObject * obj1 = 0 ;
7891 char *kwnames[] = {
7892 (char *) "self",(char *) "obj", NULL
7893 };
7894
7895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7897 if (SWIG_arg_fail(1)) SWIG_fail;
7898 arg2 = obj1;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 wxOutputStream_write(arg1,arg2);
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 Py_INCREF(Py_None); resultobj = Py_None;
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7914 PyObject *obj;
7915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7916 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7917 Py_INCREF(obj);
7918 return Py_BuildValue((char *)"");
7919 }
7920 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj;
7922 wxInputStream *arg1 = (wxInputStream *) 0 ;
7923 wxString *arg2 = 0 ;
7924 wxString *arg3 = 0 ;
7925 wxString *arg4 = 0 ;
7926 wxDateTime arg5 ;
7927 wxFSFile *result;
7928 wxPyInputStream *temp1 ;
7929 bool temp2 = false ;
7930 bool temp3 = false ;
7931 bool temp4 = false ;
7932 PyObject * obj0 = 0 ;
7933 PyObject * obj1 = 0 ;
7934 PyObject * obj2 = 0 ;
7935 PyObject * obj3 = 0 ;
7936 PyObject * obj4 = 0 ;
7937 char *kwnames[] = {
7938 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7939 };
7940
7941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7942 {
7943 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7944 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7945 } else {
7946 PyErr_Clear(); // clear the failure of the wxPyConvert above
7947 arg1 = wxPyCBInputStream_create(obj0, true);
7948 if (arg1 == NULL) {
7949 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7950 SWIG_fail;
7951 }
7952 }
7953 }
7954 {
7955 arg2 = wxString_in_helper(obj1);
7956 if (arg2 == NULL) SWIG_fail;
7957 temp2 = true;
7958 }
7959 {
7960 arg3 = wxString_in_helper(obj2);
7961 if (arg3 == NULL) SWIG_fail;
7962 temp3 = true;
7963 }
7964 {
7965 arg4 = wxString_in_helper(obj3);
7966 if (arg4 == NULL) SWIG_fail;
7967 temp4 = true;
7968 }
7969 {
7970 wxDateTime * argp;
7971 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7972 if (SWIG_arg_fail(5)) SWIG_fail;
7973 if (argp == NULL) {
7974 SWIG_null_ref("wxDateTime");
7975 }
7976 if (SWIG_arg_fail(5)) SWIG_fail;
7977 arg5 = *argp;
7978 }
7979 {
7980 PyThreadState* __tstate = wxPyBeginAllowThreads();
7981 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7982
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 {
7987 resultobj = wxPyMake_wxObject(result, 1);
7988 }
7989 {
7990 if (temp2)
7991 delete arg2;
7992 }
7993 {
7994 if (temp3)
7995 delete arg3;
7996 }
7997 {
7998 if (temp4)
7999 delete arg4;
8000 }
8001 return resultobj;
8002 fail:
8003 {
8004 if (temp2)
8005 delete arg2;
8006 }
8007 {
8008 if (temp3)
8009 delete arg3;
8010 }
8011 {
8012 if (temp4)
8013 delete arg4;
8014 }
8015 return NULL;
8016 }
8017
8018
8019 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 wxFSFile *arg1 = (wxFSFile *) 0 ;
8022 PyObject * obj0 = 0 ;
8023 char *kwnames[] = {
8024 (char *) "self", NULL
8025 };
8026
8027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8029 if (SWIG_arg_fail(1)) SWIG_fail;
8030 {
8031 PyThreadState* __tstate = wxPyBeginAllowThreads();
8032 delete arg1;
8033
8034 wxPyEndAllowThreads(__tstate);
8035 if (PyErr_Occurred()) SWIG_fail;
8036 }
8037 Py_INCREF(Py_None); resultobj = Py_None;
8038 return resultobj;
8039 fail:
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxFSFile *arg1 = (wxFSFile *) 0 ;
8047 wxInputStream *result;
8048 PyObject * obj0 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (wxInputStream *)(arg1)->GetStream();
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 {
8064 wxPyInputStream * _ptr = NULL;
8065
8066 if (result) {
8067 _ptr = new wxPyInputStream(result);
8068 }
8069 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8070 }
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8078 PyObject *resultobj;
8079 wxFSFile *arg1 = (wxFSFile *) 0 ;
8080 wxString *result;
8081 PyObject * obj0 = 0 ;
8082 char *kwnames[] = {
8083 (char *) "self", NULL
8084 };
8085
8086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(1)) SWIG_fail;
8089 {
8090 PyThreadState* __tstate = wxPyBeginAllowThreads();
8091 {
8092 wxString const &_result_ref = (arg1)->GetMimeType();
8093 result = (wxString *) &_result_ref;
8094 }
8095
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 {
8100 #if wxUSE_UNICODE
8101 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8102 #else
8103 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8104 #endif
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj;
8114 wxFSFile *arg1 = (wxFSFile *) 0 ;
8115 wxString *result;
8116 PyObject * obj0 = 0 ;
8117 char *kwnames[] = {
8118 (char *) "self", NULL
8119 };
8120
8121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8123 if (SWIG_arg_fail(1)) SWIG_fail;
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 {
8127 wxString const &_result_ref = (arg1)->GetLocation();
8128 result = (wxString *) &_result_ref;
8129 }
8130
8131 wxPyEndAllowThreads(__tstate);
8132 if (PyErr_Occurred()) SWIG_fail;
8133 }
8134 {
8135 #if wxUSE_UNICODE
8136 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8137 #else
8138 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8139 #endif
8140 }
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxFSFile *arg1 = (wxFSFile *) 0 ;
8150 wxString *result;
8151 PyObject * obj0 = 0 ;
8152 char *kwnames[] = {
8153 (char *) "self", NULL
8154 };
8155
8156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8158 if (SWIG_arg_fail(1)) SWIG_fail;
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 {
8162 wxString const &_result_ref = (arg1)->GetAnchor();
8163 result = (wxString *) &_result_ref;
8164 }
8165
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 #if wxUSE_UNICODE
8171 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8172 #else
8173 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8174 #endif
8175 }
8176 return resultobj;
8177 fail:
8178 return NULL;
8179 }
8180
8181
8182 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj;
8184 wxFSFile *arg1 = (wxFSFile *) 0 ;
8185 wxDateTime result;
8186 PyObject * obj0 = 0 ;
8187 char *kwnames[] = {
8188 (char *) "self", NULL
8189 };
8190
8191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8193 if (SWIG_arg_fail(1)) SWIG_fail;
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (arg1)->GetModificationTime();
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 wxDateTime * resultptr;
8203 resultptr = new wxDateTime((wxDateTime &)(result));
8204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8205 }
8206 return resultobj;
8207 fail:
8208 return NULL;
8209 }
8210
8211
8212 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8213 PyObject *obj;
8214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8215 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8216 Py_INCREF(obj);
8217 return Py_BuildValue((char *)"");
8218 }
8219 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8220 PyObject *obj;
8221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8222 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8223 Py_INCREF(obj);
8224 return Py_BuildValue((char *)"");
8225 }
8226 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8227 PyObject *resultobj;
8228 wxPyFileSystemHandler *result;
8229 char *kwnames[] = {
8230 NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8251 PyObject *arg2 = (PyObject *) 0 ;
8252 PyObject *arg3 = (PyObject *) 0 ;
8253 PyObject * obj0 = 0 ;
8254 PyObject * obj1 = 0 ;
8255 PyObject * obj2 = 0 ;
8256 char *kwnames[] = {
8257 (char *) "self",(char *) "self",(char *) "_class", NULL
8258 };
8259
8260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8262 if (SWIG_arg_fail(1)) SWIG_fail;
8263 arg2 = obj1;
8264 arg3 = obj2;
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 (arg1)->_setCallbackInfo(arg2,arg3);
8268
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 Py_INCREF(Py_None); resultobj = Py_None;
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8282 wxString *arg2 = 0 ;
8283 bool result;
8284 bool temp2 = false ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "self",(char *) "location", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 {
8295 arg2 = wxString_in_helper(obj1);
8296 if (arg2 == NULL) SWIG_fail;
8297 temp2 = true;
8298 }
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8302
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 {
8307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8308 }
8309 {
8310 if (temp2)
8311 delete arg2;
8312 }
8313 return resultobj;
8314 fail:
8315 {
8316 if (temp2)
8317 delete arg2;
8318 }
8319 return NULL;
8320 }
8321
8322
8323 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8326 wxFileSystem *arg2 = 0 ;
8327 wxString *arg3 = 0 ;
8328 wxFSFile *result;
8329 bool temp3 = false ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 PyObject * obj2 = 0 ;
8333 char *kwnames[] = {
8334 (char *) "self",(char *) "fs",(char *) "location", NULL
8335 };
8336
8337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8339 if (SWIG_arg_fail(1)) SWIG_fail;
8340 {
8341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8342 if (SWIG_arg_fail(2)) SWIG_fail;
8343 if (arg2 == NULL) {
8344 SWIG_null_ref("wxFileSystem");
8345 }
8346 if (SWIG_arg_fail(2)) SWIG_fail;
8347 }
8348 {
8349 arg3 = wxString_in_helper(obj2);
8350 if (arg3 == NULL) SWIG_fail;
8351 temp3 = true;
8352 }
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8356
8357 wxPyEndAllowThreads(__tstate);
8358 if (PyErr_Occurred()) SWIG_fail;
8359 }
8360 {
8361 resultobj = wxPyMake_wxObject(result, 1);
8362 }
8363 {
8364 if (temp3)
8365 delete arg3;
8366 }
8367 return resultobj;
8368 fail:
8369 {
8370 if (temp3)
8371 delete arg3;
8372 }
8373 return NULL;
8374 }
8375
8376
8377 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj;
8379 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8380 wxString *arg2 = 0 ;
8381 int arg3 = (int) 0 ;
8382 wxString result;
8383 bool temp2 = false ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "spec",(char *) "flags", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 {
8395 arg2 = wxString_in_helper(obj1);
8396 if (arg2 == NULL) SWIG_fail;
8397 temp2 = true;
8398 }
8399 if (obj2) {
8400 {
8401 arg3 = (int)(SWIG_As_int(obj2));
8402 if (SWIG_arg_fail(3)) SWIG_fail;
8403 }
8404 }
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 {
8413 #if wxUSE_UNICODE
8414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8415 #else
8416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8417 #endif
8418 }
8419 {
8420 if (temp2)
8421 delete arg2;
8422 }
8423 return resultobj;
8424 fail:
8425 {
8426 if (temp2)
8427 delete arg2;
8428 }
8429 return NULL;
8430 }
8431
8432
8433 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8434 PyObject *resultobj;
8435 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8436 wxString result;
8437 PyObject * obj0 = 0 ;
8438 char *kwnames[] = {
8439 (char *) "self", NULL
8440 };
8441
8442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8444 if (SWIG_arg_fail(1)) SWIG_fail;
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 result = (arg1)->FindNext();
8448
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 {
8453 #if wxUSE_UNICODE
8454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8455 #else
8456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8457 #endif
8458 }
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString *arg2 = 0 ;
8469 wxString result;
8470 bool temp2 = false ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char *kwnames[] = {
8474 (char *) "self",(char *) "location", NULL
8475 };
8476
8477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8479 if (SWIG_arg_fail(1)) SWIG_fail;
8480 {
8481 arg2 = wxString_in_helper(obj1);
8482 if (arg2 == NULL) SWIG_fail;
8483 temp2 = true;
8484 }
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = (arg1)->GetProtocol((wxString const &)*arg2);
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 #if wxUSE_UNICODE
8494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8495 #else
8496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8497 #endif
8498 }
8499 {
8500 if (temp2)
8501 delete arg2;
8502 }
8503 return resultobj;
8504 fail:
8505 {
8506 if (temp2)
8507 delete arg2;
8508 }
8509 return NULL;
8510 }
8511
8512
8513 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8514 PyObject *resultobj;
8515 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8516 wxString *arg2 = 0 ;
8517 wxString result;
8518 bool temp2 = false ;
8519 PyObject * obj0 = 0 ;
8520 PyObject * obj1 = 0 ;
8521 char *kwnames[] = {
8522 (char *) "self",(char *) "location", NULL
8523 };
8524
8525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8527 if (SWIG_arg_fail(1)) SWIG_fail;
8528 {
8529 arg2 = wxString_in_helper(obj1);
8530 if (arg2 == NULL) SWIG_fail;
8531 temp2 = true;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8536
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 {
8541 #if wxUSE_UNICODE
8542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8543 #else
8544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8545 #endif
8546 }
8547 {
8548 if (temp2)
8549 delete arg2;
8550 }
8551 return resultobj;
8552 fail:
8553 {
8554 if (temp2)
8555 delete arg2;
8556 }
8557 return NULL;
8558 }
8559
8560
8561 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8562 PyObject *resultobj;
8563 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8564 wxString *arg2 = 0 ;
8565 wxString result;
8566 bool temp2 = false ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char *kwnames[] = {
8570 (char *) "self",(char *) "location", NULL
8571 };
8572
8573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8575 if (SWIG_arg_fail(1)) SWIG_fail;
8576 {
8577 arg2 = wxString_in_helper(obj1);
8578 if (arg2 == NULL) SWIG_fail;
8579 temp2 = true;
8580 }
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (arg1)->GetAnchor((wxString const &)*arg2);
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 {
8589 #if wxUSE_UNICODE
8590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8591 #else
8592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8593 #endif
8594 }
8595 {
8596 if (temp2)
8597 delete arg2;
8598 }
8599 return resultobj;
8600 fail:
8601 {
8602 if (temp2)
8603 delete arg2;
8604 }
8605 return NULL;
8606 }
8607
8608
8609 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8610 PyObject *resultobj;
8611 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8612 wxString *arg2 = 0 ;
8613 wxString result;
8614 bool temp2 = false ;
8615 PyObject * obj0 = 0 ;
8616 PyObject * obj1 = 0 ;
8617 char *kwnames[] = {
8618 (char *) "self",(char *) "location", NULL
8619 };
8620
8621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8623 if (SWIG_arg_fail(1)) SWIG_fail;
8624 {
8625 arg2 = wxString_in_helper(obj1);
8626 if (arg2 == NULL) SWIG_fail;
8627 temp2 = true;
8628 }
8629 {
8630 PyThreadState* __tstate = wxPyBeginAllowThreads();
8631 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8632
8633 wxPyEndAllowThreads(__tstate);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 {
8637 #if wxUSE_UNICODE
8638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8639 #else
8640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8641 #endif
8642 }
8643 {
8644 if (temp2)
8645 delete arg2;
8646 }
8647 return resultobj;
8648 fail:
8649 {
8650 if (temp2)
8651 delete arg2;
8652 }
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj;
8659 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8660 wxString *arg2 = 0 ;
8661 wxString result;
8662 bool temp2 = false ;
8663 PyObject * obj0 = 0 ;
8664 PyObject * obj1 = 0 ;
8665 char *kwnames[] = {
8666 (char *) "self",(char *) "location", NULL
8667 };
8668
8669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8671 if (SWIG_arg_fail(1)) SWIG_fail;
8672 {
8673 arg2 = wxString_in_helper(obj1);
8674 if (arg2 == NULL) SWIG_fail;
8675 temp2 = true;
8676 }
8677 {
8678 PyThreadState* __tstate = wxPyBeginAllowThreads();
8679 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8680
8681 wxPyEndAllowThreads(__tstate);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 {
8685 #if wxUSE_UNICODE
8686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8687 #else
8688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8689 #endif
8690 }
8691 {
8692 if (temp2)
8693 delete arg2;
8694 }
8695 return resultobj;
8696 fail:
8697 {
8698 if (temp2)
8699 delete arg2;
8700 }
8701 return NULL;
8702 }
8703
8704
8705 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8706 PyObject *obj;
8707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8708 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8709 Py_INCREF(obj);
8710 return Py_BuildValue((char *)"");
8711 }
8712 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj;
8714 wxFileSystem *result;
8715 char *kwnames[] = {
8716 NULL
8717 };
8718
8719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8720 {
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 result = (wxFileSystem *)new wxFileSystem();
8723
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 {
8728 resultobj = wxPyMake_wxObject(result, 1);
8729 }
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8739 PyObject * obj0 = 0 ;
8740 char *kwnames[] = {
8741 (char *) "self", NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8746 if (SWIG_arg_fail(1)) SWIG_fail;
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 delete arg1;
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 Py_INCREF(Py_None); resultobj = Py_None;
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj;
8763 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8764 wxString *arg2 = 0 ;
8765 bool arg3 = (bool) false ;
8766 bool temp2 = false ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 PyObject * obj2 = 0 ;
8770 char *kwnames[] = {
8771 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8772 };
8773
8774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8776 if (SWIG_arg_fail(1)) SWIG_fail;
8777 {
8778 arg2 = wxString_in_helper(obj1);
8779 if (arg2 == NULL) SWIG_fail;
8780 temp2 = true;
8781 }
8782 if (obj2) {
8783 {
8784 arg3 = (bool)(SWIG_As_bool(obj2));
8785 if (SWIG_arg_fail(3)) SWIG_fail;
8786 }
8787 }
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8791
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 Py_INCREF(Py_None); resultobj = Py_None;
8796 {
8797 if (temp2)
8798 delete arg2;
8799 }
8800 return resultobj;
8801 fail:
8802 {
8803 if (temp2)
8804 delete arg2;
8805 }
8806 return NULL;
8807 }
8808
8809
8810 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj;
8812 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8813 wxString result;
8814 PyObject * obj0 = 0 ;
8815 char *kwnames[] = {
8816 (char *) "self", NULL
8817 };
8818
8819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8821 if (SWIG_arg_fail(1)) SWIG_fail;
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 result = (arg1)->GetPath();
8825
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 {
8830 #if wxUSE_UNICODE
8831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8832 #else
8833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8834 #endif
8835 }
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8845 wxString *arg2 = 0 ;
8846 wxFSFile *result;
8847 bool temp2 = false ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 char *kwnames[] = {
8851 (char *) "self",(char *) "location", NULL
8852 };
8853
8854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8856 if (SWIG_arg_fail(1)) SWIG_fail;
8857 {
8858 arg2 = wxString_in_helper(obj1);
8859 if (arg2 == NULL) SWIG_fail;
8860 temp2 = true;
8861 }
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 {
8870 resultobj = wxPyMake_wxObject(result, 1);
8871 }
8872 {
8873 if (temp2)
8874 delete arg2;
8875 }
8876 return resultobj;
8877 fail:
8878 {
8879 if (temp2)
8880 delete arg2;
8881 }
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj;
8888 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8889 wxString *arg2 = 0 ;
8890 int arg3 = (int) 0 ;
8891 wxString result;
8892 bool temp2 = false ;
8893 PyObject * obj0 = 0 ;
8894 PyObject * obj1 = 0 ;
8895 PyObject * obj2 = 0 ;
8896 char *kwnames[] = {
8897 (char *) "self",(char *) "spec",(char *) "flags", NULL
8898 };
8899
8900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8902 if (SWIG_arg_fail(1)) SWIG_fail;
8903 {
8904 arg2 = wxString_in_helper(obj1);
8905 if (arg2 == NULL) SWIG_fail;
8906 temp2 = true;
8907 }
8908 if (obj2) {
8909 {
8910 arg3 = (int)(SWIG_As_int(obj2));
8911 if (SWIG_arg_fail(3)) SWIG_fail;
8912 }
8913 }
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8917
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 {
8922 #if wxUSE_UNICODE
8923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8924 #else
8925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8926 #endif
8927 }
8928 {
8929 if (temp2)
8930 delete arg2;
8931 }
8932 return resultobj;
8933 fail:
8934 {
8935 if (temp2)
8936 delete arg2;
8937 }
8938 return NULL;
8939 }
8940
8941
8942 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8943 PyObject *resultobj;
8944 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8945 wxString result;
8946 PyObject * obj0 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "self", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 result = (arg1)->FindNext();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 {
8962 #if wxUSE_UNICODE
8963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8964 #else
8965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8966 #endif
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8977 PyObject * obj0 = 0 ;
8978 char *kwnames[] = {
8979 (char *) "handler", NULL
8980 };
8981
8982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8984 if (SWIG_arg_fail(1)) SWIG_fail;
8985 {
8986 PyThreadState* __tstate = wxPyBeginAllowThreads();
8987 wxFileSystem::AddHandler(arg1);
8988
8989 wxPyEndAllowThreads(__tstate);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 Py_INCREF(Py_None); resultobj = Py_None;
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 char *kwnames[] = {
9002 NULL
9003 };
9004
9005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 wxFileSystem::CleanUpHandlers();
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 Py_INCREF(Py_None); resultobj = Py_None;
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj;
9022 wxString *arg1 = 0 ;
9023 wxString result;
9024 bool temp1 = false ;
9025 PyObject * obj0 = 0 ;
9026 char *kwnames[] = {
9027 (char *) "filename", NULL
9028 };
9029
9030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9031 {
9032 arg1 = wxString_in_helper(obj0);
9033 if (arg1 == NULL) SWIG_fail;
9034 temp1 = true;
9035 }
9036 {
9037 PyThreadState* __tstate = wxPyBeginAllowThreads();
9038 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9039
9040 wxPyEndAllowThreads(__tstate);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 {
9044 #if wxUSE_UNICODE
9045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9046 #else
9047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9048 #endif
9049 }
9050 {
9051 if (temp1)
9052 delete arg1;
9053 }
9054 return resultobj;
9055 fail:
9056 {
9057 if (temp1)
9058 delete arg1;
9059 }
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 wxString *arg1 = 0 ;
9067 wxString result;
9068 bool temp1 = false ;
9069 PyObject * obj0 = 0 ;
9070 char *kwnames[] = {
9071 (char *) "url", NULL
9072 };
9073
9074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9075 {
9076 arg1 = wxString_in_helper(obj0);
9077 if (arg1 == NULL) SWIG_fail;
9078 temp1 = true;
9079 }
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 result = FileSystem_URLToFileName((wxString const &)*arg1);
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 {
9088 #if wxUSE_UNICODE
9089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9090 #else
9091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9092 #endif
9093 }
9094 {
9095 if (temp1)
9096 delete arg1;
9097 }
9098 return resultobj;
9099 fail:
9100 {
9101 if (temp1)
9102 delete arg1;
9103 }
9104 return NULL;
9105 }
9106
9107
9108 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9109 PyObject *obj;
9110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9111 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9112 Py_INCREF(obj);
9113 return Py_BuildValue((char *)"");
9114 }
9115 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj;
9117 wxInternetFSHandler *result;
9118 char *kwnames[] = {
9119 NULL
9120 };
9121
9122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9140 wxString *arg2 = 0 ;
9141 bool result;
9142 bool temp2 = false ;
9143 PyObject * obj0 = 0 ;
9144 PyObject * obj1 = 0 ;
9145 char *kwnames[] = {
9146 (char *) "self",(char *) "location", NULL
9147 };
9148
9149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9151 if (SWIG_arg_fail(1)) SWIG_fail;
9152 {
9153 arg2 = wxString_in_helper(obj1);
9154 if (arg2 == NULL) SWIG_fail;
9155 temp2 = true;
9156 }
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9160
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 {
9165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9166 }
9167 {
9168 if (temp2)
9169 delete arg2;
9170 }
9171 return resultobj;
9172 fail:
9173 {
9174 if (temp2)
9175 delete arg2;
9176 }
9177 return NULL;
9178 }
9179
9180
9181 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj;
9183 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9184 wxFileSystem *arg2 = 0 ;
9185 wxString *arg3 = 0 ;
9186 wxFSFile *result;
9187 bool temp3 = false ;
9188 PyObject * obj0 = 0 ;
9189 PyObject * obj1 = 0 ;
9190 PyObject * obj2 = 0 ;
9191 char *kwnames[] = {
9192 (char *) "self",(char *) "fs",(char *) "location", NULL
9193 };
9194
9195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9197 if (SWIG_arg_fail(1)) SWIG_fail;
9198 {
9199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9200 if (SWIG_arg_fail(2)) SWIG_fail;
9201 if (arg2 == NULL) {
9202 SWIG_null_ref("wxFileSystem");
9203 }
9204 if (SWIG_arg_fail(2)) SWIG_fail;
9205 }
9206 {
9207 arg3 = wxString_in_helper(obj2);
9208 if (arg3 == NULL) SWIG_fail;
9209 temp3 = true;
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9214
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 {
9219 resultobj = wxPyMake_wxObject(result, 1);
9220 }
9221 {
9222 if (temp3)
9223 delete arg3;
9224 }
9225 return resultobj;
9226 fail:
9227 {
9228 if (temp3)
9229 delete arg3;
9230 }
9231 return NULL;
9232 }
9233
9234
9235 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9236 PyObject *obj;
9237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9238 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9239 Py_INCREF(obj);
9240 return Py_BuildValue((char *)"");
9241 }
9242 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj;
9244 wxZipFSHandler *result;
9245 char *kwnames[] = {
9246 NULL
9247 };
9248
9249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9250 {
9251 PyThreadState* __tstate = wxPyBeginAllowThreads();
9252 result = (wxZipFSHandler *)new wxZipFSHandler();
9253
9254 wxPyEndAllowThreads(__tstate);
9255 if (PyErr_Occurred()) SWIG_fail;
9256 }
9257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9258 return resultobj;
9259 fail:
9260 return NULL;
9261 }
9262
9263
9264 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9265 PyObject *resultobj;
9266 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9267 wxString *arg2 = 0 ;
9268 bool result;
9269 bool temp2 = false ;
9270 PyObject * obj0 = 0 ;
9271 PyObject * obj1 = 0 ;
9272 char *kwnames[] = {
9273 (char *) "self",(char *) "location", NULL
9274 };
9275
9276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9278 if (SWIG_arg_fail(1)) SWIG_fail;
9279 {
9280 arg2 = wxString_in_helper(obj1);
9281 if (arg2 == NULL) SWIG_fail;
9282 temp2 = true;
9283 }
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 {
9292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9293 }
9294 {
9295 if (temp2)
9296 delete arg2;
9297 }
9298 return resultobj;
9299 fail:
9300 {
9301 if (temp2)
9302 delete arg2;
9303 }
9304 return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9309 PyObject *resultobj;
9310 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9311 wxFileSystem *arg2 = 0 ;
9312 wxString *arg3 = 0 ;
9313 wxFSFile *result;
9314 bool temp3 = false ;
9315 PyObject * obj0 = 0 ;
9316 PyObject * obj1 = 0 ;
9317 PyObject * obj2 = 0 ;
9318 char *kwnames[] = {
9319 (char *) "self",(char *) "fs",(char *) "location", NULL
9320 };
9321
9322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9324 if (SWIG_arg_fail(1)) SWIG_fail;
9325 {
9326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9327 if (SWIG_arg_fail(2)) SWIG_fail;
9328 if (arg2 == NULL) {
9329 SWIG_null_ref("wxFileSystem");
9330 }
9331 if (SWIG_arg_fail(2)) SWIG_fail;
9332 }
9333 {
9334 arg3 = wxString_in_helper(obj2);
9335 if (arg3 == NULL) SWIG_fail;
9336 temp3 = true;
9337 }
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9341
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 {
9346 resultobj = wxPyMake_wxObject(result, 1);
9347 }
9348 {
9349 if (temp3)
9350 delete arg3;
9351 }
9352 return resultobj;
9353 fail:
9354 {
9355 if (temp3)
9356 delete arg3;
9357 }
9358 return NULL;
9359 }
9360
9361
9362 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9363 PyObject *resultobj;
9364 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9365 wxString *arg2 = 0 ;
9366 int arg3 = (int) 0 ;
9367 wxString result;
9368 bool temp2 = false ;
9369 PyObject * obj0 = 0 ;
9370 PyObject * obj1 = 0 ;
9371 PyObject * obj2 = 0 ;
9372 char *kwnames[] = {
9373 (char *) "self",(char *) "spec",(char *) "flags", NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9378 if (SWIG_arg_fail(1)) SWIG_fail;
9379 {
9380 arg2 = wxString_in_helper(obj1);
9381 if (arg2 == NULL) SWIG_fail;
9382 temp2 = true;
9383 }
9384 if (obj2) {
9385 {
9386 arg3 = (int)(SWIG_As_int(obj2));
9387 if (SWIG_arg_fail(3)) SWIG_fail;
9388 }
9389 }
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 {
9398 #if wxUSE_UNICODE
9399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9400 #else
9401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9402 #endif
9403 }
9404 {
9405 if (temp2)
9406 delete arg2;
9407 }
9408 return resultobj;
9409 fail:
9410 {
9411 if (temp2)
9412 delete arg2;
9413 }
9414 return NULL;
9415 }
9416
9417
9418 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9419 PyObject *resultobj;
9420 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9421 wxString result;
9422 PyObject * obj0 = 0 ;
9423 char *kwnames[] = {
9424 (char *) "self", NULL
9425 };
9426
9427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9429 if (SWIG_arg_fail(1)) SWIG_fail;
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (arg1)->FindNext();
9433
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 {
9438 #if wxUSE_UNICODE
9439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9440 #else
9441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9442 #endif
9443 }
9444 return resultobj;
9445 fail:
9446 return NULL;
9447 }
9448
9449
9450 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9451 PyObject *obj;
9452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9453 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9454 Py_INCREF(obj);
9455 return Py_BuildValue((char *)"");
9456 }
9457 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9458 PyObject *resultobj;
9459 wxString *arg1 = 0 ;
9460 wxImage *arg2 = 0 ;
9461 long arg3 ;
9462 bool temp1 = false ;
9463 PyObject * obj0 = 0 ;
9464 PyObject * obj1 = 0 ;
9465 PyObject * obj2 = 0 ;
9466 char *kwnames[] = {
9467 (char *) "filename",(char *) "image",(char *) "type", NULL
9468 };
9469
9470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9471 {
9472 arg1 = wxString_in_helper(obj0);
9473 if (arg1 == NULL) SWIG_fail;
9474 temp1 = true;
9475 }
9476 {
9477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9478 if (SWIG_arg_fail(2)) SWIG_fail;
9479 if (arg2 == NULL) {
9480 SWIG_null_ref("wxImage");
9481 }
9482 if (SWIG_arg_fail(2)) SWIG_fail;
9483 }
9484 {
9485 arg3 = (long)(SWIG_As_long(obj2));
9486 if (SWIG_arg_fail(3)) SWIG_fail;
9487 }
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9491
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 Py_INCREF(Py_None); resultobj = Py_None;
9496 {
9497 if (temp1)
9498 delete arg1;
9499 }
9500 return resultobj;
9501 fail:
9502 {
9503 if (temp1)
9504 delete arg1;
9505 }
9506 return NULL;
9507 }
9508
9509
9510 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj;
9512 wxString *arg1 = 0 ;
9513 wxBitmap *arg2 = 0 ;
9514 long arg3 ;
9515 bool temp1 = false ;
9516 PyObject * obj0 = 0 ;
9517 PyObject * obj1 = 0 ;
9518 PyObject * obj2 = 0 ;
9519 char *kwnames[] = {
9520 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9521 };
9522
9523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9524 {
9525 arg1 = wxString_in_helper(obj0);
9526 if (arg1 == NULL) SWIG_fail;
9527 temp1 = true;
9528 }
9529 {
9530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9531 if (SWIG_arg_fail(2)) SWIG_fail;
9532 if (arg2 == NULL) {
9533 SWIG_null_ref("wxBitmap");
9534 }
9535 if (SWIG_arg_fail(2)) SWIG_fail;
9536 }
9537 {
9538 arg3 = (long)(SWIG_As_long(obj2));
9539 if (SWIG_arg_fail(3)) SWIG_fail;
9540 }
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9544
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 Py_INCREF(Py_None); resultobj = Py_None;
9549 {
9550 if (temp1)
9551 delete arg1;
9552 }
9553 return resultobj;
9554 fail:
9555 {
9556 if (temp1)
9557 delete arg1;
9558 }
9559 return NULL;
9560 }
9561
9562
9563 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9564 PyObject *resultobj;
9565 wxString *arg1 = 0 ;
9566 PyObject *arg2 = (PyObject *) 0 ;
9567 bool temp1 = false ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "filename",(char *) "data", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9575 {
9576 arg1 = wxString_in_helper(obj0);
9577 if (arg1 == NULL) SWIG_fail;
9578 temp1 = true;
9579 }
9580 arg2 = obj1;
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9584
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 Py_INCREF(Py_None); resultobj = Py_None;
9589 {
9590 if (temp1)
9591 delete arg1;
9592 }
9593 return resultobj;
9594 fail:
9595 {
9596 if (temp1)
9597 delete arg1;
9598 }
9599 return NULL;
9600 }
9601
9602
9603 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj;
9605 wxMemoryFSHandler *result;
9606 char *kwnames[] = {
9607 NULL
9608 };
9609
9610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9614
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj;
9627 wxString *arg1 = 0 ;
9628 bool temp1 = false ;
9629 PyObject * obj0 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "filename", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9635 {
9636 arg1 = wxString_in_helper(obj0);
9637 if (arg1 == NULL) SWIG_fail;
9638 temp1 = true;
9639 }
9640 {
9641 PyThreadState* __tstate = wxPyBeginAllowThreads();
9642 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9643
9644 wxPyEndAllowThreads(__tstate);
9645 if (PyErr_Occurred()) SWIG_fail;
9646 }
9647 Py_INCREF(Py_None); resultobj = Py_None;
9648 {
9649 if (temp1)
9650 delete arg1;
9651 }
9652 return resultobj;
9653 fail:
9654 {
9655 if (temp1)
9656 delete arg1;
9657 }
9658 return NULL;
9659 }
9660
9661
9662 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj;
9664 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9665 wxString *arg2 = 0 ;
9666 bool result;
9667 bool temp2 = false ;
9668 PyObject * obj0 = 0 ;
9669 PyObject * obj1 = 0 ;
9670 char *kwnames[] = {
9671 (char *) "self",(char *) "location", NULL
9672 };
9673
9674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9676 if (SWIG_arg_fail(1)) SWIG_fail;
9677 {
9678 arg2 = wxString_in_helper(obj1);
9679 if (arg2 == NULL) SWIG_fail;
9680 temp2 = true;
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 {
9690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9691 }
9692 {
9693 if (temp2)
9694 delete arg2;
9695 }
9696 return resultobj;
9697 fail:
9698 {
9699 if (temp2)
9700 delete arg2;
9701 }
9702 return NULL;
9703 }
9704
9705
9706 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9707 PyObject *resultobj;
9708 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9709 wxFileSystem *arg2 = 0 ;
9710 wxString *arg3 = 0 ;
9711 wxFSFile *result;
9712 bool temp3 = false ;
9713 PyObject * obj0 = 0 ;
9714 PyObject * obj1 = 0 ;
9715 PyObject * obj2 = 0 ;
9716 char *kwnames[] = {
9717 (char *) "self",(char *) "fs",(char *) "location", NULL
9718 };
9719
9720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9722 if (SWIG_arg_fail(1)) SWIG_fail;
9723 {
9724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9725 if (SWIG_arg_fail(2)) SWIG_fail;
9726 if (arg2 == NULL) {
9727 SWIG_null_ref("wxFileSystem");
9728 }
9729 if (SWIG_arg_fail(2)) SWIG_fail;
9730 }
9731 {
9732 arg3 = wxString_in_helper(obj2);
9733 if (arg3 == NULL) SWIG_fail;
9734 temp3 = true;
9735 }
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9739
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 {
9744 resultobj = wxPyMake_wxObject(result, 1);
9745 }
9746 {
9747 if (temp3)
9748 delete arg3;
9749 }
9750 return resultobj;
9751 fail:
9752 {
9753 if (temp3)
9754 delete arg3;
9755 }
9756 return NULL;
9757 }
9758
9759
9760 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9761 PyObject *resultobj;
9762 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9763 wxString *arg2 = 0 ;
9764 int arg3 = (int) 0 ;
9765 wxString result;
9766 bool temp2 = false ;
9767 PyObject * obj0 = 0 ;
9768 PyObject * obj1 = 0 ;
9769 PyObject * obj2 = 0 ;
9770 char *kwnames[] = {
9771 (char *) "self",(char *) "spec",(char *) "flags", NULL
9772 };
9773
9774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9776 if (SWIG_arg_fail(1)) SWIG_fail;
9777 {
9778 arg2 = wxString_in_helper(obj1);
9779 if (arg2 == NULL) SWIG_fail;
9780 temp2 = true;
9781 }
9782 if (obj2) {
9783 {
9784 arg3 = (int)(SWIG_As_int(obj2));
9785 if (SWIG_arg_fail(3)) SWIG_fail;
9786 }
9787 }
9788 {
9789 PyThreadState* __tstate = wxPyBeginAllowThreads();
9790 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9791
9792 wxPyEndAllowThreads(__tstate);
9793 if (PyErr_Occurred()) SWIG_fail;
9794 }
9795 {
9796 #if wxUSE_UNICODE
9797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9798 #else
9799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9800 #endif
9801 }
9802 {
9803 if (temp2)
9804 delete arg2;
9805 }
9806 return resultobj;
9807 fail:
9808 {
9809 if (temp2)
9810 delete arg2;
9811 }
9812 return NULL;
9813 }
9814
9815
9816 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj;
9818 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9819 wxString result;
9820 PyObject * obj0 = 0 ;
9821 char *kwnames[] = {
9822 (char *) "self", NULL
9823 };
9824
9825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9827 if (SWIG_arg_fail(1)) SWIG_fail;
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 result = (arg1)->FindNext();
9831
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 {
9836 #if wxUSE_UNICODE
9837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9838 #else
9839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9840 #endif
9841 }
9842 return resultobj;
9843 fail:
9844 return NULL;
9845 }
9846
9847
9848 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9849 PyObject *obj;
9850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9851 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9852 Py_INCREF(obj);
9853 return Py_BuildValue((char *)"");
9854 }
9855 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj;
9857 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9858 wxString result;
9859 PyObject * obj0 = 0 ;
9860 char *kwnames[] = {
9861 (char *) "self", NULL
9862 };
9863
9864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9866 if (SWIG_arg_fail(1)) SWIG_fail;
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = (arg1)->GetName();
9870
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 #if wxUSE_UNICODE
9876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9877 #else
9878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9879 #endif
9880 }
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 static PyObject *_wrap_ImageHandler_GetExtension(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:ImageHandler_GetExtension",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)->GetExtension();
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_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 long result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",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 = (long)(arg1)->GetType();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 resultobj = SWIG_From_long((long)(result));
9940 }
9941 return resultobj;
9942 fail:
9943 return NULL;
9944 }
9945
9946
9947 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9948 PyObject *resultobj;
9949 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9950 wxString result;
9951 PyObject * obj0 = 0 ;
9952 char *kwnames[] = {
9953 (char *) "self", NULL
9954 };
9955
9956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9958 if (SWIG_arg_fail(1)) SWIG_fail;
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 result = (arg1)->GetMimeType();
9962
9963 wxPyEndAllowThreads(__tstate);
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 {
9967 #if wxUSE_UNICODE
9968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9969 #else
9970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9971 #endif
9972 }
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj;
9981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9982 wxString *arg2 = 0 ;
9983 bool result;
9984 bool temp2 = false ;
9985 PyObject * obj0 = 0 ;
9986 PyObject * obj1 = 0 ;
9987 char *kwnames[] = {
9988 (char *) "self",(char *) "name", NULL
9989 };
9990
9991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9993 if (SWIG_arg_fail(1)) SWIG_fail;
9994 {
9995 arg2 = wxString_in_helper(obj1);
9996 if (arg2 == NULL) SWIG_fail;
9997 temp2 = true;
9998 }
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 {
10007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10008 }
10009 {
10010 if (temp2)
10011 delete arg2;
10012 }
10013 return resultobj;
10014 fail:
10015 {
10016 if (temp2)
10017 delete arg2;
10018 }
10019 return NULL;
10020 }
10021
10022
10023 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10024 PyObject *resultobj;
10025 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10026 wxString *arg2 = 0 ;
10027 bool temp2 = false ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char *kwnames[] = {
10031 (char *) "self",(char *) "name", NULL
10032 };
10033
10034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10036 if (SWIG_arg_fail(1)) SWIG_fail;
10037 {
10038 arg2 = wxString_in_helper(obj1);
10039 if (arg2 == NULL) SWIG_fail;
10040 temp2 = true;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 (arg1)->SetName((wxString const &)*arg2);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 Py_INCREF(Py_None); resultobj = Py_None;
10050 {
10051 if (temp2)
10052 delete arg2;
10053 }
10054 return resultobj;
10055 fail:
10056 {
10057 if (temp2)
10058 delete arg2;
10059 }
10060 return NULL;
10061 }
10062
10063
10064 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj;
10066 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10067 wxString *arg2 = 0 ;
10068 bool temp2 = false ;
10069 PyObject * obj0 = 0 ;
10070 PyObject * obj1 = 0 ;
10071 char *kwnames[] = {
10072 (char *) "self",(char *) "extension", NULL
10073 };
10074
10075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10077 if (SWIG_arg_fail(1)) SWIG_fail;
10078 {
10079 arg2 = wxString_in_helper(obj1);
10080 if (arg2 == NULL) SWIG_fail;
10081 temp2 = true;
10082 }
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 (arg1)->SetExtension((wxString const &)*arg2);
10086
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 Py_INCREF(Py_None); resultobj = Py_None;
10091 {
10092 if (temp2)
10093 delete arg2;
10094 }
10095 return resultobj;
10096 fail:
10097 {
10098 if (temp2)
10099 delete arg2;
10100 }
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 long arg2 ;
10109 PyObject * obj0 = 0 ;
10110 PyObject * obj1 = 0 ;
10111 char *kwnames[] = {
10112 (char *) "self",(char *) "type", NULL
10113 };
10114
10115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10117 if (SWIG_arg_fail(1)) SWIG_fail;
10118 {
10119 arg2 = (long)(SWIG_As_long(obj1));
10120 if (SWIG_arg_fail(2)) SWIG_fail;
10121 }
10122 {
10123 PyThreadState* __tstate = wxPyBeginAllowThreads();
10124 (arg1)->SetType(arg2);
10125
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 Py_INCREF(Py_None); resultobj = Py_None;
10130 return resultobj;
10131 fail:
10132 return NULL;
10133 }
10134
10135
10136 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj;
10138 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10139 wxString *arg2 = 0 ;
10140 bool temp2 = false ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "mimetype", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",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 = wxString_in_helper(obj1);
10152 if (arg2 == NULL) SWIG_fail;
10153 temp2 = true;
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 (arg1)->SetMimeType((wxString const &)*arg2);
10158
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 Py_INCREF(Py_None); resultobj = Py_None;
10163 {
10164 if (temp2)
10165 delete arg2;
10166 }
10167 return resultobj;
10168 fail:
10169 {
10170 if (temp2)
10171 delete arg2;
10172 }
10173 return NULL;
10174 }
10175
10176
10177 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10178 PyObject *obj;
10179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10180 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10181 Py_INCREF(obj);
10182 return Py_BuildValue((char *)"");
10183 }
10184 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10185 PyObject *resultobj;
10186 wxImageHistogram *result;
10187 char *kwnames[] = {
10188 NULL
10189 };
10190
10191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 result = (wxImageHistogram *)new wxImageHistogram();
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 unsigned char arg1 ;
10209 unsigned char arg2 ;
10210 unsigned char arg3 ;
10211 unsigned long result;
10212 PyObject * obj0 = 0 ;
10213 PyObject * obj1 = 0 ;
10214 PyObject * obj2 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "r",(char *) "g",(char *) "b", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10220 {
10221 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10222 if (SWIG_arg_fail(1)) SWIG_fail;
10223 }
10224 {
10225 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10226 if (SWIG_arg_fail(2)) SWIG_fail;
10227 }
10228 {
10229 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10230 if (SWIG_arg_fail(3)) SWIG_fail;
10231 }
10232 {
10233 PyThreadState* __tstate = wxPyBeginAllowThreads();
10234 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10235
10236 wxPyEndAllowThreads(__tstate);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 {
10240 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10241 }
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10251 unsigned char *arg2 = (unsigned char *) 0 ;
10252 unsigned char *arg3 = (unsigned char *) 0 ;
10253 unsigned char *arg4 = (unsigned char *) 0 ;
10254 unsigned char arg5 = (unsigned char) 1 ;
10255 unsigned char arg6 = (unsigned char) 0 ;
10256 unsigned char arg7 = (unsigned char) 0 ;
10257 bool result;
10258 unsigned char temp2 ;
10259 int res2 = 0 ;
10260 unsigned char temp3 ;
10261 int res3 = 0 ;
10262 unsigned char temp4 ;
10263 int res4 = 0 ;
10264 PyObject * obj0 = 0 ;
10265 PyObject * obj1 = 0 ;
10266 PyObject * obj2 = 0 ;
10267 PyObject * obj3 = 0 ;
10268 char *kwnames[] = {
10269 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10270 };
10271
10272 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10274 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10277 if (SWIG_arg_fail(1)) SWIG_fail;
10278 if (obj1) {
10279 {
10280 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10281 if (SWIG_arg_fail(5)) SWIG_fail;
10282 }
10283 }
10284 if (obj2) {
10285 {
10286 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10287 if (SWIG_arg_fail(6)) SWIG_fail;
10288 }
10289 }
10290 if (obj3) {
10291 {
10292 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10293 if (SWIG_arg_fail(7)) SWIG_fail;
10294 }
10295 }
10296 {
10297 PyThreadState* __tstate = wxPyBeginAllowThreads();
10298 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10299
10300 wxPyEndAllowThreads(__tstate);
10301 if (PyErr_Occurred()) SWIG_fail;
10302 }
10303 {
10304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10305 }
10306 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10307 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10308 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10309 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10310 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10311 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10312 return resultobj;
10313 fail:
10314 return NULL;
10315 }
10316
10317
10318 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10319 PyObject *obj;
10320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10321 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10322 Py_INCREF(obj);
10323 return Py_BuildValue((char *)"");
10324 }
10325 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj;
10327 wxString *arg1 = 0 ;
10328 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10329 int arg3 = (int) -1 ;
10330 wxImage *result;
10331 bool temp1 = false ;
10332 PyObject * obj0 = 0 ;
10333 PyObject * obj1 = 0 ;
10334 PyObject * obj2 = 0 ;
10335 char *kwnames[] = {
10336 (char *) "name",(char *) "type",(char *) "index", NULL
10337 };
10338
10339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10340 {
10341 arg1 = wxString_in_helper(obj0);
10342 if (arg1 == NULL) SWIG_fail;
10343 temp1 = true;
10344 }
10345 if (obj1) {
10346 {
10347 arg2 = (long)(SWIG_As_long(obj1));
10348 if (SWIG_arg_fail(2)) SWIG_fail;
10349 }
10350 }
10351 if (obj2) {
10352 {
10353 arg3 = (int)(SWIG_As_int(obj2));
10354 if (SWIG_arg_fail(3)) SWIG_fail;
10355 }
10356 }
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10360
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10365 {
10366 if (temp1)
10367 delete arg1;
10368 }
10369 return resultobj;
10370 fail:
10371 {
10372 if (temp1)
10373 delete arg1;
10374 }
10375 return NULL;
10376 }
10377
10378
10379 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10380 PyObject *resultobj;
10381 wxImage *arg1 = (wxImage *) 0 ;
10382 PyObject * obj0 = 0 ;
10383 char *kwnames[] = {
10384 (char *) "self", NULL
10385 };
10386
10387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10389 if (SWIG_arg_fail(1)) SWIG_fail;
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 delete arg1;
10393
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 Py_INCREF(Py_None); resultobj = Py_None;
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj;
10406 wxString *arg1 = 0 ;
10407 wxString *arg2 = 0 ;
10408 int arg3 = (int) -1 ;
10409 wxImage *result;
10410 bool temp1 = false ;
10411 bool temp2 = false ;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10414 PyObject * obj2 = 0 ;
10415 char *kwnames[] = {
10416 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10417 };
10418
10419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10420 {
10421 arg1 = wxString_in_helper(obj0);
10422 if (arg1 == NULL) SWIG_fail;
10423 temp1 = true;
10424 }
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 if (obj2) {
10431 {
10432 arg3 = (int)(SWIG_As_int(obj2));
10433 if (SWIG_arg_fail(3)) SWIG_fail;
10434 }
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10439
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10444 {
10445 if (temp1)
10446 delete arg1;
10447 }
10448 {
10449 if (temp2)
10450 delete arg2;
10451 }
10452 return resultobj;
10453 fail:
10454 {
10455 if (temp1)
10456 delete arg1;
10457 }
10458 {
10459 if (temp2)
10460 delete arg2;
10461 }
10462 return NULL;
10463 }
10464
10465
10466 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj;
10468 wxInputStream *arg1 = 0 ;
10469 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10470 int arg3 = (int) -1 ;
10471 wxImage *result;
10472 wxPyInputStream *temp1 ;
10473 bool created1 ;
10474 PyObject * obj0 = 0 ;
10475 PyObject * obj1 = 0 ;
10476 PyObject * obj2 = 0 ;
10477 char *kwnames[] = {
10478 (char *) "stream",(char *) "type",(char *) "index", NULL
10479 };
10480
10481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10482 {
10483 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10484 arg1 = temp1->m_wxis;
10485 created1 = false;
10486 } else {
10487 PyErr_Clear(); // clear the failure of the wxPyConvert above
10488 arg1 = wxPyCBInputStream_create(obj0, false);
10489 if (arg1 == NULL) {
10490 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10491 SWIG_fail;
10492 }
10493 created1 = true;
10494 }
10495 }
10496 if (obj1) {
10497 {
10498 arg2 = (long)(SWIG_As_long(obj1));
10499 if (SWIG_arg_fail(2)) SWIG_fail;
10500 }
10501 }
10502 if (obj2) {
10503 {
10504 arg3 = (int)(SWIG_As_int(obj2));
10505 if (SWIG_arg_fail(3)) SWIG_fail;
10506 }
10507 }
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10511
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10516 {
10517 if (created1) delete arg1;
10518 }
10519 return resultobj;
10520 fail:
10521 {
10522 if (created1) delete arg1;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxInputStream *arg1 = 0 ;
10531 wxString *arg2 = 0 ;
10532 int arg3 = (int) -1 ;
10533 wxImage *result;
10534 wxPyInputStream *temp1 ;
10535 bool created1 ;
10536 bool temp2 = false ;
10537 PyObject * obj0 = 0 ;
10538 PyObject * obj1 = 0 ;
10539 PyObject * obj2 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10545 {
10546 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10547 arg1 = temp1->m_wxis;
10548 created1 = false;
10549 } else {
10550 PyErr_Clear(); // clear the failure of the wxPyConvert above
10551 arg1 = wxPyCBInputStream_create(obj0, false);
10552 if (arg1 == NULL) {
10553 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10554 SWIG_fail;
10555 }
10556 created1 = true;
10557 }
10558 }
10559 {
10560 arg2 = wxString_in_helper(obj1);
10561 if (arg2 == NULL) SWIG_fail;
10562 temp2 = true;
10563 }
10564 if (obj2) {
10565 {
10566 arg3 = (int)(SWIG_As_int(obj2));
10567 if (SWIG_arg_fail(3)) SWIG_fail;
10568 }
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10578 {
10579 if (created1) delete arg1;
10580 }
10581 {
10582 if (temp2)
10583 delete arg2;
10584 }
10585 return resultobj;
10586 fail:
10587 {
10588 if (created1) delete arg1;
10589 }
10590 {
10591 if (temp2)
10592 delete arg2;
10593 }
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 int arg1 = (int) 0 ;
10601 int arg2 = (int) 0 ;
10602 bool arg3 = (bool) true ;
10603 wxImage *result;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 PyObject * obj2 = 0 ;
10607 char *kwnames[] = {
10608 (char *) "width",(char *) "height",(char *) "clear", NULL
10609 };
10610
10611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10612 if (obj0) {
10613 {
10614 arg1 = (int)(SWIG_As_int(obj0));
10615 if (SWIG_arg_fail(1)) SWIG_fail;
10616 }
10617 }
10618 if (obj1) {
10619 {
10620 arg2 = (int)(SWIG_As_int(obj1));
10621 if (SWIG_arg_fail(2)) SWIG_fail;
10622 }
10623 }
10624 if (obj2) {
10625 {
10626 arg3 = (bool)(SWIG_As_bool(obj2));
10627 if (SWIG_arg_fail(3)) SWIG_fail;
10628 }
10629 }
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10633
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 wxBitmap *arg1 = 0 ;
10647 wxImage *result;
10648 PyObject * obj0 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "bitmap", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10654 {
10655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10656 if (SWIG_arg_fail(1)) SWIG_fail;
10657 if (arg1 == NULL) {
10658 SWIG_null_ref("wxBitmap");
10659 }
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 }
10662 {
10663 if (!wxPyCheckForApp()) SWIG_fail;
10664 PyThreadState* __tstate = wxPyBeginAllowThreads();
10665 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10666
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10671 return resultobj;
10672 fail:
10673 return NULL;
10674 }
10675
10676
10677 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj;
10679 int arg1 ;
10680 int arg2 ;
10681 unsigned char *arg3 = (unsigned char *) 0 ;
10682 wxImage *result;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 PyObject * obj2 = 0 ;
10686 char *kwnames[] = {
10687 (char *) "width",(char *) "height",(char *) "data", NULL
10688 };
10689
10690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10691 {
10692 arg1 = (int)(SWIG_As_int(obj0));
10693 if (SWIG_arg_fail(1)) SWIG_fail;
10694 }
10695 {
10696 arg2 = (int)(SWIG_As_int(obj1));
10697 if (SWIG_arg_fail(2)) SWIG_fail;
10698 }
10699 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10700 if (SWIG_arg_fail(3)) SWIG_fail;
10701 {
10702 PyThreadState* __tstate = wxPyBeginAllowThreads();
10703 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10704
10705 wxPyEndAllowThreads(__tstate);
10706 if (PyErr_Occurred()) SWIG_fail;
10707 }
10708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10709 return resultobj;
10710 fail:
10711 return NULL;
10712 }
10713
10714
10715 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10716 PyObject *resultobj;
10717 int arg1 ;
10718 int arg2 ;
10719 unsigned char *arg3 = (unsigned char *) 0 ;
10720 unsigned char *arg4 = (unsigned char *) 0 ;
10721 wxImage *result;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 PyObject * obj2 = 0 ;
10725 PyObject * obj3 = 0 ;
10726 char *kwnames[] = {
10727 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10728 };
10729
10730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10731 {
10732 arg1 = (int)(SWIG_As_int(obj0));
10733 if (SWIG_arg_fail(1)) SWIG_fail;
10734 }
10735 {
10736 arg2 = (int)(SWIG_As_int(obj1));
10737 if (SWIG_arg_fail(2)) SWIG_fail;
10738 }
10739 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10740 if (SWIG_arg_fail(3)) SWIG_fail;
10741 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10742 if (SWIG_arg_fail(4)) SWIG_fail;
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10746
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10758 PyObject *resultobj;
10759 wxImage *arg1 = (wxImage *) 0 ;
10760 int arg2 ;
10761 int arg3 ;
10762 PyObject * obj0 = 0 ;
10763 PyObject * obj1 = 0 ;
10764 PyObject * obj2 = 0 ;
10765 char *kwnames[] = {
10766 (char *) "self",(char *) "width",(char *) "height", NULL
10767 };
10768
10769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10771 if (SWIG_arg_fail(1)) SWIG_fail;
10772 {
10773 arg2 = (int)(SWIG_As_int(obj1));
10774 if (SWIG_arg_fail(2)) SWIG_fail;
10775 }
10776 {
10777 arg3 = (int)(SWIG_As_int(obj2));
10778 if (SWIG_arg_fail(3)) SWIG_fail;
10779 }
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 (arg1)->Create(arg2,arg3);
10783
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 Py_INCREF(Py_None); resultobj = Py_None;
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj;
10796 wxImage *arg1 = (wxImage *) 0 ;
10797 PyObject * obj0 = 0 ;
10798 char *kwnames[] = {
10799 (char *) "self", NULL
10800 };
10801
10802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10804 if (SWIG_arg_fail(1)) SWIG_fail;
10805 {
10806 PyThreadState* __tstate = wxPyBeginAllowThreads();
10807 (arg1)->Destroy();
10808
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 Py_INCREF(Py_None); resultobj = Py_None;
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj;
10821 wxImage *arg1 = (wxImage *) 0 ;
10822 int arg2 ;
10823 int arg3 ;
10824 SwigValueWrapper<wxImage > result;
10825 PyObject * obj0 = 0 ;
10826 PyObject * obj1 = 0 ;
10827 PyObject * obj2 = 0 ;
10828 char *kwnames[] = {
10829 (char *) "self",(char *) "width",(char *) "height", NULL
10830 };
10831
10832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 {
10836 arg2 = (int)(SWIG_As_int(obj1));
10837 if (SWIG_arg_fail(2)) SWIG_fail;
10838 }
10839 {
10840 arg3 = (int)(SWIG_As_int(obj2));
10841 if (SWIG_arg_fail(3)) SWIG_fail;
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (arg1)->Scale(arg2,arg3);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 {
10851 wxImage * resultptr;
10852 resultptr = new wxImage((wxImage &)(result));
10853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj;
10863 wxImage *arg1 = (wxImage *) 0 ;
10864 int arg2 ;
10865 int arg3 ;
10866 SwigValueWrapper<wxImage > result;
10867 PyObject * obj0 = 0 ;
10868 PyObject * obj1 = 0 ;
10869 PyObject * obj2 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10876 if (SWIG_arg_fail(1)) SWIG_fail;
10877 {
10878 arg2 = (int)(SWIG_As_int(obj1));
10879 if (SWIG_arg_fail(2)) SWIG_fail;
10880 }
10881 {
10882 arg3 = (int)(SWIG_As_int(obj2));
10883 if (SWIG_arg_fail(3)) SWIG_fail;
10884 }
10885 {
10886 PyThreadState* __tstate = wxPyBeginAllowThreads();
10887 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10888
10889 wxPyEndAllowThreads(__tstate);
10890 if (PyErr_Occurred()) SWIG_fail;
10891 }
10892 {
10893 wxImage * resultptr;
10894 resultptr = new wxImage((wxImage &)(result));
10895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10896 }
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 wxImage *arg1 = (wxImage *) 0 ;
10906 int arg2 ;
10907 int arg3 ;
10908 wxImage *result;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 PyObject * obj2 = 0 ;
10912 char *kwnames[] = {
10913 (char *) "self",(char *) "width",(char *) "height", NULL
10914 };
10915
10916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10918 if (SWIG_arg_fail(1)) SWIG_fail;
10919 {
10920 arg2 = (int)(SWIG_As_int(obj1));
10921 if (SWIG_arg_fail(2)) SWIG_fail;
10922 }
10923 {
10924 arg3 = (int)(SWIG_As_int(obj2));
10925 if (SWIG_arg_fail(3)) SWIG_fail;
10926 }
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 {
10930 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10931 result = (wxImage *) &_result_ref;
10932 }
10933
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10938 return resultobj;
10939 fail:
10940 return NULL;
10941 }
10942
10943
10944 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
10945 PyObject *resultobj;
10946 wxImage *arg1 = (wxImage *) 0 ;
10947 wxSize *arg2 = 0 ;
10948 wxPoint *arg3 = 0 ;
10949 int arg4 = (int) -1 ;
10950 int arg5 = (int) -1 ;
10951 int arg6 = (int) -1 ;
10952 wxImage *result;
10953 wxSize temp2 ;
10954 wxPoint temp3 ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 PyObject * obj2 = 0 ;
10958 PyObject * obj3 = 0 ;
10959 PyObject * obj4 = 0 ;
10960 PyObject * obj5 = 0 ;
10961 char *kwnames[] = {
10962 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
10963 };
10964
10965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10967 if (SWIG_arg_fail(1)) SWIG_fail;
10968 {
10969 arg2 = &temp2;
10970 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10971 }
10972 {
10973 arg3 = &temp3;
10974 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10975 }
10976 if (obj3) {
10977 {
10978 arg4 = (int)(SWIG_As_int(obj3));
10979 if (SWIG_arg_fail(4)) SWIG_fail;
10980 }
10981 }
10982 if (obj4) {
10983 {
10984 arg5 = (int)(SWIG_As_int(obj4));
10985 if (SWIG_arg_fail(5)) SWIG_fail;
10986 }
10987 }
10988 if (obj5) {
10989 {
10990 arg6 = (int)(SWIG_As_int(obj5));
10991 if (SWIG_arg_fail(6)) SWIG_fail;
10992 }
10993 }
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 {
10997 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
10998 result = (wxImage *) &_result_ref;
10999 }
11000
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj;
11013 wxImage *arg1 = (wxImage *) 0 ;
11014 int arg2 ;
11015 int arg3 ;
11016 unsigned char arg4 ;
11017 unsigned char arg5 ;
11018 unsigned char arg6 ;
11019 PyObject * obj0 = 0 ;
11020 PyObject * obj1 = 0 ;
11021 PyObject * obj2 = 0 ;
11022 PyObject * obj3 = 0 ;
11023 PyObject * obj4 = 0 ;
11024 PyObject * obj5 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 arg2 = (int)(SWIG_As_int(obj1));
11034 if (SWIG_arg_fail(2)) SWIG_fail;
11035 }
11036 {
11037 arg3 = (int)(SWIG_As_int(obj2));
11038 if (SWIG_arg_fail(3)) SWIG_fail;
11039 }
11040 {
11041 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11042 if (SWIG_arg_fail(4)) SWIG_fail;
11043 }
11044 {
11045 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11046 if (SWIG_arg_fail(5)) SWIG_fail;
11047 }
11048 {
11049 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11050 if (SWIG_arg_fail(6)) SWIG_fail;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 Py_INCREF(Py_None); resultobj = Py_None;
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj;
11068 wxImage *arg1 = (wxImage *) 0 ;
11069 wxRect *arg2 = 0 ;
11070 unsigned char arg3 ;
11071 unsigned char arg4 ;
11072 unsigned char arg5 ;
11073 wxRect temp2 ;
11074 PyObject * obj0 = 0 ;
11075 PyObject * obj1 = 0 ;
11076 PyObject * obj2 = 0 ;
11077 PyObject * obj3 = 0 ;
11078 PyObject * obj4 = 0 ;
11079 char *kwnames[] = {
11080 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11081 };
11082
11083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11085 if (SWIG_arg_fail(1)) SWIG_fail;
11086 {
11087 arg2 = &temp2;
11088 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11089 }
11090 {
11091 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11092 if (SWIG_arg_fail(3)) SWIG_fail;
11093 }
11094 {
11095 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11096 if (SWIG_arg_fail(4)) SWIG_fail;
11097 }
11098 {
11099 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11100 if (SWIG_arg_fail(5)) SWIG_fail;
11101 }
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11105
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 Py_INCREF(Py_None); resultobj = Py_None;
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11117 PyObject *resultobj;
11118 wxImage *arg1 = (wxImage *) 0 ;
11119 int arg2 ;
11120 int arg3 ;
11121 unsigned char result;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 char *kwnames[] = {
11126 (char *) "self",(char *) "x",(char *) "y", NULL
11127 };
11128
11129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11131 if (SWIG_arg_fail(1)) SWIG_fail;
11132 {
11133 arg2 = (int)(SWIG_As_int(obj1));
11134 if (SWIG_arg_fail(2)) SWIG_fail;
11135 }
11136 {
11137 arg3 = (int)(SWIG_As_int(obj2));
11138 if (SWIG_arg_fail(3)) SWIG_fail;
11139 }
11140 {
11141 PyThreadState* __tstate = wxPyBeginAllowThreads();
11142 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11143
11144 wxPyEndAllowThreads(__tstate);
11145 if (PyErr_Occurred()) SWIG_fail;
11146 }
11147 {
11148 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11149 }
11150 return resultobj;
11151 fail:
11152 return NULL;
11153 }
11154
11155
11156 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj;
11158 wxImage *arg1 = (wxImage *) 0 ;
11159 int arg2 ;
11160 int arg3 ;
11161 unsigned char result;
11162 PyObject * obj0 = 0 ;
11163 PyObject * obj1 = 0 ;
11164 PyObject * obj2 = 0 ;
11165 char *kwnames[] = {
11166 (char *) "self",(char *) "x",(char *) "y", NULL
11167 };
11168
11169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11171 if (SWIG_arg_fail(1)) SWIG_fail;
11172 {
11173 arg2 = (int)(SWIG_As_int(obj1));
11174 if (SWIG_arg_fail(2)) SWIG_fail;
11175 }
11176 {
11177 arg3 = (int)(SWIG_As_int(obj2));
11178 if (SWIG_arg_fail(3)) SWIG_fail;
11179 }
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11183
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 {
11188 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11189 }
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj;
11198 wxImage *arg1 = (wxImage *) 0 ;
11199 int arg2 ;
11200 int arg3 ;
11201 unsigned char result;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 char *kwnames[] = {
11206 (char *) "self",(char *) "x",(char *) "y", NULL
11207 };
11208
11209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11211 if (SWIG_arg_fail(1)) SWIG_fail;
11212 {
11213 arg2 = (int)(SWIG_As_int(obj1));
11214 if (SWIG_arg_fail(2)) SWIG_fail;
11215 }
11216 {
11217 arg3 = (int)(SWIG_As_int(obj2));
11218 if (SWIG_arg_fail(3)) SWIG_fail;
11219 }
11220 {
11221 PyThreadState* __tstate = wxPyBeginAllowThreads();
11222 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11223
11224 wxPyEndAllowThreads(__tstate);
11225 if (PyErr_Occurred()) SWIG_fail;
11226 }
11227 {
11228 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11229 }
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11237 PyObject *resultobj;
11238 wxImage *arg1 = (wxImage *) 0 ;
11239 int arg2 ;
11240 int arg3 ;
11241 unsigned char arg4 ;
11242 PyObject * obj0 = 0 ;
11243 PyObject * obj1 = 0 ;
11244 PyObject * obj2 = 0 ;
11245 PyObject * obj3 = 0 ;
11246 char *kwnames[] = {
11247 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11248 };
11249
11250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11252 if (SWIG_arg_fail(1)) SWIG_fail;
11253 {
11254 arg2 = (int)(SWIG_As_int(obj1));
11255 if (SWIG_arg_fail(2)) SWIG_fail;
11256 }
11257 {
11258 arg3 = (int)(SWIG_As_int(obj2));
11259 if (SWIG_arg_fail(3)) SWIG_fail;
11260 }
11261 {
11262 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11263 if (SWIG_arg_fail(4)) SWIG_fail;
11264 }
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 (arg1)->SetAlpha(arg2,arg3,arg4);
11268
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 Py_INCREF(Py_None); resultobj = Py_None;
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11280 PyObject *resultobj;
11281 wxImage *arg1 = (wxImage *) 0 ;
11282 int arg2 ;
11283 int arg3 ;
11284 unsigned char result;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 PyObject * obj2 = 0 ;
11288 char *kwnames[] = {
11289 (char *) "self",(char *) "x",(char *) "y", NULL
11290 };
11291
11292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11294 if (SWIG_arg_fail(1)) SWIG_fail;
11295 {
11296 arg2 = (int)(SWIG_As_int(obj1));
11297 if (SWIG_arg_fail(2)) SWIG_fail;
11298 }
11299 {
11300 arg3 = (int)(SWIG_As_int(obj2));
11301 if (SWIG_arg_fail(3)) SWIG_fail;
11302 }
11303 {
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11306
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 {
11311 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11312 }
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj;
11321 wxImage *arg1 = (wxImage *) 0 ;
11322 bool result;
11323 PyObject * obj0 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "self", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11330 if (SWIG_arg_fail(1)) SWIG_fail;
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 result = (bool)(arg1)->HasAlpha();
11334
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 {
11339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj;
11349 wxImage *arg1 = (wxImage *) 0 ;
11350 PyObject * obj0 = 0 ;
11351 char *kwnames[] = {
11352 (char *) "self", NULL
11353 };
11354
11355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11357 if (SWIG_arg_fail(1)) SWIG_fail;
11358 {
11359 PyThreadState* __tstate = wxPyBeginAllowThreads();
11360 (arg1)->InitAlpha();
11361
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 Py_INCREF(Py_None); resultobj = Py_None;
11366 return resultobj;
11367 fail:
11368 return NULL;
11369 }
11370
11371
11372 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj;
11374 wxImage *arg1 = (wxImage *) 0 ;
11375 byte *arg2 = (byte *) 0 ;
11376 byte *arg3 = (byte *) 0 ;
11377 byte *arg4 = (byte *) 0 ;
11378 byte arg5 = (byte) 0 ;
11379 byte arg6 = (byte) 0 ;
11380 byte arg7 = (byte) 0 ;
11381 bool result;
11382 byte temp2 ;
11383 int res2 = 0 ;
11384 byte temp3 ;
11385 int res3 = 0 ;
11386 byte temp4 ;
11387 int res4 = 0 ;
11388 PyObject * obj0 = 0 ;
11389 PyObject * obj1 = 0 ;
11390 PyObject * obj2 = 0 ;
11391 PyObject * obj3 = 0 ;
11392 char *kwnames[] = {
11393 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11394 };
11395
11396 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11397 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11398 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11401 if (SWIG_arg_fail(1)) SWIG_fail;
11402 if (obj1) {
11403 {
11404 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11405 if (SWIG_arg_fail(5)) SWIG_fail;
11406 }
11407 }
11408 if (obj2) {
11409 {
11410 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11411 if (SWIG_arg_fail(6)) SWIG_fail;
11412 }
11413 }
11414 if (obj3) {
11415 {
11416 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11417 if (SWIG_arg_fail(7)) SWIG_fail;
11418 }
11419 }
11420 {
11421 PyThreadState* __tstate = wxPyBeginAllowThreads();
11422 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11423
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 {
11428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11429 }
11430 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11431 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11432 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11433 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11434 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11435 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11436 return resultobj;
11437 fail:
11438 return NULL;
11439 }
11440
11441
11442 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11443 PyObject *resultobj;
11444 wxImage *arg1 = (wxImage *) 0 ;
11445 byte arg2 = (byte) 128 ;
11446 bool result;
11447 PyObject * obj0 = 0 ;
11448 PyObject * obj1 = 0 ;
11449 char *kwnames[] = {
11450 (char *) "self",(char *) "threshold", NULL
11451 };
11452
11453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11455 if (SWIG_arg_fail(1)) SWIG_fail;
11456 if (obj1) {
11457 {
11458 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11459 if (SWIG_arg_fail(2)) SWIG_fail;
11460 }
11461 }
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11465
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 {
11470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11471 }
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11479 PyObject *resultobj;
11480 wxImage *arg1 = (wxImage *) 0 ;
11481 unsigned char arg2 ;
11482 unsigned char arg3 ;
11483 unsigned char arg4 ;
11484 bool result;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11487 PyObject * obj2 = 0 ;
11488 PyObject * obj3 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11498 if (SWIG_arg_fail(2)) SWIG_fail;
11499 }
11500 {
11501 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11502 if (SWIG_arg_fail(3)) SWIG_fail;
11503 }
11504 {
11505 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11506 if (SWIG_arg_fail(4)) SWIG_fail;
11507 }
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11511
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 {
11516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11517 }
11518 return resultobj;
11519 fail:
11520 return NULL;
11521 }
11522
11523
11524 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11525 PyObject *resultobj;
11526 wxImage *arg1 = (wxImage *) 0 ;
11527 wxImage *arg2 = 0 ;
11528 byte arg3 ;
11529 byte arg4 ;
11530 byte arg5 ;
11531 bool result;
11532 PyObject * obj0 = 0 ;
11533 PyObject * obj1 = 0 ;
11534 PyObject * obj2 = 0 ;
11535 PyObject * obj3 = 0 ;
11536 PyObject * obj4 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 {
11545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11546 if (SWIG_arg_fail(2)) SWIG_fail;
11547 if (arg2 == NULL) {
11548 SWIG_null_ref("wxImage");
11549 }
11550 if (SWIG_arg_fail(2)) SWIG_fail;
11551 }
11552 {
11553 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11554 if (SWIG_arg_fail(3)) SWIG_fail;
11555 }
11556 {
11557 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11558 if (SWIG_arg_fail(4)) SWIG_fail;
11559 }
11560 {
11561 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11562 if (SWIG_arg_fail(5)) SWIG_fail;
11563 }
11564 {
11565 PyThreadState* __tstate = wxPyBeginAllowThreads();
11566 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11567
11568 wxPyEndAllowThreads(__tstate);
11569 if (PyErr_Occurred()) SWIG_fail;
11570 }
11571 {
11572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11573 }
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj;
11582 wxString *arg1 = 0 ;
11583 bool result;
11584 bool temp1 = false ;
11585 PyObject * obj0 = 0 ;
11586 char *kwnames[] = {
11587 (char *) "name", NULL
11588 };
11589
11590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11591 {
11592 arg1 = wxString_in_helper(obj0);
11593 if (arg1 == NULL) SWIG_fail;
11594 temp1 = true;
11595 }
11596 {
11597 PyThreadState* __tstate = wxPyBeginAllowThreads();
11598 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11599
11600 wxPyEndAllowThreads(__tstate);
11601 if (PyErr_Occurred()) SWIG_fail;
11602 }
11603 {
11604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11605 }
11606 {
11607 if (temp1)
11608 delete arg1;
11609 }
11610 return resultobj;
11611 fail:
11612 {
11613 if (temp1)
11614 delete arg1;
11615 }
11616 return NULL;
11617 }
11618
11619
11620 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11621 PyObject *resultobj;
11622 wxString *arg1 = 0 ;
11623 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11624 int result;
11625 bool temp1 = false ;
11626 PyObject * obj0 = 0 ;
11627 PyObject * obj1 = 0 ;
11628 char *kwnames[] = {
11629 (char *) "name",(char *) "type", NULL
11630 };
11631
11632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11633 {
11634 arg1 = wxString_in_helper(obj0);
11635 if (arg1 == NULL) SWIG_fail;
11636 temp1 = true;
11637 }
11638 if (obj1) {
11639 {
11640 arg2 = (long)(SWIG_As_long(obj1));
11641 if (SWIG_arg_fail(2)) SWIG_fail;
11642 }
11643 }
11644 {
11645 PyThreadState* __tstate = wxPyBeginAllowThreads();
11646 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11647
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 resultobj = SWIG_From_int((int)(result));
11653 }
11654 {
11655 if (temp1)
11656 delete arg1;
11657 }
11658 return resultobj;
11659 fail:
11660 {
11661 if (temp1)
11662 delete arg1;
11663 }
11664 return NULL;
11665 }
11666
11667
11668 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11669 PyObject *resultobj;
11670 wxImage *arg1 = (wxImage *) 0 ;
11671 wxString *arg2 = 0 ;
11672 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11673 int arg4 = (int) -1 ;
11674 bool result;
11675 bool temp2 = false ;
11676 PyObject * obj0 = 0 ;
11677 PyObject * obj1 = 0 ;
11678 PyObject * obj2 = 0 ;
11679 PyObject * obj3 = 0 ;
11680 char *kwnames[] = {
11681 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11682 };
11683
11684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11686 if (SWIG_arg_fail(1)) SWIG_fail;
11687 {
11688 arg2 = wxString_in_helper(obj1);
11689 if (arg2 == NULL) SWIG_fail;
11690 temp2 = true;
11691 }
11692 if (obj2) {
11693 {
11694 arg3 = (long)(SWIG_As_long(obj2));
11695 if (SWIG_arg_fail(3)) SWIG_fail;
11696 }
11697 }
11698 if (obj3) {
11699 {
11700 arg4 = (int)(SWIG_As_int(obj3));
11701 if (SWIG_arg_fail(4)) SWIG_fail;
11702 }
11703 }
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11713 }
11714 {
11715 if (temp2)
11716 delete arg2;
11717 }
11718 return resultobj;
11719 fail:
11720 {
11721 if (temp2)
11722 delete arg2;
11723 }
11724 return NULL;
11725 }
11726
11727
11728 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxImage *arg1 = (wxImage *) 0 ;
11731 wxString *arg2 = 0 ;
11732 wxString *arg3 = 0 ;
11733 int arg4 = (int) -1 ;
11734 bool result;
11735 bool temp2 = false ;
11736 bool temp3 = false ;
11737 PyObject * obj0 = 0 ;
11738 PyObject * obj1 = 0 ;
11739 PyObject * obj2 = 0 ;
11740 PyObject * obj3 = 0 ;
11741 char *kwnames[] = {
11742 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11743 };
11744
11745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11747 if (SWIG_arg_fail(1)) SWIG_fail;
11748 {
11749 arg2 = wxString_in_helper(obj1);
11750 if (arg2 == NULL) SWIG_fail;
11751 temp2 = true;
11752 }
11753 {
11754 arg3 = wxString_in_helper(obj2);
11755 if (arg3 == NULL) SWIG_fail;
11756 temp3 = true;
11757 }
11758 if (obj3) {
11759 {
11760 arg4 = (int)(SWIG_As_int(obj3));
11761 if (SWIG_arg_fail(4)) SWIG_fail;
11762 }
11763 }
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11767
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 {
11772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11773 }
11774 {
11775 if (temp2)
11776 delete arg2;
11777 }
11778 {
11779 if (temp3)
11780 delete arg3;
11781 }
11782 return resultobj;
11783 fail:
11784 {
11785 if (temp2)
11786 delete arg2;
11787 }
11788 {
11789 if (temp3)
11790 delete arg3;
11791 }
11792 return NULL;
11793 }
11794
11795
11796 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj;
11798 wxImage *arg1 = (wxImage *) 0 ;
11799 wxString *arg2 = 0 ;
11800 int arg3 ;
11801 bool result;
11802 bool temp2 = false ;
11803 PyObject * obj0 = 0 ;
11804 PyObject * obj1 = 0 ;
11805 PyObject * obj2 = 0 ;
11806 char *kwnames[] = {
11807 (char *) "self",(char *) "name",(char *) "type", NULL
11808 };
11809
11810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11812 if (SWIG_arg_fail(1)) SWIG_fail;
11813 {
11814 arg2 = wxString_in_helper(obj1);
11815 if (arg2 == NULL) SWIG_fail;
11816 temp2 = true;
11817 }
11818 {
11819 arg3 = (int)(SWIG_As_int(obj2));
11820 if (SWIG_arg_fail(3)) SWIG_fail;
11821 }
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11825
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 {
11830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11831 }
11832 {
11833 if (temp2)
11834 delete arg2;
11835 }
11836 return resultobj;
11837 fail:
11838 {
11839 if (temp2)
11840 delete arg2;
11841 }
11842 return NULL;
11843 }
11844
11845
11846 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11847 PyObject *resultobj;
11848 wxImage *arg1 = (wxImage *) 0 ;
11849 wxString *arg2 = 0 ;
11850 wxString *arg3 = 0 ;
11851 bool result;
11852 bool temp2 = false ;
11853 bool temp3 = false ;
11854 PyObject * obj0 = 0 ;
11855 PyObject * obj1 = 0 ;
11856 PyObject * obj2 = 0 ;
11857 char *kwnames[] = {
11858 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11859 };
11860
11861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11863 if (SWIG_arg_fail(1)) SWIG_fail;
11864 {
11865 arg2 = wxString_in_helper(obj1);
11866 if (arg2 == NULL) SWIG_fail;
11867 temp2 = true;
11868 }
11869 {
11870 arg3 = wxString_in_helper(obj2);
11871 if (arg3 == NULL) SWIG_fail;
11872 temp3 = true;
11873 }
11874 {
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11877
11878 wxPyEndAllowThreads(__tstate);
11879 if (PyErr_Occurred()) SWIG_fail;
11880 }
11881 {
11882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11883 }
11884 {
11885 if (temp2)
11886 delete arg2;
11887 }
11888 {
11889 if (temp3)
11890 delete arg3;
11891 }
11892 return resultobj;
11893 fail:
11894 {
11895 if (temp2)
11896 delete arg2;
11897 }
11898 {
11899 if (temp3)
11900 delete arg3;
11901 }
11902 return NULL;
11903 }
11904
11905
11906 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj;
11908 wxInputStream *arg1 = 0 ;
11909 bool result;
11910 wxPyInputStream *temp1 ;
11911 bool created1 ;
11912 PyObject * obj0 = 0 ;
11913 char *kwnames[] = {
11914 (char *) "stream", NULL
11915 };
11916
11917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11918 {
11919 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11920 arg1 = temp1->m_wxis;
11921 created1 = false;
11922 } else {
11923 PyErr_Clear(); // clear the failure of the wxPyConvert above
11924 arg1 = wxPyCBInputStream_create(obj0, false);
11925 if (arg1 == NULL) {
11926 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11927 SWIG_fail;
11928 }
11929 created1 = true;
11930 }
11931 }
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 result = (bool)wxImage::CanRead(*arg1);
11935
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 {
11940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11941 }
11942 {
11943 if (created1) delete arg1;
11944 }
11945 return resultobj;
11946 fail:
11947 {
11948 if (created1) delete arg1;
11949 }
11950 return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj;
11956 wxImage *arg1 = (wxImage *) 0 ;
11957 wxInputStream *arg2 = 0 ;
11958 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11959 int arg4 = (int) -1 ;
11960 bool result;
11961 wxPyInputStream *temp2 ;
11962 bool created2 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 PyObject * obj3 = 0 ;
11967 char *kwnames[] = {
11968 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11969 };
11970
11971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11973 if (SWIG_arg_fail(1)) SWIG_fail;
11974 {
11975 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11976 arg2 = temp2->m_wxis;
11977 created2 = false;
11978 } else {
11979 PyErr_Clear(); // clear the failure of the wxPyConvert above
11980 arg2 = wxPyCBInputStream_create(obj1, false);
11981 if (arg2 == NULL) {
11982 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11983 SWIG_fail;
11984 }
11985 created2 = true;
11986 }
11987 }
11988 if (obj2) {
11989 {
11990 arg3 = (long)(SWIG_As_long(obj2));
11991 if (SWIG_arg_fail(3)) SWIG_fail;
11992 }
11993 }
11994 if (obj3) {
11995 {
11996 arg4 = (int)(SWIG_As_int(obj3));
11997 if (SWIG_arg_fail(4)) SWIG_fail;
11998 }
11999 }
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12003
12004 wxPyEndAllowThreads(__tstate);
12005 if (PyErr_Occurred()) SWIG_fail;
12006 }
12007 {
12008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12009 }
12010 {
12011 if (created2) delete arg2;
12012 }
12013 return resultobj;
12014 fail:
12015 {
12016 if (created2) delete arg2;
12017 }
12018 return NULL;
12019 }
12020
12021
12022 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj;
12024 wxImage *arg1 = (wxImage *) 0 ;
12025 wxInputStream *arg2 = 0 ;
12026 wxString *arg3 = 0 ;
12027 int arg4 = (int) -1 ;
12028 bool result;
12029 wxPyInputStream *temp2 ;
12030 bool created2 ;
12031 bool temp3 = false ;
12032 PyObject * obj0 = 0 ;
12033 PyObject * obj1 = 0 ;
12034 PyObject * obj2 = 0 ;
12035 PyObject * obj3 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12045 arg2 = temp2->m_wxis;
12046 created2 = false;
12047 } else {
12048 PyErr_Clear(); // clear the failure of the wxPyConvert above
12049 arg2 = wxPyCBInputStream_create(obj1, false);
12050 if (arg2 == NULL) {
12051 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12052 SWIG_fail;
12053 }
12054 created2 = true;
12055 }
12056 }
12057 {
12058 arg3 = wxString_in_helper(obj2);
12059 if (arg3 == NULL) SWIG_fail;
12060 temp3 = true;
12061 }
12062 if (obj3) {
12063 {
12064 arg4 = (int)(SWIG_As_int(obj3));
12065 if (SWIG_arg_fail(4)) SWIG_fail;
12066 }
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 {
12076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12077 }
12078 {
12079 if (created2) delete arg2;
12080 }
12081 {
12082 if (temp3)
12083 delete arg3;
12084 }
12085 return resultobj;
12086 fail:
12087 {
12088 if (created2) delete arg2;
12089 }
12090 {
12091 if (temp3)
12092 delete arg3;
12093 }
12094 return NULL;
12095 }
12096
12097
12098 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12099 PyObject *resultobj;
12100 wxImage *arg1 = (wxImage *) 0 ;
12101 bool result;
12102 PyObject * obj0 = 0 ;
12103 char *kwnames[] = {
12104 (char *) "self", NULL
12105 };
12106
12107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12109 if (SWIG_arg_fail(1)) SWIG_fail;
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (bool)(arg1)->Ok();
12113
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 {
12118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12119 }
12120 return resultobj;
12121 fail:
12122 return NULL;
12123 }
12124
12125
12126 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj;
12128 wxImage *arg1 = (wxImage *) 0 ;
12129 int result;
12130 PyObject * obj0 = 0 ;
12131 char *kwnames[] = {
12132 (char *) "self", NULL
12133 };
12134
12135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12137 if (SWIG_arg_fail(1)) SWIG_fail;
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (int)(arg1)->GetWidth();
12141
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 resultobj = SWIG_From_int((int)(result));
12147 }
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj;
12156 wxImage *arg1 = (wxImage *) 0 ;
12157 int result;
12158 PyObject * obj0 = 0 ;
12159 char *kwnames[] = {
12160 (char *) "self", NULL
12161 };
12162
12163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12165 if (SWIG_arg_fail(1)) SWIG_fail;
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = (int)(arg1)->GetHeight();
12169
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 {
12174 resultobj = SWIG_From_int((int)(result));
12175 }
12176 return resultobj;
12177 fail:
12178 return NULL;
12179 }
12180
12181
12182 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12183 PyObject *resultobj;
12184 wxImage *arg1 = (wxImage *) 0 ;
12185 wxSize result;
12186 PyObject * obj0 = 0 ;
12187 char *kwnames[] = {
12188 (char *) "self", NULL
12189 };
12190
12191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12193 if (SWIG_arg_fail(1)) SWIG_fail;
12194 {
12195 PyThreadState* __tstate = wxPyBeginAllowThreads();
12196 result = wxImage_GetSize(arg1);
12197
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 {
12202 wxSize * resultptr;
12203 resultptr = new wxSize((wxSize &)(result));
12204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12205 }
12206 return resultobj;
12207 fail:
12208 return NULL;
12209 }
12210
12211
12212 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12213 PyObject *resultobj;
12214 wxImage *arg1 = (wxImage *) 0 ;
12215 wxRect *arg2 = 0 ;
12216 SwigValueWrapper<wxImage > result;
12217 wxRect temp2 ;
12218 PyObject * obj0 = 0 ;
12219 PyObject * obj1 = 0 ;
12220 char *kwnames[] = {
12221 (char *) "self",(char *) "rect", NULL
12222 };
12223
12224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12226 if (SWIG_arg_fail(1)) SWIG_fail;
12227 {
12228 arg2 = &temp2;
12229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12230 }
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 {
12239 wxImage * resultptr;
12240 resultptr = new wxImage((wxImage &)(result));
12241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12242 }
12243 return resultobj;
12244 fail:
12245 return NULL;
12246 }
12247
12248
12249 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12250 PyObject *resultobj;
12251 wxImage *arg1 = (wxImage *) 0 ;
12252 wxSize *arg2 = 0 ;
12253 wxPoint *arg3 = 0 ;
12254 int arg4 = (int) -1 ;
12255 int arg5 = (int) -1 ;
12256 int arg6 = (int) -1 ;
12257 SwigValueWrapper<wxImage > result;
12258 wxSize temp2 ;
12259 wxPoint temp3 ;
12260 PyObject * obj0 = 0 ;
12261 PyObject * obj1 = 0 ;
12262 PyObject * obj2 = 0 ;
12263 PyObject * obj3 = 0 ;
12264 PyObject * obj4 = 0 ;
12265 PyObject * obj5 = 0 ;
12266 char *kwnames[] = {
12267 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12268 };
12269
12270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12272 if (SWIG_arg_fail(1)) SWIG_fail;
12273 {
12274 arg2 = &temp2;
12275 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12276 }
12277 {
12278 arg3 = &temp3;
12279 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12280 }
12281 if (obj3) {
12282 {
12283 arg4 = (int)(SWIG_As_int(obj3));
12284 if (SWIG_arg_fail(4)) SWIG_fail;
12285 }
12286 }
12287 if (obj4) {
12288 {
12289 arg5 = (int)(SWIG_As_int(obj4));
12290 if (SWIG_arg_fail(5)) SWIG_fail;
12291 }
12292 }
12293 if (obj5) {
12294 {
12295 arg6 = (int)(SWIG_As_int(obj5));
12296 if (SWIG_arg_fail(6)) SWIG_fail;
12297 }
12298 }
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12302
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 wxImage * resultptr;
12308 resultptr = new wxImage((wxImage &)(result));
12309 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12310 }
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12318 PyObject *resultobj;
12319 wxImage *arg1 = (wxImage *) 0 ;
12320 SwigValueWrapper<wxImage > result;
12321 PyObject * obj0 = 0 ;
12322 char *kwnames[] = {
12323 (char *) "self", NULL
12324 };
12325
12326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (arg1)->Copy();
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 {
12337 wxImage * resultptr;
12338 resultptr = new wxImage((wxImage &)(result));
12339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12340 }
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj;
12349 wxImage *arg1 = (wxImage *) 0 ;
12350 wxImage *arg2 = 0 ;
12351 int arg3 ;
12352 int arg4 ;
12353 PyObject * obj0 = 0 ;
12354 PyObject * obj1 = 0 ;
12355 PyObject * obj2 = 0 ;
12356 PyObject * obj3 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 {
12365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12366 if (SWIG_arg_fail(2)) SWIG_fail;
12367 if (arg2 == NULL) {
12368 SWIG_null_ref("wxImage");
12369 }
12370 if (SWIG_arg_fail(2)) SWIG_fail;
12371 }
12372 {
12373 arg3 = (int)(SWIG_As_int(obj2));
12374 if (SWIG_arg_fail(3)) SWIG_fail;
12375 }
12376 {
12377 arg4 = (int)(SWIG_As_int(obj3));
12378 if (SWIG_arg_fail(4)) SWIG_fail;
12379 }
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12383
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 Py_INCREF(Py_None); resultobj = Py_None;
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj;
12396 wxImage *arg1 = (wxImage *) 0 ;
12397 PyObject *result;
12398 PyObject * obj0 = 0 ;
12399 char *kwnames[] = {
12400 (char *) "self", NULL
12401 };
12402
12403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12405 if (SWIG_arg_fail(1)) SWIG_fail;
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (PyObject *)wxImage_GetData(arg1);
12409
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 resultobj = result;
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj;
12422 wxImage *arg1 = (wxImage *) 0 ;
12423 PyObject *arg2 = (PyObject *) 0 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "data", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 arg2 = obj1;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 wxImage_SetData(arg1,arg2);
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 Py_INCREF(Py_None); resultobj = Py_None;
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12449 PyObject *resultobj;
12450 wxImage *arg1 = (wxImage *) 0 ;
12451 PyObject *result;
12452 PyObject * obj0 = 0 ;
12453 char *kwnames[] = {
12454 (char *) "self", NULL
12455 };
12456
12457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12459 if (SWIG_arg_fail(1)) SWIG_fail;
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = result;
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj;
12476 wxImage *arg1 = (wxImage *) 0 ;
12477 PyObject *arg2 = (PyObject *) 0 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char *kwnames[] = {
12481 (char *) "self",(char *) "data", NULL
12482 };
12483
12484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12486 if (SWIG_arg_fail(1)) SWIG_fail;
12487 arg2 = obj1;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 wxImage_SetDataBuffer(arg1,arg2);
12491
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 Py_INCREF(Py_None); resultobj = Py_None;
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj;
12504 wxImage *arg1 = (wxImage *) 0 ;
12505 PyObject *result;
12506 PyObject * obj0 = 0 ;
12507 char *kwnames[] = {
12508 (char *) "self", NULL
12509 };
12510
12511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12513 if (SWIG_arg_fail(1)) SWIG_fail;
12514 {
12515 PyThreadState* __tstate = wxPyBeginAllowThreads();
12516 result = (PyObject *)wxImage_GetAlphaData(arg1);
12517
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = result;
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj;
12530 wxImage *arg1 = (wxImage *) 0 ;
12531 PyObject *arg2 = (PyObject *) 0 ;
12532 PyObject * obj0 = 0 ;
12533 PyObject * obj1 = 0 ;
12534 char *kwnames[] = {
12535 (char *) "self",(char *) "data", NULL
12536 };
12537
12538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12540 if (SWIG_arg_fail(1)) SWIG_fail;
12541 arg2 = obj1;
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 wxImage_SetAlphaData(arg1,arg2);
12545
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 Py_INCREF(Py_None); resultobj = Py_None;
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj;
12558 wxImage *arg1 = (wxImage *) 0 ;
12559 PyObject *result;
12560 PyObject * obj0 = 0 ;
12561 char *kwnames[] = {
12562 (char *) "self", NULL
12563 };
12564
12565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12567 if (SWIG_arg_fail(1)) SWIG_fail;
12568 {
12569 PyThreadState* __tstate = wxPyBeginAllowThreads();
12570 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12571
12572 wxPyEndAllowThreads(__tstate);
12573 if (PyErr_Occurred()) SWIG_fail;
12574 }
12575 resultobj = result;
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj;
12584 wxImage *arg1 = (wxImage *) 0 ;
12585 PyObject *arg2 = (PyObject *) 0 ;
12586 PyObject * obj0 = 0 ;
12587 PyObject * obj1 = 0 ;
12588 char *kwnames[] = {
12589 (char *) "self",(char *) "data", NULL
12590 };
12591
12592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12594 if (SWIG_arg_fail(1)) SWIG_fail;
12595 arg2 = obj1;
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 wxImage_SetAlphaBuffer(arg1,arg2);
12599
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 Py_INCREF(Py_None); resultobj = Py_None;
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxImage *arg1 = (wxImage *) 0 ;
12613 unsigned char arg2 ;
12614 unsigned char arg3 ;
12615 unsigned char arg4 ;
12616 PyObject * obj0 = 0 ;
12617 PyObject * obj1 = 0 ;
12618 PyObject * obj2 = 0 ;
12619 PyObject * obj3 = 0 ;
12620 char *kwnames[] = {
12621 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12622 };
12623
12624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12626 if (SWIG_arg_fail(1)) SWIG_fail;
12627 {
12628 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12629 if (SWIG_arg_fail(2)) SWIG_fail;
12630 }
12631 {
12632 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12633 if (SWIG_arg_fail(3)) SWIG_fail;
12634 }
12635 {
12636 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12637 if (SWIG_arg_fail(4)) SWIG_fail;
12638 }
12639 {
12640 PyThreadState* __tstate = wxPyBeginAllowThreads();
12641 (arg1)->SetMaskColour(arg2,arg3,arg4);
12642
12643 wxPyEndAllowThreads(__tstate);
12644 if (PyErr_Occurred()) SWIG_fail;
12645 }
12646 Py_INCREF(Py_None); resultobj = Py_None;
12647 return resultobj;
12648 fail:
12649 return NULL;
12650 }
12651
12652
12653 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12654 PyObject *resultobj;
12655 wxImage *arg1 = (wxImage *) 0 ;
12656 unsigned char *arg2 = (unsigned char *) 0 ;
12657 unsigned char *arg3 = (unsigned char *) 0 ;
12658 unsigned char *arg4 = (unsigned char *) 0 ;
12659 unsigned char temp2 ;
12660 int res2 = 0 ;
12661 unsigned char temp3 ;
12662 int res3 = 0 ;
12663 unsigned char temp4 ;
12664 int res4 = 0 ;
12665 PyObject * obj0 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self", NULL
12668 };
12669
12670 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12671 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12672 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12679
12680 wxPyEndAllowThreads(__tstate);
12681 if (PyErr_Occurred()) SWIG_fail;
12682 }
12683 Py_INCREF(Py_None); resultobj = Py_None;
12684 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12685 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12686 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12687 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12688 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12689 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxImage *arg1 = (wxImage *) 0 ;
12699 unsigned char result;
12700 PyObject * obj0 = 0 ;
12701 char *kwnames[] = {
12702 (char *) "self", NULL
12703 };
12704
12705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12707 if (SWIG_arg_fail(1)) SWIG_fail;
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = (unsigned char)(arg1)->GetMaskRed();
12711
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12717 }
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12725 PyObject *resultobj;
12726 wxImage *arg1 = (wxImage *) 0 ;
12727 unsigned char result;
12728 PyObject * obj0 = 0 ;
12729 char *kwnames[] = {
12730 (char *) "self", NULL
12731 };
12732
12733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12735 if (SWIG_arg_fail(1)) SWIG_fail;
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (unsigned char)(arg1)->GetMaskGreen();
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj;
12754 wxImage *arg1 = (wxImage *) 0 ;
12755 unsigned char result;
12756 PyObject * obj0 = 0 ;
12757 char *kwnames[] = {
12758 (char *) "self", NULL
12759 };
12760
12761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12763 if (SWIG_arg_fail(1)) SWIG_fail;
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (unsigned char)(arg1)->GetMaskBlue();
12767
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12773 }
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12781 PyObject *resultobj;
12782 wxImage *arg1 = (wxImage *) 0 ;
12783 bool arg2 = (bool) true ;
12784 PyObject * obj0 = 0 ;
12785 PyObject * obj1 = 0 ;
12786 char *kwnames[] = {
12787 (char *) "self",(char *) "mask", NULL
12788 };
12789
12790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12792 if (SWIG_arg_fail(1)) SWIG_fail;
12793 if (obj1) {
12794 {
12795 arg2 = (bool)(SWIG_As_bool(obj1));
12796 if (SWIG_arg_fail(2)) SWIG_fail;
12797 }
12798 }
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 (arg1)->SetMask(arg2);
12802
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 Py_INCREF(Py_None); resultobj = Py_None;
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 bool result;
12817 PyObject * obj0 = 0 ;
12818 char *kwnames[] = {
12819 (char *) "self", NULL
12820 };
12821
12822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12824 if (SWIG_arg_fail(1)) SWIG_fail;
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (bool)(arg1)->HasMask();
12828
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 {
12833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12834 }
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxImage *arg1 = (wxImage *) 0 ;
12844 double arg2 ;
12845 wxPoint *arg3 = 0 ;
12846 bool arg4 = (bool) true ;
12847 wxPoint *arg5 = (wxPoint *) NULL ;
12848 SwigValueWrapper<wxImage > result;
12849 wxPoint temp3 ;
12850 PyObject * obj0 = 0 ;
12851 PyObject * obj1 = 0 ;
12852 PyObject * obj2 = 0 ;
12853 PyObject * obj3 = 0 ;
12854 PyObject * obj4 = 0 ;
12855 char *kwnames[] = {
12856 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12857 };
12858
12859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12861 if (SWIG_arg_fail(1)) SWIG_fail;
12862 {
12863 arg2 = (double)(SWIG_As_double(obj1));
12864 if (SWIG_arg_fail(2)) SWIG_fail;
12865 }
12866 {
12867 arg3 = &temp3;
12868 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12869 }
12870 if (obj3) {
12871 {
12872 arg4 = (bool)(SWIG_As_bool(obj3));
12873 if (SWIG_arg_fail(4)) SWIG_fail;
12874 }
12875 }
12876 if (obj4) {
12877 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12878 if (SWIG_arg_fail(5)) SWIG_fail;
12879 }
12880 {
12881 PyThreadState* __tstate = wxPyBeginAllowThreads();
12882 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12883
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 {
12888 wxImage * resultptr;
12889 resultptr = new wxImage((wxImage &)(result));
12890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12891 }
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj;
12900 wxImage *arg1 = (wxImage *) 0 ;
12901 bool arg2 = (bool) true ;
12902 SwigValueWrapper<wxImage > result;
12903 PyObject * obj0 = 0 ;
12904 PyObject * obj1 = 0 ;
12905 char *kwnames[] = {
12906 (char *) "self",(char *) "clockwise", NULL
12907 };
12908
12909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12911 if (SWIG_arg_fail(1)) SWIG_fail;
12912 if (obj1) {
12913 {
12914 arg2 = (bool)(SWIG_As_bool(obj1));
12915 if (SWIG_arg_fail(2)) SWIG_fail;
12916 }
12917 }
12918 {
12919 PyThreadState* __tstate = wxPyBeginAllowThreads();
12920 result = (arg1)->Rotate90(arg2);
12921
12922 wxPyEndAllowThreads(__tstate);
12923 if (PyErr_Occurred()) SWIG_fail;
12924 }
12925 {
12926 wxImage * resultptr;
12927 resultptr = new wxImage((wxImage &)(result));
12928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12929 }
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj;
12938 wxImage *arg1 = (wxImage *) 0 ;
12939 bool arg2 = (bool) true ;
12940 SwigValueWrapper<wxImage > result;
12941 PyObject * obj0 = 0 ;
12942 PyObject * obj1 = 0 ;
12943 char *kwnames[] = {
12944 (char *) "self",(char *) "horizontally", NULL
12945 };
12946
12947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12949 if (SWIG_arg_fail(1)) SWIG_fail;
12950 if (obj1) {
12951 {
12952 arg2 = (bool)(SWIG_As_bool(obj1));
12953 if (SWIG_arg_fail(2)) SWIG_fail;
12954 }
12955 }
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (arg1)->Mirror(arg2);
12959
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 {
12964 wxImage * resultptr;
12965 resultptr = new wxImage((wxImage &)(result));
12966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxImage *arg1 = (wxImage *) 0 ;
12977 unsigned char arg2 ;
12978 unsigned char arg3 ;
12979 unsigned char arg4 ;
12980 unsigned char arg5 ;
12981 unsigned char arg6 ;
12982 unsigned char arg7 ;
12983 PyObject * obj0 = 0 ;
12984 PyObject * obj1 = 0 ;
12985 PyObject * obj2 = 0 ;
12986 PyObject * obj3 = 0 ;
12987 PyObject * obj4 = 0 ;
12988 PyObject * obj5 = 0 ;
12989 PyObject * obj6 = 0 ;
12990 char *kwnames[] = {
12991 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12992 };
12993
12994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12996 if (SWIG_arg_fail(1)) SWIG_fail;
12997 {
12998 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12999 if (SWIG_arg_fail(2)) SWIG_fail;
13000 }
13001 {
13002 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13003 if (SWIG_arg_fail(3)) SWIG_fail;
13004 }
13005 {
13006 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13007 if (SWIG_arg_fail(4)) SWIG_fail;
13008 }
13009 {
13010 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13011 if (SWIG_arg_fail(5)) SWIG_fail;
13012 }
13013 {
13014 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13015 if (SWIG_arg_fail(6)) SWIG_fail;
13016 }
13017 {
13018 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13019 if (SWIG_arg_fail(7)) SWIG_fail;
13020 }
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13024
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 Py_INCREF(Py_None); resultobj = Py_None;
13029 return resultobj;
13030 fail:
13031 return NULL;
13032 }
13033
13034
13035 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13036 PyObject *resultobj;
13037 wxImage *arg1 = (wxImage *) 0 ;
13038 unsigned char arg2 ;
13039 unsigned char arg3 ;
13040 unsigned char arg4 ;
13041 SwigValueWrapper<wxImage > result;
13042 PyObject * obj0 = 0 ;
13043 PyObject * obj1 = 0 ;
13044 PyObject * obj2 = 0 ;
13045 PyObject * obj3 = 0 ;
13046 char *kwnames[] = {
13047 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13048 };
13049
13050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13052 if (SWIG_arg_fail(1)) SWIG_fail;
13053 {
13054 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13055 if (SWIG_arg_fail(2)) SWIG_fail;
13056 }
13057 {
13058 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13059 if (SWIG_arg_fail(3)) SWIG_fail;
13060 }
13061 {
13062 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13063 if (SWIG_arg_fail(4)) SWIG_fail;
13064 }
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13068
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 {
13073 wxImage * resultptr;
13074 resultptr = new wxImage((wxImage &)(result));
13075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13076 }
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 wxString *arg2 = 0 ;
13087 wxString *arg3 = 0 ;
13088 bool temp2 = false ;
13089 bool temp3 = false ;
13090 PyObject * obj0 = 0 ;
13091 PyObject * obj1 = 0 ;
13092 PyObject * obj2 = 0 ;
13093 char *kwnames[] = {
13094 (char *) "self",(char *) "name",(char *) "value", NULL
13095 };
13096
13097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13099 if (SWIG_arg_fail(1)) SWIG_fail;
13100 {
13101 arg2 = wxString_in_helper(obj1);
13102 if (arg2 == NULL) SWIG_fail;
13103 temp2 = true;
13104 }
13105 {
13106 arg3 = wxString_in_helper(obj2);
13107 if (arg3 == NULL) SWIG_fail;
13108 temp3 = true;
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 Py_INCREF(Py_None); resultobj = Py_None;
13118 {
13119 if (temp2)
13120 delete arg2;
13121 }
13122 {
13123 if (temp3)
13124 delete arg3;
13125 }
13126 return resultobj;
13127 fail:
13128 {
13129 if (temp2)
13130 delete arg2;
13131 }
13132 {
13133 if (temp3)
13134 delete arg3;
13135 }
13136 return NULL;
13137 }
13138
13139
13140 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13141 PyObject *resultobj;
13142 wxImage *arg1 = (wxImage *) 0 ;
13143 wxString *arg2 = 0 ;
13144 int arg3 ;
13145 bool temp2 = false ;
13146 PyObject * obj0 = 0 ;
13147 PyObject * obj1 = 0 ;
13148 PyObject * obj2 = 0 ;
13149 char *kwnames[] = {
13150 (char *) "self",(char *) "name",(char *) "value", NULL
13151 };
13152
13153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13155 if (SWIG_arg_fail(1)) SWIG_fail;
13156 {
13157 arg2 = wxString_in_helper(obj1);
13158 if (arg2 == NULL) SWIG_fail;
13159 temp2 = true;
13160 }
13161 {
13162 arg3 = (int)(SWIG_As_int(obj2));
13163 if (SWIG_arg_fail(3)) SWIG_fail;
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 (arg1)->SetOption((wxString const &)*arg2,arg3);
13168
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 Py_INCREF(Py_None); resultobj = Py_None;
13173 {
13174 if (temp2)
13175 delete arg2;
13176 }
13177 return resultobj;
13178 fail:
13179 {
13180 if (temp2)
13181 delete arg2;
13182 }
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxImage *arg1 = (wxImage *) 0 ;
13190 wxString *arg2 = 0 ;
13191 wxString result;
13192 bool temp2 = false ;
13193 PyObject * obj0 = 0 ;
13194 PyObject * obj1 = 0 ;
13195 char *kwnames[] = {
13196 (char *) "self",(char *) "name", NULL
13197 };
13198
13199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13201 if (SWIG_arg_fail(1)) SWIG_fail;
13202 {
13203 arg2 = wxString_in_helper(obj1);
13204 if (arg2 == NULL) SWIG_fail;
13205 temp2 = true;
13206 }
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 {
13215 #if wxUSE_UNICODE
13216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13217 #else
13218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13219 #endif
13220 }
13221 {
13222 if (temp2)
13223 delete arg2;
13224 }
13225 return resultobj;
13226 fail:
13227 {
13228 if (temp2)
13229 delete arg2;
13230 }
13231 return NULL;
13232 }
13233
13234
13235 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj;
13237 wxImage *arg1 = (wxImage *) 0 ;
13238 wxString *arg2 = 0 ;
13239 int result;
13240 bool temp2 = false ;
13241 PyObject * obj0 = 0 ;
13242 PyObject * obj1 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self",(char *) "name", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 arg2 = wxString_in_helper(obj1);
13252 if (arg2 == NULL) SWIG_fail;
13253 temp2 = true;
13254 }
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13258
13259 wxPyEndAllowThreads(__tstate);
13260 if (PyErr_Occurred()) SWIG_fail;
13261 }
13262 {
13263 resultobj = SWIG_From_int((int)(result));
13264 }
13265 {
13266 if (temp2)
13267 delete arg2;
13268 }
13269 return resultobj;
13270 fail:
13271 {
13272 if (temp2)
13273 delete arg2;
13274 }
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxImage *arg1 = (wxImage *) 0 ;
13282 wxString *arg2 = 0 ;
13283 bool result;
13284 bool temp2 = false ;
13285 PyObject * obj0 = 0 ;
13286 PyObject * obj1 = 0 ;
13287 char *kwnames[] = {
13288 (char *) "self",(char *) "name", NULL
13289 };
13290
13291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13293 if (SWIG_arg_fail(1)) SWIG_fail;
13294 {
13295 arg2 = wxString_in_helper(obj1);
13296 if (arg2 == NULL) SWIG_fail;
13297 temp2 = true;
13298 }
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13302
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 {
13307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13308 }
13309 {
13310 if (temp2)
13311 delete arg2;
13312 }
13313 return resultobj;
13314 fail:
13315 {
13316 if (temp2)
13317 delete arg2;
13318 }
13319 return NULL;
13320 }
13321
13322
13323 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13324 PyObject *resultobj;
13325 wxImage *arg1 = (wxImage *) 0 ;
13326 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13327 unsigned long result;
13328 PyObject * obj0 = 0 ;
13329 PyObject * obj1 = 0 ;
13330 char *kwnames[] = {
13331 (char *) "self",(char *) "stopafter", NULL
13332 };
13333
13334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13336 if (SWIG_arg_fail(1)) SWIG_fail;
13337 if (obj1) {
13338 {
13339 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13340 if (SWIG_arg_fail(2)) SWIG_fail;
13341 }
13342 }
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 result = (unsigned long)(arg1)->CountColours(arg2);
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13352 }
13353 return resultobj;
13354 fail:
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj;
13361 wxImage *arg1 = (wxImage *) 0 ;
13362 wxImageHistogram *arg2 = 0 ;
13363 unsigned long result;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "self",(char *) "h", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13372 if (SWIG_arg_fail(1)) SWIG_fail;
13373 {
13374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13375 if (SWIG_arg_fail(2)) SWIG_fail;
13376 if (arg2 == NULL) {
13377 SWIG_null_ref("wxImageHistogram");
13378 }
13379 if (SWIG_arg_fail(2)) SWIG_fail;
13380 }
13381 {
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13384
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13390 }
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj;
13399 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13400 PyObject * obj0 = 0 ;
13401 char *kwnames[] = {
13402 (char *) "handler", NULL
13403 };
13404
13405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13407 if (SWIG_arg_fail(1)) SWIG_fail;
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 wxImage::AddHandler(arg1);
13411
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 Py_INCREF(Py_None); resultobj = Py_None;
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj;
13424 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13425 PyObject * obj0 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "handler", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13432 if (SWIG_arg_fail(1)) SWIG_fail;
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 wxImage::InsertHandler(arg1);
13436
13437 wxPyEndAllowThreads(__tstate);
13438 if (PyErr_Occurred()) SWIG_fail;
13439 }
13440 Py_INCREF(Py_None); resultobj = Py_None;
13441 return resultobj;
13442 fail:
13443 return NULL;
13444 }
13445
13446
13447 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13448 PyObject *resultobj;
13449 wxString *arg1 = 0 ;
13450 bool result;
13451 bool temp1 = false ;
13452 PyObject * obj0 = 0 ;
13453 char *kwnames[] = {
13454 (char *) "name", NULL
13455 };
13456
13457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13458 {
13459 arg1 = wxString_in_helper(obj0);
13460 if (arg1 == NULL) SWIG_fail;
13461 temp1 = true;
13462 }
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 {
13471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13472 }
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 return resultobj;
13478 fail:
13479 {
13480 if (temp1)
13481 delete arg1;
13482 }
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxString result;
13490 char *kwnames[] = {
13491 NULL
13492 };
13493
13494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 result = wxImage::GetImageExtWildcard();
13498
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 {
13503 #if wxUSE_UNICODE
13504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13505 #else
13506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13507 #endif
13508 }
13509 return resultobj;
13510 fail:
13511 return NULL;
13512 }
13513
13514
13515 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13516 PyObject *resultobj;
13517 wxImage *arg1 = (wxImage *) 0 ;
13518 int arg2 = (int) -1 ;
13519 wxBitmap result;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self",(char *) "depth", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 if (obj1) {
13530 {
13531 arg2 = (int)(SWIG_As_int(obj1));
13532 if (SWIG_arg_fail(2)) SWIG_fail;
13533 }
13534 }
13535 {
13536 if (!wxPyCheckForApp()) SWIG_fail;
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = wxImage_ConvertToBitmap(arg1,arg2);
13539
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 {
13544 wxBitmap * resultptr;
13545 resultptr = new wxBitmap((wxBitmap &)(result));
13546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13547 }
13548 return resultobj;
13549 fail:
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxImage *arg1 = (wxImage *) 0 ;
13557 unsigned char arg2 ;
13558 unsigned char arg3 ;
13559 unsigned char arg4 ;
13560 wxBitmap result;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 PyObject * obj2 = 0 ;
13564 PyObject * obj3 = 0 ;
13565 char *kwnames[] = {
13566 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13567 };
13568
13569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13571 if (SWIG_arg_fail(1)) SWIG_fail;
13572 {
13573 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13574 if (SWIG_arg_fail(2)) SWIG_fail;
13575 }
13576 {
13577 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13578 if (SWIG_arg_fail(3)) SWIG_fail;
13579 }
13580 {
13581 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13582 if (SWIG_arg_fail(4)) SWIG_fail;
13583 }
13584 {
13585 if (!wxPyCheckForApp()) SWIG_fail;
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13588
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 {
13593 wxBitmap * resultptr;
13594 resultptr = new wxBitmap((wxBitmap &)(result));
13595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13596 }
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13604 PyObject *obj;
13605 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13606 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13607 Py_INCREF(obj);
13608 return Py_BuildValue((char *)"");
13609 }
13610 static int _wrap_NullImage_set(PyObject *) {
13611 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13612 return 1;
13613 }
13614
13615
13616 static PyObject *_wrap_NullImage_get(void) {
13617 PyObject *pyobj;
13618
13619 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13620 return pyobj;
13621 }
13622
13623
13624 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13625 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13626 return 1;
13627 }
13628
13629
13630 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13631 PyObject *pyobj;
13632
13633 {
13634 #if wxUSE_UNICODE
13635 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13636 #else
13637 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13638 #endif
13639 }
13640 return pyobj;
13641 }
13642
13643
13644 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13645 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13646 return 1;
13647 }
13648
13649
13650 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13651 PyObject *pyobj;
13652
13653 {
13654 #if wxUSE_UNICODE
13655 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13656 #else
13657 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13658 #endif
13659 }
13660 return pyobj;
13661 }
13662
13663
13664 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13665 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13666 return 1;
13667 }
13668
13669
13670 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13671 PyObject *pyobj;
13672
13673 {
13674 #if wxUSE_UNICODE
13675 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13676 #else
13677 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13678 #endif
13679 }
13680 return pyobj;
13681 }
13682
13683
13684 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13685 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13686 return 1;
13687 }
13688
13689
13690 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13691 PyObject *pyobj;
13692
13693 {
13694 #if wxUSE_UNICODE
13695 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13696 #else
13697 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13698 #endif
13699 }
13700 return pyobj;
13701 }
13702
13703
13704 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13705 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13706 return 1;
13707 }
13708
13709
13710 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13711 PyObject *pyobj;
13712
13713 {
13714 #if wxUSE_UNICODE
13715 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13716 #else
13717 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13718 #endif
13719 }
13720 return pyobj;
13721 }
13722
13723
13724 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13725 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13726 return 1;
13727 }
13728
13729
13730 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13731 PyObject *pyobj;
13732
13733 {
13734 #if wxUSE_UNICODE
13735 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13736 #else
13737 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13738 #endif
13739 }
13740 return pyobj;
13741 }
13742
13743
13744 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13745 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13746 return 1;
13747 }
13748
13749
13750 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13751 PyObject *pyobj;
13752
13753 {
13754 #if wxUSE_UNICODE
13755 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13756 #else
13757 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13758 #endif
13759 }
13760 return pyobj;
13761 }
13762
13763
13764 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13765 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13766 return 1;
13767 }
13768
13769
13770 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13771 PyObject *pyobj;
13772
13773 {
13774 #if wxUSE_UNICODE
13775 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13776 #else
13777 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13778 #endif
13779 }
13780 return pyobj;
13781 }
13782
13783
13784 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13785 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13786 return 1;
13787 }
13788
13789
13790 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13791 PyObject *pyobj;
13792
13793 {
13794 #if wxUSE_UNICODE
13795 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13796 #else
13797 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13798 #endif
13799 }
13800 return pyobj;
13801 }
13802
13803
13804 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13805 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13806 return 1;
13807 }
13808
13809
13810 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13811 PyObject *pyobj;
13812
13813 {
13814 #if wxUSE_UNICODE
13815 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13816 #else
13817 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13818 #endif
13819 }
13820 return pyobj;
13821 }
13822
13823
13824 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13825 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13826 return 1;
13827 }
13828
13829
13830 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13831 PyObject *pyobj;
13832
13833 {
13834 #if wxUSE_UNICODE
13835 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13836 #else
13837 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13838 #endif
13839 }
13840 return pyobj;
13841 }
13842
13843
13844 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13845 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13846 return 1;
13847 }
13848
13849
13850 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13851 PyObject *pyobj;
13852
13853 {
13854 #if wxUSE_UNICODE
13855 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13856 #else
13857 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13858 #endif
13859 }
13860 return pyobj;
13861 }
13862
13863
13864 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13865 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13866 return 1;
13867 }
13868
13869
13870 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13871 PyObject *pyobj;
13872
13873 {
13874 #if wxUSE_UNICODE
13875 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13876 #else
13877 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13878 #endif
13879 }
13880 return pyobj;
13881 }
13882
13883
13884 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13885 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13886 return 1;
13887 }
13888
13889
13890 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13891 PyObject *pyobj;
13892
13893 {
13894 #if wxUSE_UNICODE
13895 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13896 #else
13897 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13898 #endif
13899 }
13900 return pyobj;
13901 }
13902
13903
13904 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13905 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13906 return 1;
13907 }
13908
13909
13910 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13911 PyObject *pyobj;
13912
13913 {
13914 #if wxUSE_UNICODE
13915 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13916 #else
13917 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13918 #endif
13919 }
13920 return pyobj;
13921 }
13922
13923
13924 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13925 PyObject *resultobj;
13926 wxBMPHandler *result;
13927 char *kwnames[] = {
13928 NULL
13929 };
13930
13931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13932 {
13933 PyThreadState* __tstate = wxPyBeginAllowThreads();
13934 result = (wxBMPHandler *)new wxBMPHandler();
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13940 return resultobj;
13941 fail:
13942 return NULL;
13943 }
13944
13945
13946 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13947 PyObject *obj;
13948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13949 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13950 Py_INCREF(obj);
13951 return Py_BuildValue((char *)"");
13952 }
13953 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj;
13955 wxICOHandler *result;
13956 char *kwnames[] = {
13957 NULL
13958 };
13959
13960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 result = (wxICOHandler *)new wxICOHandler();
13964
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13969 return resultobj;
13970 fail:
13971 return NULL;
13972 }
13973
13974
13975 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13976 PyObject *obj;
13977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13978 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13979 Py_INCREF(obj);
13980 return Py_BuildValue((char *)"");
13981 }
13982 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj;
13984 wxCURHandler *result;
13985 char *kwnames[] = {
13986 NULL
13987 };
13988
13989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = (wxCURHandler *)new wxCURHandler();
13993
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14005 PyObject *obj;
14006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14007 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14008 Py_INCREF(obj);
14009 return Py_BuildValue((char *)"");
14010 }
14011 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14012 PyObject *resultobj;
14013 wxANIHandler *result;
14014 char *kwnames[] = {
14015 NULL
14016 };
14017
14018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (wxANIHandler *)new wxANIHandler();
14022
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14034 PyObject *obj;
14035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14036 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14037 Py_INCREF(obj);
14038 return Py_BuildValue((char *)"");
14039 }
14040 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14041 PyObject *resultobj;
14042 wxPNGHandler *result;
14043 char *kwnames[] = {
14044 NULL
14045 };
14046
14047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (wxPNGHandler *)new wxPNGHandler();
14051
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14056 return resultobj;
14057 fail:
14058 return NULL;
14059 }
14060
14061
14062 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14063 PyObject *obj;
14064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14065 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14066 Py_INCREF(obj);
14067 return Py_BuildValue((char *)"");
14068 }
14069 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj;
14071 wxGIFHandler *result;
14072 char *kwnames[] = {
14073 NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = (wxGIFHandler *)new wxGIFHandler();
14080
14081 wxPyEndAllowThreads(__tstate);
14082 if (PyErr_Occurred()) SWIG_fail;
14083 }
14084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14085 return resultobj;
14086 fail:
14087 return NULL;
14088 }
14089
14090
14091 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14092 PyObject *obj;
14093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14094 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14095 Py_INCREF(obj);
14096 return Py_BuildValue((char *)"");
14097 }
14098 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj;
14100 wxPCXHandler *result;
14101 char *kwnames[] = {
14102 NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 result = (wxPCXHandler *)new wxPCXHandler();
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14121 PyObject *obj;
14122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14123 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14124 Py_INCREF(obj);
14125 return Py_BuildValue((char *)"");
14126 }
14127 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj;
14129 wxJPEGHandler *result;
14130 char *kwnames[] = {
14131 NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (wxJPEGHandler *)new wxJPEGHandler();
14138
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14150 PyObject *obj;
14151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14152 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14153 Py_INCREF(obj);
14154 return Py_BuildValue((char *)"");
14155 }
14156 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj;
14158 wxPNMHandler *result;
14159 char *kwnames[] = {
14160 NULL
14161 };
14162
14163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = (wxPNMHandler *)new wxPNMHandler();
14167
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14172 return resultobj;
14173 fail:
14174 return NULL;
14175 }
14176
14177
14178 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14179 PyObject *obj;
14180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14181 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14182 Py_INCREF(obj);
14183 return Py_BuildValue((char *)"");
14184 }
14185 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxXPMHandler *result;
14188 char *kwnames[] = {
14189 NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14193 {
14194 PyThreadState* __tstate = wxPyBeginAllowThreads();
14195 result = (wxXPMHandler *)new wxXPMHandler();
14196
14197 wxPyEndAllowThreads(__tstate);
14198 if (PyErr_Occurred()) SWIG_fail;
14199 }
14200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14208 PyObject *obj;
14209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14210 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14211 Py_INCREF(obj);
14212 return Py_BuildValue((char *)"");
14213 }
14214 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14215 PyObject *resultobj;
14216 wxTIFFHandler *result;
14217 char *kwnames[] = {
14218 NULL
14219 };
14220
14221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (wxTIFFHandler *)new wxTIFFHandler();
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14237 PyObject *obj;
14238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14239 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14240 Py_INCREF(obj);
14241 return Py_BuildValue((char *)"");
14242 }
14243 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxImage *arg1 = 0 ;
14246 wxImage *arg2 = 0 ;
14247 int arg3 = (int) 236 ;
14248 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14249 bool result;
14250 PyObject * obj0 = 0 ;
14251 PyObject * obj1 = 0 ;
14252 PyObject * obj2 = 0 ;
14253 PyObject * obj3 = 0 ;
14254 char *kwnames[] = {
14255 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14256 };
14257
14258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14259 {
14260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(1)) SWIG_fail;
14262 if (arg1 == NULL) {
14263 SWIG_null_ref("wxImage");
14264 }
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 }
14267 {
14268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 if (arg2 == NULL) {
14271 SWIG_null_ref("wxImage");
14272 }
14273 if (SWIG_arg_fail(2)) SWIG_fail;
14274 }
14275 if (obj2) {
14276 {
14277 arg3 = (int)(SWIG_As_int(obj2));
14278 if (SWIG_arg_fail(3)) SWIG_fail;
14279 }
14280 }
14281 if (obj3) {
14282 {
14283 arg4 = (int)(SWIG_As_int(obj3));
14284 if (SWIG_arg_fail(4)) SWIG_fail;
14285 }
14286 }
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14290
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 {
14295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14296 }
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14304 PyObject *obj;
14305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14306 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14307 Py_INCREF(obj);
14308 return Py_BuildValue((char *)"");
14309 }
14310 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj;
14312 wxEvtHandler *result;
14313 char *kwnames[] = {
14314 NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (wxEvtHandler *)new wxEvtHandler();
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14335 wxEvtHandler *result;
14336 PyObject * obj0 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 {
14352 resultobj = wxPyMake_wxObject(result, 0);
14353 }
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14363 wxEvtHandler *result;
14364 PyObject * obj0 = 0 ;
14365 char *kwnames[] = {
14366 (char *) "self", NULL
14367 };
14368
14369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14371 if (SWIG_arg_fail(1)) SWIG_fail;
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 {
14380 resultobj = wxPyMake_wxObject(result, 0);
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj;
14390 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14391 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14392 PyObject * obj0 = 0 ;
14393 PyObject * obj1 = 0 ;
14394 char *kwnames[] = {
14395 (char *) "self",(char *) "handler", NULL
14396 };
14397
14398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14400 if (SWIG_arg_fail(1)) SWIG_fail;
14401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14402 if (SWIG_arg_fail(2)) SWIG_fail;
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 (arg1)->SetNextHandler(arg2);
14406
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 Py_INCREF(Py_None); resultobj = Py_None;
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj;
14419 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14420 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14421 PyObject * obj0 = 0 ;
14422 PyObject * obj1 = 0 ;
14423 char *kwnames[] = {
14424 (char *) "self",(char *) "handler", NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14431 if (SWIG_arg_fail(2)) SWIG_fail;
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 (arg1)->SetPreviousHandler(arg2);
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 Py_INCREF(Py_None); resultobj = Py_None;
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14447 PyObject *resultobj;
14448 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14449 bool result;
14450 PyObject * obj0 = 0 ;
14451 char *kwnames[] = {
14452 (char *) "self", NULL
14453 };
14454
14455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14457 if (SWIG_arg_fail(1)) SWIG_fail;
14458 {
14459 PyThreadState* __tstate = wxPyBeginAllowThreads();
14460 result = (bool)(arg1)->GetEvtHandlerEnabled();
14461
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 {
14466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14477 bool arg2 ;
14478 PyObject * obj0 = 0 ;
14479 PyObject * obj1 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self",(char *) "enabled", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 arg2 = (bool)(SWIG_As_bool(obj1));
14489 if (SWIG_arg_fail(2)) SWIG_fail;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->SetEvtHandlerEnabled(arg2);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14508 wxEvent *arg2 = 0 ;
14509 bool result;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self",(char *) "event", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14521 if (SWIG_arg_fail(2)) SWIG_fail;
14522 if (arg2 == NULL) {
14523 SWIG_null_ref("wxEvent");
14524 }
14525 if (SWIG_arg_fail(2)) SWIG_fail;
14526 }
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 result = (bool)(arg1)->ProcessEvent(*arg2);
14530
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 {
14535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14536 }
14537 return resultobj;
14538 fail:
14539 return NULL;
14540 }
14541
14542
14543 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14544 PyObject *resultobj;
14545 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14546 wxEvent *arg2 = 0 ;
14547 PyObject * obj0 = 0 ;
14548 PyObject * obj1 = 0 ;
14549 char *kwnames[] = {
14550 (char *) "self",(char *) "event", NULL
14551 };
14552
14553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14555 if (SWIG_arg_fail(1)) SWIG_fail;
14556 {
14557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14558 if (SWIG_arg_fail(2)) SWIG_fail;
14559 if (arg2 == NULL) {
14560 SWIG_null_ref("wxEvent");
14561 }
14562 if (SWIG_arg_fail(2)) SWIG_fail;
14563 }
14564 {
14565 PyThreadState* __tstate = wxPyBeginAllowThreads();
14566 (arg1)->AddPendingEvent(*arg2);
14567
14568 wxPyEndAllowThreads(__tstate);
14569 if (PyErr_Occurred()) SWIG_fail;
14570 }
14571 Py_INCREF(Py_None); resultobj = Py_None;
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj;
14580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14581 PyObject * obj0 = 0 ;
14582 char *kwnames[] = {
14583 (char *) "self", NULL
14584 };
14585
14586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14588 if (SWIG_arg_fail(1)) SWIG_fail;
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->ProcessPendingEvents();
14592
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 Py_INCREF(Py_None); resultobj = Py_None;
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14604 PyObject *resultobj;
14605 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14606 int arg2 ;
14607 int arg3 ;
14608 int arg4 ;
14609 PyObject *arg5 = (PyObject *) 0 ;
14610 PyObject * obj0 = 0 ;
14611 PyObject * obj1 = 0 ;
14612 PyObject * obj2 = 0 ;
14613 PyObject * obj3 = 0 ;
14614 PyObject * obj4 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 arg2 = (int)(SWIG_As_int(obj1));
14624 if (SWIG_arg_fail(2)) SWIG_fail;
14625 }
14626 {
14627 arg3 = (int)(SWIG_As_int(obj2));
14628 if (SWIG_arg_fail(3)) SWIG_fail;
14629 }
14630 {
14631 arg4 = (int)(SWIG_As_int(obj3));
14632 if (SWIG_arg_fail(4)) SWIG_fail;
14633 }
14634 arg5 = obj4;
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14638
14639 wxPyEndAllowThreads(__tstate);
14640 if (PyErr_Occurred()) SWIG_fail;
14641 }
14642 Py_INCREF(Py_None); resultobj = Py_None;
14643 return resultobj;
14644 fail:
14645 return NULL;
14646 }
14647
14648
14649 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14650 PyObject *resultobj;
14651 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14652 int arg2 ;
14653 int arg3 = (int) -1 ;
14654 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14655 bool result;
14656 PyObject * obj0 = 0 ;
14657 PyObject * obj1 = 0 ;
14658 PyObject * obj2 = 0 ;
14659 PyObject * obj3 = 0 ;
14660 char *kwnames[] = {
14661 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14662 };
14663
14664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14666 if (SWIG_arg_fail(1)) SWIG_fail;
14667 {
14668 arg2 = (int)(SWIG_As_int(obj1));
14669 if (SWIG_arg_fail(2)) SWIG_fail;
14670 }
14671 if (obj2) {
14672 {
14673 arg3 = (int)(SWIG_As_int(obj2));
14674 if (SWIG_arg_fail(3)) SWIG_fail;
14675 }
14676 }
14677 if (obj3) {
14678 {
14679 arg4 = (wxEventType)(SWIG_As_int(obj3));
14680 if (SWIG_arg_fail(4)) SWIG_fail;
14681 }
14682 }
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14686
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14692 }
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj;
14701 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14702 PyObject *arg2 = (PyObject *) 0 ;
14703 bool arg3 = (bool) true ;
14704 PyObject * obj0 = 0 ;
14705 PyObject * obj1 = 0 ;
14706 PyObject * obj2 = 0 ;
14707 char *kwnames[] = {
14708 (char *) "self",(char *) "_self",(char *) "incref", NULL
14709 };
14710
14711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14713 if (SWIG_arg_fail(1)) SWIG_fail;
14714 arg2 = obj1;
14715 if (obj2) {
14716 {
14717 arg3 = (bool)(SWIG_As_bool(obj2));
14718 if (SWIG_arg_fail(3)) SWIG_fail;
14719 }
14720 }
14721 {
14722 PyThreadState* __tstate = wxPyBeginAllowThreads();
14723 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14724
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 Py_INCREF(Py_None); resultobj = Py_None;
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14736 PyObject *obj;
14737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14738 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14739 Py_INCREF(obj);
14740 return Py_BuildValue((char *)"");
14741 }
14742 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj;
14744 wxEventType result;
14745 char *kwnames[] = {
14746 NULL
14747 };
14748
14749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14750 {
14751 PyThreadState* __tstate = wxPyBeginAllowThreads();
14752 result = (wxEventType)wxNewEventType();
14753
14754 wxPyEndAllowThreads(__tstate);
14755 if (PyErr_Occurred()) SWIG_fail;
14756 }
14757 {
14758 resultobj = SWIG_From_int((int)(result));
14759 }
14760 return resultobj;
14761 fail:
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxEvent *arg1 = (wxEvent *) 0 ;
14769 PyObject * obj0 = 0 ;
14770 char *kwnames[] = {
14771 (char *) "self", NULL
14772 };
14773
14774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 delete arg1;
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxEvent *arg1 = (wxEvent *) 0 ;
14794 wxEventType arg2 ;
14795 PyObject * obj0 = 0 ;
14796 PyObject * obj1 = 0 ;
14797 char *kwnames[] = {
14798 (char *) "self",(char *) "typ", NULL
14799 };
14800
14801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14803 if (SWIG_arg_fail(1)) SWIG_fail;
14804 {
14805 arg2 = (wxEventType)(SWIG_As_int(obj1));
14806 if (SWIG_arg_fail(2)) SWIG_fail;
14807 }
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 (arg1)->SetEventType(arg2);
14811
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 Py_INCREF(Py_None); resultobj = Py_None;
14816 return resultobj;
14817 fail:
14818 return NULL;
14819 }
14820
14821
14822 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj;
14824 wxEvent *arg1 = (wxEvent *) 0 ;
14825 wxEventType result;
14826 PyObject * obj0 = 0 ;
14827 char *kwnames[] = {
14828 (char *) "self", NULL
14829 };
14830
14831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14833 if (SWIG_arg_fail(1)) SWIG_fail;
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14837
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = SWIG_From_int((int)(result));
14843 }
14844 return resultobj;
14845 fail:
14846 return NULL;
14847 }
14848
14849
14850 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14851 PyObject *resultobj;
14852 wxEvent *arg1 = (wxEvent *) 0 ;
14853 wxObject *result;
14854 PyObject * obj0 = 0 ;
14855 char *kwnames[] = {
14856 (char *) "self", NULL
14857 };
14858
14859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14861 if (SWIG_arg_fail(1)) SWIG_fail;
14862 {
14863 PyThreadState* __tstate = wxPyBeginAllowThreads();
14864 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14865
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 {
14870 resultobj = wxPyMake_wxObject(result, 0);
14871 }
14872 return resultobj;
14873 fail:
14874 return NULL;
14875 }
14876
14877
14878 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj;
14880 wxEvent *arg1 = (wxEvent *) 0 ;
14881 wxObject *arg2 = (wxObject *) 0 ;
14882 PyObject * obj0 = 0 ;
14883 PyObject * obj1 = 0 ;
14884 char *kwnames[] = {
14885 (char *) "self",(char *) "obj", NULL
14886 };
14887
14888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14890 if (SWIG_arg_fail(1)) SWIG_fail;
14891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14892 if (SWIG_arg_fail(2)) SWIG_fail;
14893 {
14894 PyThreadState* __tstate = wxPyBeginAllowThreads();
14895 (arg1)->SetEventObject(arg2);
14896
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 Py_INCREF(Py_None); resultobj = Py_None;
14901 return resultobj;
14902 fail:
14903 return NULL;
14904 }
14905
14906
14907 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj;
14909 wxEvent *arg1 = (wxEvent *) 0 ;
14910 long result;
14911 PyObject * obj0 = 0 ;
14912 char *kwnames[] = {
14913 (char *) "self", NULL
14914 };
14915
14916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14918 if (SWIG_arg_fail(1)) SWIG_fail;
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14922
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 {
14927 resultobj = SWIG_From_long((long)(result));
14928 }
14929 return resultobj;
14930 fail:
14931 return NULL;
14932 }
14933
14934
14935 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14936 PyObject *resultobj;
14937 wxEvent *arg1 = (wxEvent *) 0 ;
14938 long arg2 = (long) 0 ;
14939 PyObject * obj0 = 0 ;
14940 PyObject * obj1 = 0 ;
14941 char *kwnames[] = {
14942 (char *) "self",(char *) "ts", NULL
14943 };
14944
14945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14947 if (SWIG_arg_fail(1)) SWIG_fail;
14948 if (obj1) {
14949 {
14950 arg2 = (long)(SWIG_As_long(obj1));
14951 if (SWIG_arg_fail(2)) SWIG_fail;
14952 }
14953 }
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 (arg1)->SetTimestamp(arg2);
14957
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 Py_INCREF(Py_None); resultobj = Py_None;
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14969 PyObject *resultobj;
14970 wxEvent *arg1 = (wxEvent *) 0 ;
14971 int result;
14972 PyObject * obj0 = 0 ;
14973 char *kwnames[] = {
14974 (char *) "self", NULL
14975 };
14976
14977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14979 if (SWIG_arg_fail(1)) SWIG_fail;
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (int)((wxEvent const *)arg1)->GetId();
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 {
14988 resultobj = SWIG_From_int((int)(result));
14989 }
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj;
14998 wxEvent *arg1 = (wxEvent *) 0 ;
14999 int arg2 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self",(char *) "Id", NULL
15004 };
15005
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 arg2 = (int)(SWIG_As_int(obj1));
15011 if (SWIG_arg_fail(2)) SWIG_fail;
15012 }
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 (arg1)->SetId(arg2);
15016
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 Py_INCREF(Py_None); resultobj = Py_None;
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15028 PyObject *resultobj;
15029 wxEvent *arg1 = (wxEvent *) 0 ;
15030 bool result;
15031 PyObject * obj0 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxEvent *arg1 = (wxEvent *) 0 ;
15058 bool arg2 = (bool) true ;
15059 PyObject * obj0 = 0 ;
15060 PyObject * obj1 = 0 ;
15061 char *kwnames[] = {
15062 (char *) "self",(char *) "skip", NULL
15063 };
15064
15065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15067 if (SWIG_arg_fail(1)) SWIG_fail;
15068 if (obj1) {
15069 {
15070 arg2 = (bool)(SWIG_As_bool(obj1));
15071 if (SWIG_arg_fail(2)) SWIG_fail;
15072 }
15073 }
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 (arg1)->Skip(arg2);
15077
15078 wxPyEndAllowThreads(__tstate);
15079 if (PyErr_Occurred()) SWIG_fail;
15080 }
15081 Py_INCREF(Py_None); resultobj = Py_None;
15082 return resultobj;
15083 fail:
15084 return NULL;
15085 }
15086
15087
15088 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15089 PyObject *resultobj;
15090 wxEvent *arg1 = (wxEvent *) 0 ;
15091 bool result;
15092 PyObject * obj0 = 0 ;
15093 char *kwnames[] = {
15094 (char *) "self", NULL
15095 };
15096
15097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15099 if (SWIG_arg_fail(1)) SWIG_fail;
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15103
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 {
15108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15109 }
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxEvent *arg1 = (wxEvent *) 0 ;
15119 bool result;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 {
15136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15137 }
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxEvent *arg1 = (wxEvent *) 0 ;
15147 int result;
15148 PyObject * obj0 = 0 ;
15149 char *kwnames[] = {
15150 (char *) "self", NULL
15151 };
15152
15153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15155 if (SWIG_arg_fail(1)) SWIG_fail;
15156 {
15157 PyThreadState* __tstate = wxPyBeginAllowThreads();
15158 result = (int)(arg1)->StopPropagation();
15159
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 {
15164 resultobj = SWIG_From_int((int)(result));
15165 }
15166 return resultobj;
15167 fail:
15168 return NULL;
15169 }
15170
15171
15172 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj;
15174 wxEvent *arg1 = (wxEvent *) 0 ;
15175 int arg2 ;
15176 PyObject * obj0 = 0 ;
15177 PyObject * obj1 = 0 ;
15178 char *kwnames[] = {
15179 (char *) "self",(char *) "propagationLevel", NULL
15180 };
15181
15182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15184 if (SWIG_arg_fail(1)) SWIG_fail;
15185 {
15186 arg2 = (int)(SWIG_As_int(obj1));
15187 if (SWIG_arg_fail(2)) SWIG_fail;
15188 }
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 (arg1)->ResumePropagation(arg2);
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 Py_INCREF(Py_None); resultobj = Py_None;
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxEvent *arg1 = (wxEvent *) 0 ;
15206 wxEvent *result;
15207 PyObject * obj0 = 0 ;
15208 char *kwnames[] = {
15209 (char *) "self", NULL
15210 };
15211
15212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (wxEvent *)(arg1)->Clone();
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15230 PyObject *obj;
15231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15232 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15233 Py_INCREF(obj);
15234 return Py_BuildValue((char *)"");
15235 }
15236 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxEvent *arg1 = 0 ;
15239 wxPropagationDisabler *result;
15240 PyObject * obj0 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "event", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15246 {
15247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15248 if (SWIG_arg_fail(1)) SWIG_fail;
15249 if (arg1 == NULL) {
15250 SWIG_null_ref("wxEvent");
15251 }
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 }
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj;
15270 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15271 PyObject * obj0 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 delete arg1;
15282
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 Py_INCREF(Py_None); resultobj = Py_None;
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15294 PyObject *obj;
15295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15296 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15297 Py_INCREF(obj);
15298 return Py_BuildValue((char *)"");
15299 }
15300 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15301 PyObject *resultobj;
15302 wxEvent *arg1 = 0 ;
15303 wxPropagateOnce *result;
15304 PyObject * obj0 = 0 ;
15305 char *kwnames[] = {
15306 (char *) "event", NULL
15307 };
15308
15309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15310 {
15311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15312 if (SWIG_arg_fail(1)) SWIG_fail;
15313 if (arg1 == NULL) {
15314 SWIG_null_ref("wxEvent");
15315 }
15316 if (SWIG_arg_fail(1)) SWIG_fail;
15317 }
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj;
15334 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15335 PyObject * obj0 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self", NULL
15338 };
15339
15340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15342 if (SWIG_arg_fail(1)) SWIG_fail;
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 delete arg1;
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 Py_INCREF(Py_None); resultobj = Py_None;
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15358 PyObject *obj;
15359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15360 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15361 Py_INCREF(obj);
15362 return Py_BuildValue((char *)"");
15363 }
15364 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj;
15366 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15367 int arg2 = (int) 0 ;
15368 wxCommandEvent *result;
15369 PyObject * obj0 = 0 ;
15370 PyObject * obj1 = 0 ;
15371 char *kwnames[] = {
15372 (char *) "commandType",(char *) "winid", NULL
15373 };
15374
15375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15376 if (obj0) {
15377 {
15378 arg1 = (wxEventType)(SWIG_As_int(obj0));
15379 if (SWIG_arg_fail(1)) SWIG_fail;
15380 }
15381 }
15382 if (obj1) {
15383 {
15384 arg2 = (int)(SWIG_As_int(obj1));
15385 if (SWIG_arg_fail(2)) SWIG_fail;
15386 }
15387 }
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15391
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15396 return resultobj;
15397 fail:
15398 return NULL;
15399 }
15400
15401
15402 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15403 PyObject *resultobj;
15404 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15405 int result;
15406 PyObject * obj0 = 0 ;
15407 char *kwnames[] = {
15408 (char *) "self", NULL
15409 };
15410
15411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 {
15422 resultobj = SWIG_From_int((int)(result));
15423 }
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15433 wxString *arg2 = 0 ;
15434 bool temp2 = false ;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "s", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 arg2 = wxString_in_helper(obj1);
15446 if (arg2 == NULL) SWIG_fail;
15447 temp2 = true;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 (arg1)->SetString((wxString const &)*arg2);
15452
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 Py_INCREF(Py_None); resultobj = Py_None;
15457 {
15458 if (temp2)
15459 delete arg2;
15460 }
15461 return resultobj;
15462 fail:
15463 {
15464 if (temp2)
15465 delete arg2;
15466 }
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj;
15473 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15474 wxString result;
15475 PyObject * obj0 = 0 ;
15476 char *kwnames[] = {
15477 (char *) "self", NULL
15478 };
15479
15480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15482 if (SWIG_arg_fail(1)) SWIG_fail;
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = ((wxCommandEvent const *)arg1)->GetString();
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 {
15491 #if wxUSE_UNICODE
15492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15493 #else
15494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15495 #endif
15496 }
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj;
15505 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15506 bool result;
15507 PyObject * obj0 = 0 ;
15508 char *kwnames[] = {
15509 (char *) "self", NULL
15510 };
15511
15512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15514 if (SWIG_arg_fail(1)) SWIG_fail;
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15518
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 {
15523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15524 }
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj;
15533 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15534 bool result;
15535 PyObject * obj0 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "self", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15542 if (SWIG_arg_fail(1)) SWIG_fail;
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 {
15551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15552 }
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj;
15561 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15562 long arg2 ;
15563 PyObject * obj0 = 0 ;
15564 PyObject * obj1 = 0 ;
15565 char *kwnames[] = {
15566 (char *) "self",(char *) "extraLong", NULL
15567 };
15568
15569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15571 if (SWIG_arg_fail(1)) SWIG_fail;
15572 {
15573 arg2 = (long)(SWIG_As_long(obj1));
15574 if (SWIG_arg_fail(2)) SWIG_fail;
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 (arg1)->SetExtraLong(arg2);
15579
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 Py_INCREF(Py_None); resultobj = Py_None;
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15591 PyObject *resultobj;
15592 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15593 long result;
15594 PyObject * obj0 = 0 ;
15595 char *kwnames[] = {
15596 (char *) "self", NULL
15597 };
15598
15599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15601 if (SWIG_arg_fail(1)) SWIG_fail;
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 {
15610 resultobj = SWIG_From_long((long)(result));
15611 }
15612 return resultobj;
15613 fail:
15614 return NULL;
15615 }
15616
15617
15618 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15619 PyObject *resultobj;
15620 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15621 int arg2 ;
15622 PyObject * obj0 = 0 ;
15623 PyObject * obj1 = 0 ;
15624 char *kwnames[] = {
15625 (char *) "self",(char *) "i", NULL
15626 };
15627
15628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15630 if (SWIG_arg_fail(1)) SWIG_fail;
15631 {
15632 arg2 = (int)(SWIG_As_int(obj1));
15633 if (SWIG_arg_fail(2)) SWIG_fail;
15634 }
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 (arg1)->SetInt(arg2);
15638
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 Py_INCREF(Py_None); resultobj = Py_None;
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15650 PyObject *resultobj;
15651 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15652 long result;
15653 PyObject * obj0 = 0 ;
15654 char *kwnames[] = {
15655 (char *) "self", NULL
15656 };
15657
15658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15660 if (SWIG_arg_fail(1)) SWIG_fail;
15661 {
15662 PyThreadState* __tstate = wxPyBeginAllowThreads();
15663 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15664
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 {
15669 resultobj = SWIG_From_long((long)(result));
15670 }
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15678 PyObject *resultobj;
15679 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15680 wxEvent *result;
15681 PyObject * obj0 = 0 ;
15682 char *kwnames[] = {
15683 (char *) "self", NULL
15684 };
15685
15686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15688 if (SWIG_arg_fail(1)) SWIG_fail;
15689 {
15690 PyThreadState* __tstate = wxPyBeginAllowThreads();
15691 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15692
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15704 PyObject *obj;
15705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15706 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15707 Py_INCREF(obj);
15708 return Py_BuildValue((char *)"");
15709 }
15710 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15711 PyObject *resultobj;
15712 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15713 int arg2 = (int) 0 ;
15714 wxNotifyEvent *result;
15715 PyObject * obj0 = 0 ;
15716 PyObject * obj1 = 0 ;
15717 char *kwnames[] = {
15718 (char *) "commandType",(char *) "winid", NULL
15719 };
15720
15721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15722 if (obj0) {
15723 {
15724 arg1 = (wxEventType)(SWIG_As_int(obj0));
15725 if (SWIG_arg_fail(1)) SWIG_fail;
15726 }
15727 }
15728 if (obj1) {
15729 {
15730 arg2 = (int)(SWIG_As_int(obj1));
15731 if (SWIG_arg_fail(2)) SWIG_fail;
15732 }
15733 }
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15737
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj;
15750 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15751 PyObject * obj0 = 0 ;
15752 char *kwnames[] = {
15753 (char *) "self", NULL
15754 };
15755
15756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15758 if (SWIG_arg_fail(1)) SWIG_fail;
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 (arg1)->Veto();
15762
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 Py_INCREF(Py_None); resultobj = Py_None;
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj;
15775 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15776 PyObject * obj0 = 0 ;
15777 char *kwnames[] = {
15778 (char *) "self", NULL
15779 };
15780
15781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15783 if (SWIG_arg_fail(1)) SWIG_fail;
15784 {
15785 PyThreadState* __tstate = wxPyBeginAllowThreads();
15786 (arg1)->Allow();
15787
15788 wxPyEndAllowThreads(__tstate);
15789 if (PyErr_Occurred()) SWIG_fail;
15790 }
15791 Py_INCREF(Py_None); resultobj = Py_None;
15792 return resultobj;
15793 fail:
15794 return NULL;
15795 }
15796
15797
15798 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15799 PyObject *resultobj;
15800 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15801 bool result;
15802 PyObject * obj0 = 0 ;
15803 char *kwnames[] = {
15804 (char *) "self", NULL
15805 };
15806
15807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15809 if (SWIG_arg_fail(1)) SWIG_fail;
15810 {
15811 PyThreadState* __tstate = wxPyBeginAllowThreads();
15812 result = (bool)(arg1)->IsAllowed();
15813
15814 wxPyEndAllowThreads(__tstate);
15815 if (PyErr_Occurred()) SWIG_fail;
15816 }
15817 {
15818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15819 }
15820 return resultobj;
15821 fail:
15822 return NULL;
15823 }
15824
15825
15826 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15827 PyObject *obj;
15828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15829 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15830 Py_INCREF(obj);
15831 return Py_BuildValue((char *)"");
15832 }
15833 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj;
15835 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15836 int arg2 = (int) 0 ;
15837 int arg3 = (int) 0 ;
15838 int arg4 = (int) 0 ;
15839 wxScrollEvent *result;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 PyObject * obj2 = 0 ;
15843 PyObject * obj3 = 0 ;
15844 char *kwnames[] = {
15845 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15846 };
15847
15848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15849 if (obj0) {
15850 {
15851 arg1 = (wxEventType)(SWIG_As_int(obj0));
15852 if (SWIG_arg_fail(1)) SWIG_fail;
15853 }
15854 }
15855 if (obj1) {
15856 {
15857 arg2 = (int)(SWIG_As_int(obj1));
15858 if (SWIG_arg_fail(2)) SWIG_fail;
15859 }
15860 }
15861 if (obj2) {
15862 {
15863 arg3 = (int)(SWIG_As_int(obj2));
15864 if (SWIG_arg_fail(3)) SWIG_fail;
15865 }
15866 }
15867 if (obj3) {
15868 {
15869 arg4 = (int)(SWIG_As_int(obj3));
15870 if (SWIG_arg_fail(4)) SWIG_fail;
15871 }
15872 }
15873 {
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15876
15877 wxPyEndAllowThreads(__tstate);
15878 if (PyErr_Occurred()) SWIG_fail;
15879 }
15880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15881 return resultobj;
15882 fail:
15883 return NULL;
15884 }
15885
15886
15887 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15888 PyObject *resultobj;
15889 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15890 int result;
15891 PyObject * obj0 = 0 ;
15892 char *kwnames[] = {
15893 (char *) "self", NULL
15894 };
15895
15896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15898 if (SWIG_arg_fail(1)) SWIG_fail;
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 {
15907 resultobj = SWIG_From_int((int)(result));
15908 }
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj;
15917 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15918 int result;
15919 PyObject * obj0 = 0 ;
15920 char *kwnames[] = {
15921 (char *) "self", NULL
15922 };
15923
15924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15926 if (SWIG_arg_fail(1)) SWIG_fail;
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 {
15935 resultobj = SWIG_From_int((int)(result));
15936 }
15937 return resultobj;
15938 fail:
15939 return NULL;
15940 }
15941
15942
15943 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15944 PyObject *resultobj;
15945 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15946 int arg2 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 char *kwnames[] = {
15950 (char *) "self",(char *) "orient", NULL
15951 };
15952
15953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15955 if (SWIG_arg_fail(1)) SWIG_fail;
15956 {
15957 arg2 = (int)(SWIG_As_int(obj1));
15958 if (SWIG_arg_fail(2)) SWIG_fail;
15959 }
15960 {
15961 PyThreadState* __tstate = wxPyBeginAllowThreads();
15962 (arg1)->SetOrientation(arg2);
15963
15964 wxPyEndAllowThreads(__tstate);
15965 if (PyErr_Occurred()) SWIG_fail;
15966 }
15967 Py_INCREF(Py_None); resultobj = Py_None;
15968 return resultobj;
15969 fail:
15970 return NULL;
15971 }
15972
15973
15974 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15975 PyObject *resultobj;
15976 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15977 int arg2 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self",(char *) "pos", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 arg2 = (int)(SWIG_As_int(obj1));
15989 if (SWIG_arg_fail(2)) SWIG_fail;
15990 }
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 (arg1)->SetPosition(arg2);
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 Py_INCREF(Py_None); resultobj = Py_None;
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16006 PyObject *obj;
16007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16008 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16009 Py_INCREF(obj);
16010 return Py_BuildValue((char *)"");
16011 }
16012 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj;
16014 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16015 int arg2 = (int) 0 ;
16016 int arg3 = (int) 0 ;
16017 wxScrollWinEvent *result;
16018 PyObject * obj0 = 0 ;
16019 PyObject * obj1 = 0 ;
16020 PyObject * obj2 = 0 ;
16021 char *kwnames[] = {
16022 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16023 };
16024
16025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16026 if (obj0) {
16027 {
16028 arg1 = (wxEventType)(SWIG_As_int(obj0));
16029 if (SWIG_arg_fail(1)) SWIG_fail;
16030 }
16031 }
16032 if (obj1) {
16033 {
16034 arg2 = (int)(SWIG_As_int(obj1));
16035 if (SWIG_arg_fail(2)) SWIG_fail;
16036 }
16037 }
16038 if (obj2) {
16039 {
16040 arg3 = (int)(SWIG_As_int(obj2));
16041 if (SWIG_arg_fail(3)) SWIG_fail;
16042 }
16043 }
16044 {
16045 PyThreadState* __tstate = wxPyBeginAllowThreads();
16046 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16047
16048 wxPyEndAllowThreads(__tstate);
16049 if (PyErr_Occurred()) SWIG_fail;
16050 }
16051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16052 return resultobj;
16053 fail:
16054 return NULL;
16055 }
16056
16057
16058 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16059 PyObject *resultobj;
16060 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16061 int result;
16062 PyObject * obj0 = 0 ;
16063 char *kwnames[] = {
16064 (char *) "self", NULL
16065 };
16066
16067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16069 if (SWIG_arg_fail(1)) SWIG_fail;
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 resultobj = SWIG_From_int((int)(result));
16079 }
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj;
16088 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16089 int result;
16090 PyObject * obj0 = 0 ;
16091 char *kwnames[] = {
16092 (char *) "self", NULL
16093 };
16094
16095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16097 if (SWIG_arg_fail(1)) SWIG_fail;
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16101
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 {
16106 resultobj = SWIG_From_int((int)(result));
16107 }
16108 return resultobj;
16109 fail:
16110 return NULL;
16111 }
16112
16113
16114 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16115 PyObject *resultobj;
16116 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16117 int arg2 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 char *kwnames[] = {
16121 (char *) "self",(char *) "orient", NULL
16122 };
16123
16124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16126 if (SWIG_arg_fail(1)) SWIG_fail;
16127 {
16128 arg2 = (int)(SWIG_As_int(obj1));
16129 if (SWIG_arg_fail(2)) SWIG_fail;
16130 }
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 (arg1)->SetOrientation(arg2);
16134
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 Py_INCREF(Py_None); resultobj = Py_None;
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16148 int arg2 ;
16149 PyObject * obj0 = 0 ;
16150 PyObject * obj1 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self",(char *) "pos", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 arg2 = (int)(SWIG_As_int(obj1));
16160 if (SWIG_arg_fail(2)) SWIG_fail;
16161 }
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 (arg1)->SetPosition(arg2);
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 Py_INCREF(Py_None); resultobj = Py_None;
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16177 PyObject *obj;
16178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16179 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16180 Py_INCREF(obj);
16181 return Py_BuildValue((char *)"");
16182 }
16183 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj;
16185 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16186 wxMouseEvent *result;
16187 PyObject * obj0 = 0 ;
16188 char *kwnames[] = {
16189 (char *) "mouseType", NULL
16190 };
16191
16192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16193 if (obj0) {
16194 {
16195 arg1 = (wxEventType)(SWIG_As_int(obj0));
16196 if (SWIG_arg_fail(1)) SWIG_fail;
16197 }
16198 }
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16202
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 {
16207 resultobj = wxPyMake_wxObject(result, 1);
16208 }
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj;
16217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16218 bool result;
16219 PyObject * obj0 = 0 ;
16220 char *kwnames[] = {
16221 (char *) "self", NULL
16222 };
16223
16224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16226 if (SWIG_arg_fail(1)) SWIG_fail;
16227 {
16228 PyThreadState* __tstate = wxPyBeginAllowThreads();
16229 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16230
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 {
16235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16236 }
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj;
16245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16246 int arg2 = (int) wxMOUSE_BTN_ANY ;
16247 bool result;
16248 PyObject * obj0 = 0 ;
16249 PyObject * obj1 = 0 ;
16250 char *kwnames[] = {
16251 (char *) "self",(char *) "but", NULL
16252 };
16253
16254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16256 if (SWIG_arg_fail(1)) SWIG_fail;
16257 if (obj1) {
16258 {
16259 arg2 = (int)(SWIG_As_int(obj1));
16260 if (SWIG_arg_fail(2)) SWIG_fail;
16261 }
16262 }
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 {
16271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16272 }
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj;
16281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16282 int arg2 = (int) wxMOUSE_BTN_ANY ;
16283 bool result;
16284 PyObject * obj0 = 0 ;
16285 PyObject * obj1 = 0 ;
16286 char *kwnames[] = {
16287 (char *) "self",(char *) "but", NULL
16288 };
16289
16290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16292 if (SWIG_arg_fail(1)) SWIG_fail;
16293 if (obj1) {
16294 {
16295 arg2 = (int)(SWIG_As_int(obj1));
16296 if (SWIG_arg_fail(2)) SWIG_fail;
16297 }
16298 }
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16302
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 {
16307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16308 }
16309 return resultobj;
16310 fail:
16311 return NULL;
16312 }
16313
16314
16315 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16316 PyObject *resultobj;
16317 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16318 int arg2 = (int) wxMOUSE_BTN_ANY ;
16319 bool result;
16320 PyObject * obj0 = 0 ;
16321 PyObject * obj1 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self",(char *) "but", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 if (obj1) {
16330 {
16331 arg2 = (int)(SWIG_As_int(obj1));
16332 if (SWIG_arg_fail(2)) SWIG_fail;
16333 }
16334 }
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16338
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj;
16353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16354 int arg2 ;
16355 bool result;
16356 PyObject * obj0 = 0 ;
16357 PyObject * obj1 = 0 ;
16358 char *kwnames[] = {
16359 (char *) "self",(char *) "but", NULL
16360 };
16361
16362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16364 if (SWIG_arg_fail(1)) SWIG_fail;
16365 {
16366 arg2 = (int)(SWIG_As_int(obj1));
16367 if (SWIG_arg_fail(2)) SWIG_fail;
16368 }
16369 {
16370 PyThreadState* __tstate = wxPyBeginAllowThreads();
16371 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16372
16373 wxPyEndAllowThreads(__tstate);
16374 if (PyErr_Occurred()) SWIG_fail;
16375 }
16376 {
16377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16378 }
16379 return resultobj;
16380 fail:
16381 return NULL;
16382 }
16383
16384
16385 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16386 PyObject *resultobj;
16387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16388 int arg2 ;
16389 bool result;
16390 PyObject * obj0 = 0 ;
16391 PyObject * obj1 = 0 ;
16392 char *kwnames[] = {
16393 (char *) "self",(char *) "but", NULL
16394 };
16395
16396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16398 if (SWIG_arg_fail(1)) SWIG_fail;
16399 {
16400 arg2 = (int)(SWIG_As_int(obj1));
16401 if (SWIG_arg_fail(2)) SWIG_fail;
16402 }
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16406
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 {
16411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16412 }
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj;
16421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16422 int result;
16423 PyObject * obj0 = 0 ;
16424 char *kwnames[] = {
16425 (char *) "self", NULL
16426 };
16427
16428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16430 if (SWIG_arg_fail(1)) SWIG_fail;
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16434
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 {
16439 resultobj = SWIG_From_int((int)(result));
16440 }
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj;
16449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16450 bool result;
16451 PyObject * obj0 = 0 ;
16452 char *kwnames[] = {
16453 (char *) "self", NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16458 if (SWIG_arg_fail(1)) SWIG_fail;
16459 {
16460 PyThreadState* __tstate = wxPyBeginAllowThreads();
16461 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16462
16463 wxPyEndAllowThreads(__tstate);
16464 if (PyErr_Occurred()) SWIG_fail;
16465 }
16466 {
16467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16468 }
16469 return resultobj;
16470 fail:
16471 return NULL;
16472 }
16473
16474
16475 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16476 PyObject *resultobj;
16477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16478 bool result;
16479 PyObject * obj0 = 0 ;
16480 char *kwnames[] = {
16481 (char *) "self", NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16486 if (SWIG_arg_fail(1)) SWIG_fail;
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16496 }
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj;
16505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16506 bool result;
16507 PyObject * obj0 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 PyThreadState* __tstate = wxPyBeginAllowThreads();
16517 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16518
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 {
16523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16524 }
16525 return resultobj;
16526 fail:
16527 return NULL;
16528 }
16529
16530
16531 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj;
16533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16534 bool result;
16535 PyObject * obj0 = 0 ;
16536 char *kwnames[] = {
16537 (char *) "self", NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16542 if (SWIG_arg_fail(1)) SWIG_fail;
16543 {
16544 PyThreadState* __tstate = wxPyBeginAllowThreads();
16545 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16546
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 {
16551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16552 }
16553 return resultobj;
16554 fail:
16555 return NULL;
16556 }
16557
16558
16559 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16560 PyObject *resultobj;
16561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16562 bool result;
16563 PyObject * obj0 = 0 ;
16564 char *kwnames[] = {
16565 (char *) "self", NULL
16566 };
16567
16568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16570 if (SWIG_arg_fail(1)) SWIG_fail;
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16590 bool result;
16591 PyObject * obj0 = 0 ;
16592 char *kwnames[] = {
16593 (char *) "self", NULL
16594 };
16595
16596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16598 if (SWIG_arg_fail(1)) SWIG_fail;
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16602
16603 wxPyEndAllowThreads(__tstate);
16604 if (PyErr_Occurred()) SWIG_fail;
16605 }
16606 {
16607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16608 }
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj;
16617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16618 bool result;
16619 PyObject * obj0 = 0 ;
16620 char *kwnames[] = {
16621 (char *) "self", NULL
16622 };
16623
16624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16626 if (SWIG_arg_fail(1)) SWIG_fail;
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16630
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 {
16635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16636 }
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj;
16645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16646 bool result;
16647 PyObject * obj0 = 0 ;
16648 char *kwnames[] = {
16649 (char *) "self", NULL
16650 };
16651
16652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16654 if (SWIG_arg_fail(1)) SWIG_fail;
16655 {
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16658
16659 wxPyEndAllowThreads(__tstate);
16660 if (PyErr_Occurred()) SWIG_fail;
16661 }
16662 {
16663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16664 }
16665 return resultobj;
16666 fail:
16667 return NULL;
16668 }
16669
16670
16671 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16672 PyObject *resultobj;
16673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16674 bool result;
16675 PyObject * obj0 = 0 ;
16676 char *kwnames[] = {
16677 (char *) "self", NULL
16678 };
16679
16680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16682 if (SWIG_arg_fail(1)) SWIG_fail;
16683 {
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16686
16687 wxPyEndAllowThreads(__tstate);
16688 if (PyErr_Occurred()) SWIG_fail;
16689 }
16690 {
16691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16692 }
16693 return resultobj;
16694 fail:
16695 return NULL;
16696 }
16697
16698
16699 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16700 PyObject *resultobj;
16701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16702 bool result;
16703 PyObject * obj0 = 0 ;
16704 char *kwnames[] = {
16705 (char *) "self", NULL
16706 };
16707
16708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16710 if (SWIG_arg_fail(1)) SWIG_fail;
16711 {
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16714
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 {
16719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16720 }
16721 return resultobj;
16722 fail:
16723 return NULL;
16724 }
16725
16726
16727 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16728 PyObject *resultobj;
16729 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16730 bool result;
16731 PyObject * obj0 = 0 ;
16732 char *kwnames[] = {
16733 (char *) "self", NULL
16734 };
16735
16736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16738 if (SWIG_arg_fail(1)) SWIG_fail;
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16742
16743 wxPyEndAllowThreads(__tstate);
16744 if (PyErr_Occurred()) SWIG_fail;
16745 }
16746 {
16747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16748 }
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj;
16757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16758 bool result;
16759 PyObject * obj0 = 0 ;
16760 char *kwnames[] = {
16761 (char *) "self", NULL
16762 };
16763
16764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16766 if (SWIG_arg_fail(1)) SWIG_fail;
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16770
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 {
16775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16776 }
16777 return resultobj;
16778 fail:
16779 return NULL;
16780 }
16781
16782
16783 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16784 PyObject *resultobj;
16785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16786 bool result;
16787 PyObject * obj0 = 0 ;
16788 char *kwnames[] = {
16789 (char *) "self", NULL
16790 };
16791
16792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16794 if (SWIG_arg_fail(1)) SWIG_fail;
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16798
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 {
16803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16804 }
16805 return resultobj;
16806 fail:
16807 return NULL;
16808 }
16809
16810
16811 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16812 PyObject *resultobj;
16813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16814 bool result;
16815 PyObject * obj0 = 0 ;
16816 char *kwnames[] = {
16817 (char *) "self", NULL
16818 };
16819
16820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16822 if (SWIG_arg_fail(1)) SWIG_fail;
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16826
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 {
16831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16832 }
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj;
16841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16842 bool result;
16843 PyObject * obj0 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "self", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16850 if (SWIG_arg_fail(1)) SWIG_fail;
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = (bool)(arg1)->LeftIsDown();
16854
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 {
16859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16860 }
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj;
16869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16870 bool result;
16871 PyObject * obj0 = 0 ;
16872 char *kwnames[] = {
16873 (char *) "self", NULL
16874 };
16875
16876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16878 if (SWIG_arg_fail(1)) SWIG_fail;
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 result = (bool)(arg1)->MiddleIsDown();
16882
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 {
16887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16888 }
16889 return resultobj;
16890 fail:
16891 return NULL;
16892 }
16893
16894
16895 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16896 PyObject *resultobj;
16897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16898 bool result;
16899 PyObject * obj0 = 0 ;
16900 char *kwnames[] = {
16901 (char *) "self", NULL
16902 };
16903
16904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16906 if (SWIG_arg_fail(1)) SWIG_fail;
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = (bool)(arg1)->RightIsDown();
16910
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 {
16915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16916 }
16917 return resultobj;
16918 fail:
16919 return NULL;
16920 }
16921
16922
16923 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj;
16925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16926 bool result;
16927 PyObject * obj0 = 0 ;
16928 char *kwnames[] = {
16929 (char *) "self", NULL
16930 };
16931
16932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16934 if (SWIG_arg_fail(1)) SWIG_fail;
16935 {
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16938
16939 wxPyEndAllowThreads(__tstate);
16940 if (PyErr_Occurred()) SWIG_fail;
16941 }
16942 {
16943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16944 }
16945 return resultobj;
16946 fail:
16947 return NULL;
16948 }
16949
16950
16951 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16952 PyObject *resultobj;
16953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16954 bool result;
16955 PyObject * obj0 = 0 ;
16956 char *kwnames[] = {
16957 (char *) "self", NULL
16958 };
16959
16960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16962 if (SWIG_arg_fail(1)) SWIG_fail;
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16966
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 {
16971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16972 }
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj;
16981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16982 bool result;
16983 PyObject * obj0 = 0 ;
16984 char *kwnames[] = {
16985 (char *) "self", NULL
16986 };
16987
16988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16990 if (SWIG_arg_fail(1)) SWIG_fail;
16991 {
16992 PyThreadState* __tstate = wxPyBeginAllowThreads();
16993 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16994
16995 wxPyEndAllowThreads(__tstate);
16996 if (PyErr_Occurred()) SWIG_fail;
16997 }
16998 {
16999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17000 }
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj;
17009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17010 bool result;
17011 PyObject * obj0 = 0 ;
17012 char *kwnames[] = {
17013 (char *) "self", NULL
17014 };
17015
17016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17018 if (SWIG_arg_fail(1)) SWIG_fail;
17019 {
17020 PyThreadState* __tstate = wxPyBeginAllowThreads();
17021 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17022
17023 wxPyEndAllowThreads(__tstate);
17024 if (PyErr_Occurred()) SWIG_fail;
17025 }
17026 {
17027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17028 }
17029 return resultobj;
17030 fail:
17031 return NULL;
17032 }
17033
17034
17035 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17036 PyObject *resultobj;
17037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17038 wxPoint result;
17039 PyObject * obj0 = 0 ;
17040 char *kwnames[] = {
17041 (char *) "self", NULL
17042 };
17043
17044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17046 if (SWIG_arg_fail(1)) SWIG_fail;
17047 {
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 result = (arg1)->GetPosition();
17050
17051 wxPyEndAllowThreads(__tstate);
17052 if (PyErr_Occurred()) SWIG_fail;
17053 }
17054 {
17055 wxPoint * resultptr;
17056 resultptr = new wxPoint((wxPoint &)(result));
17057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17058 }
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj;
17067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17068 long *arg2 = (long *) 0 ;
17069 long *arg3 = (long *) 0 ;
17070 long temp2 ;
17071 int res2 = 0 ;
17072 long temp3 ;
17073 int res3 = 0 ;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17080 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17083 if (SWIG_arg_fail(1)) SWIG_fail;
17084 {
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 (arg1)->GetPosition(arg2,arg3);
17087
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 Py_INCREF(Py_None); resultobj = Py_None;
17092 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17093 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17094 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17095 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj;
17104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17105 wxDC *arg2 = 0 ;
17106 wxPoint result;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 char *kwnames[] = {
17110 (char *) "self",(char *) "dc", NULL
17111 };
17112
17113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 {
17117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(2)) SWIG_fail;
17119 if (arg2 == NULL) {
17120 SWIG_null_ref("wxDC");
17121 }
17122 if (SWIG_arg_fail(2)) SWIG_fail;
17123 }
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17127
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 {
17132 wxPoint * resultptr;
17133 resultptr = new wxPoint((wxPoint &)(result));
17134 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17135 }
17136 return resultobj;
17137 fail:
17138 return NULL;
17139 }
17140
17141
17142 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj;
17144 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17145 int result;
17146 PyObject * obj0 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (int)((wxMouseEvent const *)arg1)->GetX();
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 {
17162 resultobj = SWIG_From_int((int)(result));
17163 }
17164 return resultobj;
17165 fail:
17166 return NULL;
17167 }
17168
17169
17170 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17171 PyObject *resultobj;
17172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17173 int result;
17174 PyObject * obj0 = 0 ;
17175 char *kwnames[] = {
17176 (char *) "self", NULL
17177 };
17178
17179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17181 if (SWIG_arg_fail(1)) SWIG_fail;
17182 {
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (int)((wxMouseEvent const *)arg1)->GetY();
17185
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 {
17190 resultobj = SWIG_From_int((int)(result));
17191 }
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17201 int result;
17202 PyObject * obj0 = 0 ;
17203 char *kwnames[] = {
17204 (char *) "self", NULL
17205 };
17206
17207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17209 if (SWIG_arg_fail(1)) SWIG_fail;
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17213
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 {
17218 resultobj = SWIG_From_int((int)(result));
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17229 int result;
17230 PyObject * obj0 = 0 ;
17231 char *kwnames[] = {
17232 (char *) "self", NULL
17233 };
17234
17235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17237 if (SWIG_arg_fail(1)) SWIG_fail;
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17241
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 {
17246 resultobj = SWIG_From_int((int)(result));
17247 }
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 int result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17269
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = SWIG_From_int((int)(result));
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 bool result;
17286 PyObject * obj0 = 0 ;
17287 char *kwnames[] = {
17288 (char *) "self", NULL
17289 };
17290
17291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17293 if (SWIG_arg_fail(1)) SWIG_fail;
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17297
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 {
17302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17303 }
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj;
17312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17313 int arg2 ;
17314 PyObject * obj0 = 0 ;
17315 PyObject * obj1 = 0 ;
17316 char *kwnames[] = {
17317 (char *) "self",(char *) "m_x", NULL
17318 };
17319
17320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17322 if (SWIG_arg_fail(1)) SWIG_fail;
17323 {
17324 arg2 = (int)(SWIG_As_int(obj1));
17325 if (SWIG_arg_fail(2)) SWIG_fail;
17326 }
17327 if (arg1) (arg1)->m_x = arg2;
17328
17329 Py_INCREF(Py_None); resultobj = Py_None;
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17337 PyObject *resultobj;
17338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17339 int result;
17340 PyObject * obj0 = 0 ;
17341 char *kwnames[] = {
17342 (char *) "self", NULL
17343 };
17344
17345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17347 if (SWIG_arg_fail(1)) SWIG_fail;
17348 result = (int) ((arg1)->m_x);
17349
17350 {
17351 resultobj = SWIG_From_int((int)(result));
17352 }
17353 return resultobj;
17354 fail:
17355 return NULL;
17356 }
17357
17358
17359 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17360 PyObject *resultobj;
17361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17362 int arg2 ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 char *kwnames[] = {
17366 (char *) "self",(char *) "m_y", NULL
17367 };
17368
17369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(1)) SWIG_fail;
17372 {
17373 arg2 = (int)(SWIG_As_int(obj1));
17374 if (SWIG_arg_fail(2)) SWIG_fail;
17375 }
17376 if (arg1) (arg1)->m_y = arg2;
17377
17378 Py_INCREF(Py_None); resultobj = Py_None;
17379 return resultobj;
17380 fail:
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj;
17387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17388 int result;
17389 PyObject * obj0 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 result = (int) ((arg1)->m_y);
17398
17399 {
17400 resultobj = SWIG_From_int((int)(result));
17401 }
17402 return resultobj;
17403 fail:
17404 return NULL;
17405 }
17406
17407
17408 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17409 PyObject *resultobj;
17410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17411 bool arg2 ;
17412 PyObject * obj0 = 0 ;
17413 PyObject * obj1 = 0 ;
17414 char *kwnames[] = {
17415 (char *) "self",(char *) "m_leftDown", NULL
17416 };
17417
17418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17420 if (SWIG_arg_fail(1)) SWIG_fail;
17421 {
17422 arg2 = (bool)(SWIG_As_bool(obj1));
17423 if (SWIG_arg_fail(2)) SWIG_fail;
17424 }
17425 if (arg1) (arg1)->m_leftDown = arg2;
17426
17427 Py_INCREF(Py_None); resultobj = Py_None;
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj;
17436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17437 bool result;
17438 PyObject * obj0 = 0 ;
17439 char *kwnames[] = {
17440 (char *) "self", NULL
17441 };
17442
17443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17445 if (SWIG_arg_fail(1)) SWIG_fail;
17446 result = (bool) ((arg1)->m_leftDown);
17447
17448 {
17449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 bool arg2 ;
17461 PyObject * obj0 = 0 ;
17462 PyObject * obj1 = 0 ;
17463 char *kwnames[] = {
17464 (char *) "self",(char *) "m_middleDown", NULL
17465 };
17466
17467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17469 if (SWIG_arg_fail(1)) SWIG_fail;
17470 {
17471 arg2 = (bool)(SWIG_As_bool(obj1));
17472 if (SWIG_arg_fail(2)) SWIG_fail;
17473 }
17474 if (arg1) (arg1)->m_middleDown = arg2;
17475
17476 Py_INCREF(Py_None); resultobj = Py_None;
17477 return resultobj;
17478 fail:
17479 return NULL;
17480 }
17481
17482
17483 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17484 PyObject *resultobj;
17485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17486 bool result;
17487 PyObject * obj0 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 result = (bool) ((arg1)->m_middleDown);
17496
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 return resultobj;
17501 fail:
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17509 bool arg2 ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 char *kwnames[] = {
17513 (char *) "self",(char *) "m_rightDown", NULL
17514 };
17515
17516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17518 if (SWIG_arg_fail(1)) SWIG_fail;
17519 {
17520 arg2 = (bool)(SWIG_As_bool(obj1));
17521 if (SWIG_arg_fail(2)) SWIG_fail;
17522 }
17523 if (arg1) (arg1)->m_rightDown = arg2;
17524
17525 Py_INCREF(Py_None); resultobj = Py_None;
17526 return resultobj;
17527 fail:
17528 return NULL;
17529 }
17530
17531
17532 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17533 PyObject *resultobj;
17534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17535 bool result;
17536 PyObject * obj0 = 0 ;
17537 char *kwnames[] = {
17538 (char *) "self", NULL
17539 };
17540
17541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17543 if (SWIG_arg_fail(1)) SWIG_fail;
17544 result = (bool) ((arg1)->m_rightDown);
17545
17546 {
17547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17548 }
17549 return resultobj;
17550 fail:
17551 return NULL;
17552 }
17553
17554
17555 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj;
17557 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17558 bool arg2 ;
17559 PyObject * obj0 = 0 ;
17560 PyObject * obj1 = 0 ;
17561 char *kwnames[] = {
17562 (char *) "self",(char *) "m_controlDown", NULL
17563 };
17564
17565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17567 if (SWIG_arg_fail(1)) SWIG_fail;
17568 {
17569 arg2 = (bool)(SWIG_As_bool(obj1));
17570 if (SWIG_arg_fail(2)) SWIG_fail;
17571 }
17572 if (arg1) (arg1)->m_controlDown = arg2;
17573
17574 Py_INCREF(Py_None); resultobj = Py_None;
17575 return resultobj;
17576 fail:
17577 return NULL;
17578 }
17579
17580
17581 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17582 PyObject *resultobj;
17583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17584 bool result;
17585 PyObject * obj0 = 0 ;
17586 char *kwnames[] = {
17587 (char *) "self", NULL
17588 };
17589
17590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17592 if (SWIG_arg_fail(1)) SWIG_fail;
17593 result = (bool) ((arg1)->m_controlDown);
17594
17595 {
17596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17597 }
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17605 PyObject *resultobj;
17606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17607 bool arg2 ;
17608 PyObject * obj0 = 0 ;
17609 PyObject * obj1 = 0 ;
17610 char *kwnames[] = {
17611 (char *) "self",(char *) "m_shiftDown", NULL
17612 };
17613
17614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17616 if (SWIG_arg_fail(1)) SWIG_fail;
17617 {
17618 arg2 = (bool)(SWIG_As_bool(obj1));
17619 if (SWIG_arg_fail(2)) SWIG_fail;
17620 }
17621 if (arg1) (arg1)->m_shiftDown = arg2;
17622
17623 Py_INCREF(Py_None); resultobj = Py_None;
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj;
17632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17633 bool result;
17634 PyObject * obj0 = 0 ;
17635 char *kwnames[] = {
17636 (char *) "self", NULL
17637 };
17638
17639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17641 if (SWIG_arg_fail(1)) SWIG_fail;
17642 result = (bool) ((arg1)->m_shiftDown);
17643
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17656 bool arg2 ;
17657 PyObject * obj0 = 0 ;
17658 PyObject * obj1 = 0 ;
17659 char *kwnames[] = {
17660 (char *) "self",(char *) "m_altDown", NULL
17661 };
17662
17663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17665 if (SWIG_arg_fail(1)) SWIG_fail;
17666 {
17667 arg2 = (bool)(SWIG_As_bool(obj1));
17668 if (SWIG_arg_fail(2)) SWIG_fail;
17669 }
17670 if (arg1) (arg1)->m_altDown = arg2;
17671
17672 Py_INCREF(Py_None); resultobj = Py_None;
17673 return resultobj;
17674 fail:
17675 return NULL;
17676 }
17677
17678
17679 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17680 PyObject *resultobj;
17681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17682 bool result;
17683 PyObject * obj0 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "self", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17690 if (SWIG_arg_fail(1)) SWIG_fail;
17691 result = (bool) ((arg1)->m_altDown);
17692
17693 {
17694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17695 }
17696 return resultobj;
17697 fail:
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17705 bool arg2 ;
17706 PyObject * obj0 = 0 ;
17707 PyObject * obj1 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self",(char *) "m_metaDown", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 {
17716 arg2 = (bool)(SWIG_As_bool(obj1));
17717 if (SWIG_arg_fail(2)) SWIG_fail;
17718 }
17719 if (arg1) (arg1)->m_metaDown = arg2;
17720
17721 Py_INCREF(Py_None); resultobj = Py_None;
17722 return resultobj;
17723 fail:
17724 return NULL;
17725 }
17726
17727
17728 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17729 PyObject *resultobj;
17730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17731 bool result;
17732 PyObject * obj0 = 0 ;
17733 char *kwnames[] = {
17734 (char *) "self", NULL
17735 };
17736
17737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17739 if (SWIG_arg_fail(1)) SWIG_fail;
17740 result = (bool) ((arg1)->m_metaDown);
17741
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17754 int arg2 ;
17755 PyObject * obj0 = 0 ;
17756 PyObject * obj1 = 0 ;
17757 char *kwnames[] = {
17758 (char *) "self",(char *) "m_wheelRotation", NULL
17759 };
17760
17761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17763 if (SWIG_arg_fail(1)) SWIG_fail;
17764 {
17765 arg2 = (int)(SWIG_As_int(obj1));
17766 if (SWIG_arg_fail(2)) SWIG_fail;
17767 }
17768 if (arg1) (arg1)->m_wheelRotation = arg2;
17769
17770 Py_INCREF(Py_None); resultobj = Py_None;
17771 return resultobj;
17772 fail:
17773 return NULL;
17774 }
17775
17776
17777 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17778 PyObject *resultobj;
17779 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17780 int result;
17781 PyObject * obj0 = 0 ;
17782 char *kwnames[] = {
17783 (char *) "self", NULL
17784 };
17785
17786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17788 if (SWIG_arg_fail(1)) SWIG_fail;
17789 result = (int) ((arg1)->m_wheelRotation);
17790
17791 {
17792 resultobj = SWIG_From_int((int)(result));
17793 }
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj;
17802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17803 int arg2 ;
17804 PyObject * obj0 = 0 ;
17805 PyObject * obj1 = 0 ;
17806 char *kwnames[] = {
17807 (char *) "self",(char *) "m_wheelDelta", NULL
17808 };
17809
17810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17812 if (SWIG_arg_fail(1)) SWIG_fail;
17813 {
17814 arg2 = (int)(SWIG_As_int(obj1));
17815 if (SWIG_arg_fail(2)) SWIG_fail;
17816 }
17817 if (arg1) (arg1)->m_wheelDelta = arg2;
17818
17819 Py_INCREF(Py_None); resultobj = Py_None;
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17829 int result;
17830 PyObject * obj0 = 0 ;
17831 char *kwnames[] = {
17832 (char *) "self", NULL
17833 };
17834
17835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17837 if (SWIG_arg_fail(1)) SWIG_fail;
17838 result = (int) ((arg1)->m_wheelDelta);
17839
17840 {
17841 resultobj = SWIG_From_int((int)(result));
17842 }
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj;
17851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17852 int arg2 ;
17853 PyObject * obj0 = 0 ;
17854 PyObject * obj1 = 0 ;
17855 char *kwnames[] = {
17856 (char *) "self",(char *) "m_linesPerAction", NULL
17857 };
17858
17859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17861 if (SWIG_arg_fail(1)) SWIG_fail;
17862 {
17863 arg2 = (int)(SWIG_As_int(obj1));
17864 if (SWIG_arg_fail(2)) SWIG_fail;
17865 }
17866 if (arg1) (arg1)->m_linesPerAction = arg2;
17867
17868 Py_INCREF(Py_None); resultobj = Py_None;
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj;
17877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17878 int result;
17879 PyObject * obj0 = 0 ;
17880 char *kwnames[] = {
17881 (char *) "self", NULL
17882 };
17883
17884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17886 if (SWIG_arg_fail(1)) SWIG_fail;
17887 result = (int) ((arg1)->m_linesPerAction);
17888
17889 {
17890 resultobj = SWIG_From_int((int)(result));
17891 }
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17899 PyObject *obj;
17900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17901 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17902 Py_INCREF(obj);
17903 return Py_BuildValue((char *)"");
17904 }
17905 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj;
17907 int arg1 = (int) 0 ;
17908 int arg2 = (int) 0 ;
17909 wxSetCursorEvent *result;
17910 PyObject * obj0 = 0 ;
17911 PyObject * obj1 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "x",(char *) "y", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17917 if (obj0) {
17918 {
17919 arg1 = (int)(SWIG_As_int(obj0));
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 }
17922 }
17923 if (obj1) {
17924 {
17925 arg2 = (int)(SWIG_As_int(obj1));
17926 if (SWIG_arg_fail(2)) SWIG_fail;
17927 }
17928 }
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17932
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj;
17945 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17946 int result;
17947 PyObject * obj0 = 0 ;
17948 char *kwnames[] = {
17949 (char *) "self", NULL
17950 };
17951
17952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17954 if (SWIG_arg_fail(1)) SWIG_fail;
17955 {
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17958
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 {
17963 resultobj = SWIG_From_int((int)(result));
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17972 PyObject *resultobj;
17973 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17974 int result;
17975 PyObject * obj0 = 0 ;
17976 char *kwnames[] = {
17977 (char *) "self", NULL
17978 };
17979
17980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17982 if (SWIG_arg_fail(1)) SWIG_fail;
17983 {
17984 PyThreadState* __tstate = wxPyBeginAllowThreads();
17985 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17986
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 {
17991 resultobj = SWIG_From_int((int)(result));
17992 }
17993 return resultobj;
17994 fail:
17995 return NULL;
17996 }
17997
17998
17999 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18000 PyObject *resultobj;
18001 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18002 wxCursor *arg2 = 0 ;
18003 PyObject * obj0 = 0 ;
18004 PyObject * obj1 = 0 ;
18005 char *kwnames[] = {
18006 (char *) "self",(char *) "cursor", NULL
18007 };
18008
18009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18011 if (SWIG_arg_fail(1)) SWIG_fail;
18012 {
18013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(2)) SWIG_fail;
18015 if (arg2 == NULL) {
18016 SWIG_null_ref("wxCursor");
18017 }
18018 if (SWIG_arg_fail(2)) SWIG_fail;
18019 }
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 (arg1)->SetCursor((wxCursor const &)*arg2);
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 Py_INCREF(Py_None); resultobj = Py_None;
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj;
18036 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18037 wxCursor *result;
18038 PyObject * obj0 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 {
18049 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18050 result = (wxCursor *) &_result_ref;
18051 }
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 wxCursor* resultptr = new wxCursor(*result);
18058 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18059 }
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18067 PyObject *resultobj;
18068 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18069 bool result;
18070 PyObject * obj0 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "self", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18077 if (SWIG_arg_fail(1)) SWIG_fail;
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18081
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 {
18086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18087 }
18088 return resultobj;
18089 fail:
18090 return NULL;
18091 }
18092
18093
18094 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18095 PyObject *obj;
18096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18097 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18098 Py_INCREF(obj);
18099 return Py_BuildValue((char *)"");
18100 }
18101 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18102 PyObject *resultobj;
18103 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18104 wxKeyEvent *result;
18105 PyObject * obj0 = 0 ;
18106 char *kwnames[] = {
18107 (char *) "keyType", NULL
18108 };
18109
18110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18111 if (obj0) {
18112 {
18113 arg1 = (wxEventType)(SWIG_As_int(obj0));
18114 if (SWIG_arg_fail(1)) SWIG_fail;
18115 }
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18132 PyObject *resultobj;
18133 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18134 bool result;
18135 PyObject * obj0 = 0 ;
18136 char *kwnames[] = {
18137 (char *) "self", NULL
18138 };
18139
18140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18142 if (SWIG_arg_fail(1)) SWIG_fail;
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18152 }
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj;
18161 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18162 bool result;
18163 PyObject * obj0 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18174
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 {
18179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18180 }
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj;
18189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18190 bool result;
18191 PyObject * obj0 = 0 ;
18192 char *kwnames[] = {
18193 (char *) "self", NULL
18194 };
18195
18196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18198 if (SWIG_arg_fail(1)) SWIG_fail;
18199 {
18200 PyThreadState* __tstate = wxPyBeginAllowThreads();
18201 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18202
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 {
18207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18208 }
18209 return resultobj;
18210 fail:
18211 return NULL;
18212 }
18213
18214
18215 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18216 PyObject *resultobj;
18217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18218 bool result;
18219 PyObject * obj0 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18226 if (SWIG_arg_fail(1)) SWIG_fail;
18227 {
18228 PyThreadState* __tstate = wxPyBeginAllowThreads();
18229 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18230
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 {
18235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18236 }
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18244 PyObject *resultobj;
18245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18246 bool result;
18247 PyObject * obj0 = 0 ;
18248 char *kwnames[] = {
18249 (char *) "self", NULL
18250 };
18251
18252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18254 if (SWIG_arg_fail(1)) SWIG_fail;
18255 {
18256 PyThreadState* __tstate = wxPyBeginAllowThreads();
18257 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18258
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 {
18263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18264 }
18265 return resultobj;
18266 fail:
18267 return NULL;
18268 }
18269
18270
18271 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18272 PyObject *resultobj;
18273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18274 bool result;
18275 PyObject * obj0 = 0 ;
18276 char *kwnames[] = {
18277 (char *) "self", NULL
18278 };
18279
18280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18282 if (SWIG_arg_fail(1)) SWIG_fail;
18283 {
18284 PyThreadState* __tstate = wxPyBeginAllowThreads();
18285 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18286
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 {
18291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18292 }
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18302 int result;
18303 PyObject * obj0 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18314
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 {
18319 resultobj = SWIG_From_int((int)(result));
18320 }
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18328 PyObject *resultobj;
18329 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18330 int result;
18331 PyObject * obj0 = 0 ;
18332 char *kwnames[] = {
18333 (char *) "self", NULL
18334 };
18335
18336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18338 if (SWIG_arg_fail(1)) SWIG_fail;
18339 {
18340 PyThreadState* __tstate = wxPyBeginAllowThreads();
18341 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18342
18343 wxPyEndAllowThreads(__tstate);
18344 if (PyErr_Occurred()) SWIG_fail;
18345 }
18346 {
18347 resultobj = SWIG_From_int((int)(result));
18348 }
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18356 PyObject *resultobj;
18357 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18358 unsigned int result;
18359 PyObject * obj0 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 PyThreadState* __tstate = wxPyBeginAllowThreads();
18369 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18370
18371 wxPyEndAllowThreads(__tstate);
18372 if (PyErr_Occurred()) SWIG_fail;
18373 }
18374 {
18375 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18376 }
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj;
18385 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18386 unsigned int result;
18387 PyObject * obj0 = 0 ;
18388 char *kwnames[] = {
18389 (char *) "self", NULL
18390 };
18391
18392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18394 if (SWIG_arg_fail(1)) SWIG_fail;
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18398
18399 wxPyEndAllowThreads(__tstate);
18400 if (PyErr_Occurred()) SWIG_fail;
18401 }
18402 {
18403 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18404 }
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18412 PyObject *resultobj;
18413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18414 wxPoint result;
18415 PyObject * obj0 = 0 ;
18416 char *kwnames[] = {
18417 (char *) "self", NULL
18418 };
18419
18420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18422 if (SWIG_arg_fail(1)) SWIG_fail;
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (arg1)->GetPosition();
18426
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 {
18431 wxPoint * resultptr;
18432 resultptr = new wxPoint((wxPoint &)(result));
18433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18434 }
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj;
18443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18444 long *arg2 = (long *) 0 ;
18445 long *arg3 = (long *) 0 ;
18446 long temp2 ;
18447 int res2 = 0 ;
18448 long temp3 ;
18449 int res3 = 0 ;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18456 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18459 if (SWIG_arg_fail(1)) SWIG_fail;
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 (arg1)->GetPosition(arg2,arg3);
18463
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 Py_INCREF(Py_None); resultobj = Py_None;
18468 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18469 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18470 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18471 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18481 int result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 result = (int)((wxKeyEvent const *)arg1)->GetX();
18493
18494 wxPyEndAllowThreads(__tstate);
18495 if (PyErr_Occurred()) SWIG_fail;
18496 }
18497 {
18498 resultobj = SWIG_From_int((int)(result));
18499 }
18500 return resultobj;
18501 fail:
18502 return NULL;
18503 }
18504
18505
18506 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj;
18508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18509 int result;
18510 PyObject * obj0 = 0 ;
18511 char *kwnames[] = {
18512 (char *) "self", NULL
18513 };
18514
18515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18517 if (SWIG_arg_fail(1)) SWIG_fail;
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (int)((wxKeyEvent const *)arg1)->GetY();
18521
18522 wxPyEndAllowThreads(__tstate);
18523 if (PyErr_Occurred()) SWIG_fail;
18524 }
18525 {
18526 resultobj = SWIG_From_int((int)(result));
18527 }
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18535 PyObject *resultobj;
18536 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18537 int arg2 ;
18538 PyObject * obj0 = 0 ;
18539 PyObject * obj1 = 0 ;
18540 char *kwnames[] = {
18541 (char *) "self",(char *) "m_x", NULL
18542 };
18543
18544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18546 if (SWIG_arg_fail(1)) SWIG_fail;
18547 {
18548 arg2 = (int)(SWIG_As_int(obj1));
18549 if (SWIG_arg_fail(2)) SWIG_fail;
18550 }
18551 if (arg1) (arg1)->m_x = arg2;
18552
18553 Py_INCREF(Py_None); resultobj = Py_None;
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18561 PyObject *resultobj;
18562 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18563 int result;
18564 PyObject * obj0 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 result = (int) ((arg1)->m_x);
18573
18574 {
18575 resultobj = SWIG_From_int((int)(result));
18576 }
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18584 PyObject *resultobj;
18585 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18586 int arg2 ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 char *kwnames[] = {
18590 (char *) "self",(char *) "m_y", NULL
18591 };
18592
18593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18595 if (SWIG_arg_fail(1)) SWIG_fail;
18596 {
18597 arg2 = (int)(SWIG_As_int(obj1));
18598 if (SWIG_arg_fail(2)) SWIG_fail;
18599 }
18600 if (arg1) (arg1)->m_y = arg2;
18601
18602 Py_INCREF(Py_None); resultobj = Py_None;
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18612 int result;
18613 PyObject * obj0 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "self", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 result = (int) ((arg1)->m_y);
18622
18623 {
18624 resultobj = SWIG_From_int((int)(result));
18625 }
18626 return resultobj;
18627 fail:
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18635 long arg2 ;
18636 PyObject * obj0 = 0 ;
18637 PyObject * obj1 = 0 ;
18638 char *kwnames[] = {
18639 (char *) "self",(char *) "m_keyCode", NULL
18640 };
18641
18642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18644 if (SWIG_arg_fail(1)) SWIG_fail;
18645 {
18646 arg2 = (long)(SWIG_As_long(obj1));
18647 if (SWIG_arg_fail(2)) SWIG_fail;
18648 }
18649 if (arg1) (arg1)->m_keyCode = arg2;
18650
18651 Py_INCREF(Py_None); resultobj = Py_None;
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18659 PyObject *resultobj;
18660 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18661 long result;
18662 PyObject * obj0 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 result = (long) ((arg1)->m_keyCode);
18671
18672 {
18673 resultobj = SWIG_From_long((long)(result));
18674 }
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj;
18683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18684 bool arg2 ;
18685 PyObject * obj0 = 0 ;
18686 PyObject * obj1 = 0 ;
18687 char *kwnames[] = {
18688 (char *) "self",(char *) "m_controlDown", NULL
18689 };
18690
18691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18693 if (SWIG_arg_fail(1)) SWIG_fail;
18694 {
18695 arg2 = (bool)(SWIG_As_bool(obj1));
18696 if (SWIG_arg_fail(2)) SWIG_fail;
18697 }
18698 if (arg1) (arg1)->m_controlDown = arg2;
18699
18700 Py_INCREF(Py_None); resultobj = Py_None;
18701 return resultobj;
18702 fail:
18703 return NULL;
18704 }
18705
18706
18707 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18708 PyObject *resultobj;
18709 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18710 bool result;
18711 PyObject * obj0 = 0 ;
18712 char *kwnames[] = {
18713 (char *) "self", NULL
18714 };
18715
18716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18718 if (SWIG_arg_fail(1)) SWIG_fail;
18719 result = (bool) ((arg1)->m_controlDown);
18720
18721 {
18722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18723 }
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj;
18732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18733 bool arg2 ;
18734 PyObject * obj0 = 0 ;
18735 PyObject * obj1 = 0 ;
18736 char *kwnames[] = {
18737 (char *) "self",(char *) "m_shiftDown", NULL
18738 };
18739
18740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18742 if (SWIG_arg_fail(1)) SWIG_fail;
18743 {
18744 arg2 = (bool)(SWIG_As_bool(obj1));
18745 if (SWIG_arg_fail(2)) SWIG_fail;
18746 }
18747 if (arg1) (arg1)->m_shiftDown = arg2;
18748
18749 Py_INCREF(Py_None); resultobj = Py_None;
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18759 bool result;
18760 PyObject * obj0 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 result = (bool) ((arg1)->m_shiftDown);
18769
18770 {
18771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18772 }
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18782 bool arg2 ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char *kwnames[] = {
18786 (char *) "self",(char *) "m_altDown", NULL
18787 };
18788
18789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18791 if (SWIG_arg_fail(1)) SWIG_fail;
18792 {
18793 arg2 = (bool)(SWIG_As_bool(obj1));
18794 if (SWIG_arg_fail(2)) SWIG_fail;
18795 }
18796 if (arg1) (arg1)->m_altDown = arg2;
18797
18798 Py_INCREF(Py_None); resultobj = Py_None;
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj;
18807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18808 bool result;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 result = (bool) ((arg1)->m_altDown);
18818
18819 {
18820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18821 }
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18831 bool arg2 ;
18832 PyObject * obj0 = 0 ;
18833 PyObject * obj1 = 0 ;
18834 char *kwnames[] = {
18835 (char *) "self",(char *) "m_metaDown", NULL
18836 };
18837
18838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18840 if (SWIG_arg_fail(1)) SWIG_fail;
18841 {
18842 arg2 = (bool)(SWIG_As_bool(obj1));
18843 if (SWIG_arg_fail(2)) SWIG_fail;
18844 }
18845 if (arg1) (arg1)->m_metaDown = arg2;
18846
18847 Py_INCREF(Py_None); resultobj = Py_None;
18848 return resultobj;
18849 fail:
18850 return NULL;
18851 }
18852
18853
18854 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18855 PyObject *resultobj;
18856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18857 bool result;
18858 PyObject * obj0 = 0 ;
18859 char *kwnames[] = {
18860 (char *) "self", NULL
18861 };
18862
18863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18865 if (SWIG_arg_fail(1)) SWIG_fail;
18866 result = (bool) ((arg1)->m_metaDown);
18867
18868 {
18869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18870 }
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18878 PyObject *resultobj;
18879 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18880 bool arg2 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char *kwnames[] = {
18884 (char *) "self",(char *) "m_scanCode", NULL
18885 };
18886
18887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18889 if (SWIG_arg_fail(1)) SWIG_fail;
18890 {
18891 arg2 = (bool)(SWIG_As_bool(obj1));
18892 if (SWIG_arg_fail(2)) SWIG_fail;
18893 }
18894 if (arg1) (arg1)->m_scanCode = arg2;
18895
18896 Py_INCREF(Py_None); resultobj = Py_None;
18897 return resultobj;
18898 fail:
18899 return NULL;
18900 }
18901
18902
18903 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18904 PyObject *resultobj;
18905 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18906 bool result;
18907 PyObject * obj0 = 0 ;
18908 char *kwnames[] = {
18909 (char *) "self", NULL
18910 };
18911
18912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 result = (bool) ((arg1)->m_scanCode);
18916
18917 {
18918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18929 unsigned int arg2 ;
18930 PyObject * obj0 = 0 ;
18931 PyObject * obj1 = 0 ;
18932 char *kwnames[] = {
18933 (char *) "self",(char *) "m_rawCode", NULL
18934 };
18935
18936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18938 if (SWIG_arg_fail(1)) SWIG_fail;
18939 {
18940 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18941 if (SWIG_arg_fail(2)) SWIG_fail;
18942 }
18943 if (arg1) (arg1)->m_rawCode = arg2;
18944
18945 Py_INCREF(Py_None); resultobj = Py_None;
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj;
18954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18955 unsigned int result;
18956 PyObject * obj0 = 0 ;
18957 char *kwnames[] = {
18958 (char *) "self", NULL
18959 };
18960
18961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18963 if (SWIG_arg_fail(1)) SWIG_fail;
18964 result = (unsigned int) ((arg1)->m_rawCode);
18965
18966 {
18967 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18968 }
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18978 unsigned int arg2 ;
18979 PyObject * obj0 = 0 ;
18980 PyObject * obj1 = 0 ;
18981 char *kwnames[] = {
18982 (char *) "self",(char *) "m_rawFlags", NULL
18983 };
18984
18985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18987 if (SWIG_arg_fail(1)) SWIG_fail;
18988 {
18989 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18990 if (SWIG_arg_fail(2)) SWIG_fail;
18991 }
18992 if (arg1) (arg1)->m_rawFlags = arg2;
18993
18994 Py_INCREF(Py_None); resultobj = Py_None;
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj;
19003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19004 unsigned int result;
19005 PyObject * obj0 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "self", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 result = (unsigned int) ((arg1)->m_rawFlags);
19014
19015 {
19016 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19017 }
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19025 PyObject *obj;
19026 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19027 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19028 Py_INCREF(obj);
19029 return Py_BuildValue((char *)"");
19030 }
19031 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxSize const &arg1_defvalue = wxDefaultSize ;
19034 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19035 int arg2 = (int) 0 ;
19036 wxSizeEvent *result;
19037 wxSize temp1 ;
19038 PyObject * obj0 = 0 ;
19039 PyObject * obj1 = 0 ;
19040 char *kwnames[] = {
19041 (char *) "sz",(char *) "winid", NULL
19042 };
19043
19044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19045 if (obj0) {
19046 {
19047 arg1 = &temp1;
19048 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19049 }
19050 }
19051 if (obj1) {
19052 {
19053 arg2 = (int)(SWIG_As_int(obj1));
19054 if (SWIG_arg_fail(2)) SWIG_fail;
19055 }
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19060
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19074 wxSize result;
19075 PyObject * obj0 = 0 ;
19076 char *kwnames[] = {
19077 (char *) "self", NULL
19078 };
19079
19080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = ((wxSizeEvent const *)arg1)->GetSize();
19086
19087 wxPyEndAllowThreads(__tstate);
19088 if (PyErr_Occurred()) SWIG_fail;
19089 }
19090 {
19091 wxSize * resultptr;
19092 resultptr = new wxSize((wxSize &)(result));
19093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19094 }
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19104 wxRect result;
19105 PyObject * obj0 = 0 ;
19106 char *kwnames[] = {
19107 (char *) "self", NULL
19108 };
19109
19110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19112 if (SWIG_arg_fail(1)) SWIG_fail;
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 result = ((wxSizeEvent const *)arg1)->GetRect();
19116
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 {
19121 wxRect * resultptr;
19122 resultptr = new wxRect((wxRect &)(result));
19123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19124 }
19125 return resultobj;
19126 fail:
19127 return NULL;
19128 }
19129
19130
19131 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19132 PyObject *resultobj;
19133 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19134 wxRect arg2 ;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 char *kwnames[] = {
19138 (char *) "self",(char *) "rect", NULL
19139 };
19140
19141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19143 if (SWIG_arg_fail(1)) SWIG_fail;
19144 {
19145 wxRect * argp;
19146 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19147 if (SWIG_arg_fail(2)) SWIG_fail;
19148 if (argp == NULL) {
19149 SWIG_null_ref("wxRect");
19150 }
19151 if (SWIG_arg_fail(2)) SWIG_fail;
19152 arg2 = *argp;
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 (arg1)->SetRect(arg2);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 Py_INCREF(Py_None); resultobj = Py_None;
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj;
19170 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19171 wxSize arg2 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char *kwnames[] = {
19175 (char *) "self",(char *) "size", NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19180 if (SWIG_arg_fail(1)) SWIG_fail;
19181 {
19182 wxSize * argp;
19183 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19184 if (SWIG_arg_fail(2)) SWIG_fail;
19185 if (argp == NULL) {
19186 SWIG_null_ref("wxSize");
19187 }
19188 if (SWIG_arg_fail(2)) SWIG_fail;
19189 arg2 = *argp;
19190 }
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 wxSizeEvent_SetSize(arg1,arg2);
19194
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 Py_INCREF(Py_None); resultobj = Py_None;
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj;
19207 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19208 wxSize *arg2 = (wxSize *) 0 ;
19209 PyObject * obj0 = 0 ;
19210 PyObject * obj1 = 0 ;
19211 char *kwnames[] = {
19212 (char *) "self",(char *) "m_size", NULL
19213 };
19214
19215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19217 if (SWIG_arg_fail(1)) SWIG_fail;
19218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19219 if (SWIG_arg_fail(2)) SWIG_fail;
19220 if (arg1) (arg1)->m_size = *arg2;
19221
19222 Py_INCREF(Py_None); resultobj = Py_None;
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19230 PyObject *resultobj;
19231 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19232 wxSize *result;
19233 PyObject * obj0 = 0 ;
19234 char *kwnames[] = {
19235 (char *) "self", NULL
19236 };
19237
19238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19240 if (SWIG_arg_fail(1)) SWIG_fail;
19241 result = (wxSize *)& ((arg1)->m_size);
19242
19243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19253 wxRect *arg2 = (wxRect *) 0 ;
19254 PyObject * obj0 = 0 ;
19255 PyObject * obj1 = 0 ;
19256 char *kwnames[] = {
19257 (char *) "self",(char *) "m_rect", NULL
19258 };
19259
19260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19264 if (SWIG_arg_fail(2)) SWIG_fail;
19265 if (arg1) (arg1)->m_rect = *arg2;
19266
19267 Py_INCREF(Py_None); resultobj = Py_None;
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19277 wxRect *result;
19278 PyObject * obj0 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "self", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19285 if (SWIG_arg_fail(1)) SWIG_fail;
19286 result = (wxRect *)& ((arg1)->m_rect);
19287
19288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19296 PyObject *obj;
19297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19298 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19299 Py_INCREF(obj);
19300 return Py_BuildValue((char *)"");
19301 }
19302 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19305 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19306 int arg2 = (int) 0 ;
19307 wxMoveEvent *result;
19308 wxPoint temp1 ;
19309 PyObject * obj0 = 0 ;
19310 PyObject * obj1 = 0 ;
19311 char *kwnames[] = {
19312 (char *) "pos",(char *) "winid", NULL
19313 };
19314
19315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19316 if (obj0) {
19317 {
19318 arg1 = &temp1;
19319 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19320 }
19321 }
19322 if (obj1) {
19323 {
19324 arg2 = (int)(SWIG_As_int(obj1));
19325 if (SWIG_arg_fail(2)) SWIG_fail;
19326 }
19327 }
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19331
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19343 PyObject *resultobj;
19344 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19345 wxPoint result;
19346 PyObject * obj0 = 0 ;
19347 char *kwnames[] = {
19348 (char *) "self", NULL
19349 };
19350
19351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19353 if (SWIG_arg_fail(1)) SWIG_fail;
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = ((wxMoveEvent const *)arg1)->GetPosition();
19357
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 wxPoint * resultptr;
19363 resultptr = new wxPoint((wxPoint &)(result));
19364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19365 }
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19373 PyObject *resultobj;
19374 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19375 wxRect result;
19376 PyObject * obj0 = 0 ;
19377 char *kwnames[] = {
19378 (char *) "self", NULL
19379 };
19380
19381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19383 if (SWIG_arg_fail(1)) SWIG_fail;
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = ((wxMoveEvent const *)arg1)->GetRect();
19387
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 {
19392 wxRect * resultptr;
19393 resultptr = new wxRect((wxRect &)(result));
19394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj;
19404 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19405 wxRect *arg2 = 0 ;
19406 wxRect temp2 ;
19407 PyObject * obj0 = 0 ;
19408 PyObject * obj1 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "self",(char *) "rect", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(1)) SWIG_fail;
19416 {
19417 arg2 = &temp2;
19418 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19419 }
19420 {
19421 PyThreadState* __tstate = wxPyBeginAllowThreads();
19422 (arg1)->SetRect((wxRect const &)*arg2);
19423
19424 wxPyEndAllowThreads(__tstate);
19425 if (PyErr_Occurred()) SWIG_fail;
19426 }
19427 Py_INCREF(Py_None); resultobj = Py_None;
19428 return resultobj;
19429 fail:
19430 return NULL;
19431 }
19432
19433
19434 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj;
19436 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19437 wxPoint *arg2 = 0 ;
19438 wxPoint temp2 ;
19439 PyObject * obj0 = 0 ;
19440 PyObject * obj1 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "self",(char *) "pos", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 {
19449 arg2 = &temp2;
19450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19451 }
19452 {
19453 PyThreadState* __tstate = wxPyBeginAllowThreads();
19454 (arg1)->SetPosition((wxPoint const &)*arg2);
19455
19456 wxPyEndAllowThreads(__tstate);
19457 if (PyErr_Occurred()) SWIG_fail;
19458 }
19459 Py_INCREF(Py_None); resultobj = Py_None;
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19467 PyObject *obj;
19468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19469 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19470 Py_INCREF(obj);
19471 return Py_BuildValue((char *)"");
19472 }
19473 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19474 PyObject *resultobj;
19475 int arg1 = (int) 0 ;
19476 wxPaintEvent *result;
19477 PyObject * obj0 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "Id", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19483 if (obj0) {
19484 {
19485 arg1 = (int)(SWIG_As_int(obj0));
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 }
19488 }
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19492
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19504 PyObject *obj;
19505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19506 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19507 Py_INCREF(obj);
19508 return Py_BuildValue((char *)"");
19509 }
19510 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj;
19512 int arg1 = (int) 0 ;
19513 wxNcPaintEvent *result;
19514 PyObject * obj0 = 0 ;
19515 char *kwnames[] = {
19516 (char *) "winid", NULL
19517 };
19518
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19520 if (obj0) {
19521 {
19522 arg1 = (int)(SWIG_As_int(obj0));
19523 if (SWIG_arg_fail(1)) SWIG_fail;
19524 }
19525 }
19526 {
19527 PyThreadState* __tstate = wxPyBeginAllowThreads();
19528 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19529
19530 wxPyEndAllowThreads(__tstate);
19531 if (PyErr_Occurred()) SWIG_fail;
19532 }
19533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19541 PyObject *obj;
19542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19543 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19544 Py_INCREF(obj);
19545 return Py_BuildValue((char *)"");
19546 }
19547 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj;
19549 int arg1 = (int) 0 ;
19550 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19551 wxEraseEvent *result;
19552 PyObject * obj0 = 0 ;
19553 PyObject * obj1 = 0 ;
19554 char *kwnames[] = {
19555 (char *) "Id",(char *) "dc", NULL
19556 };
19557
19558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19559 if (obj0) {
19560 {
19561 arg1 = (int)(SWIG_As_int(obj0));
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 }
19564 }
19565 if (obj1) {
19566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19567 if (SWIG_arg_fail(2)) SWIG_fail;
19568 }
19569 {
19570 PyThreadState* __tstate = wxPyBeginAllowThreads();
19571 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19572
19573 wxPyEndAllowThreads(__tstate);
19574 if (PyErr_Occurred()) SWIG_fail;
19575 }
19576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19577 return resultobj;
19578 fail:
19579 return NULL;
19580 }
19581
19582
19583 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19584 PyObject *resultobj;
19585 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19586 wxDC *result;
19587 PyObject * obj0 = 0 ;
19588 char *kwnames[] = {
19589 (char *) "self", NULL
19590 };
19591
19592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19594 if (SWIG_arg_fail(1)) SWIG_fail;
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 {
19603 resultobj = wxPyMake_wxObject(result, 0);
19604 }
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19612 PyObject *obj;
19613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19614 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19615 Py_INCREF(obj);
19616 return Py_BuildValue((char *)"");
19617 }
19618 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19619 PyObject *resultobj;
19620 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19621 int arg2 = (int) 0 ;
19622 wxFocusEvent *result;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 char *kwnames[] = {
19626 (char *) "type",(char *) "winid", NULL
19627 };
19628
19629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19630 if (obj0) {
19631 {
19632 arg1 = (wxEventType)(SWIG_As_int(obj0));
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 }
19635 }
19636 if (obj1) {
19637 {
19638 arg2 = (int)(SWIG_As_int(obj1));
19639 if (SWIG_arg_fail(2)) SWIG_fail;
19640 }
19641 }
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19645
19646 wxPyEndAllowThreads(__tstate);
19647 if (PyErr_Occurred()) SWIG_fail;
19648 }
19649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19650 return resultobj;
19651 fail:
19652 return NULL;
19653 }
19654
19655
19656 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19657 PyObject *resultobj;
19658 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19659 wxWindow *result;
19660 PyObject * obj0 = 0 ;
19661 char *kwnames[] = {
19662 (char *) "self", NULL
19663 };
19664
19665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19667 if (SWIG_arg_fail(1)) SWIG_fail;
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19671
19672 wxPyEndAllowThreads(__tstate);
19673 if (PyErr_Occurred()) SWIG_fail;
19674 }
19675 {
19676 resultobj = wxPyMake_wxObject(result, 0);
19677 }
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19685 PyObject *resultobj;
19686 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19687 wxWindow *arg2 = (wxWindow *) 0 ;
19688 PyObject * obj0 = 0 ;
19689 PyObject * obj1 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "self",(char *) "win", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19696 if (SWIG_arg_fail(1)) SWIG_fail;
19697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19698 if (SWIG_arg_fail(2)) SWIG_fail;
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 (arg1)->SetWindow(arg2);
19702
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 Py_INCREF(Py_None); resultobj = Py_None;
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19714 PyObject *obj;
19715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19716 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19717 Py_INCREF(obj);
19718 return Py_BuildValue((char *)"");
19719 }
19720 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19721 PyObject *resultobj;
19722 wxWindow *arg1 = (wxWindow *) NULL ;
19723 wxChildFocusEvent *result;
19724 PyObject * obj0 = 0 ;
19725 char *kwnames[] = {
19726 (char *) "win", NULL
19727 };
19728
19729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19730 if (obj0) {
19731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19732 if (SWIG_arg_fail(1)) SWIG_fail;
19733 }
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19737
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19742 return resultobj;
19743 fail:
19744 return NULL;
19745 }
19746
19747
19748 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19749 PyObject *resultobj;
19750 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19751 wxWindow *result;
19752 PyObject * obj0 = 0 ;
19753 char *kwnames[] = {
19754 (char *) "self", NULL
19755 };
19756
19757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19759 if (SWIG_arg_fail(1)) SWIG_fail;
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
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 * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19777 PyObject *obj;
19778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19779 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19780 Py_INCREF(obj);
19781 return Py_BuildValue((char *)"");
19782 }
19783 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19786 bool arg2 = (bool) true ;
19787 int arg3 = (int) 0 ;
19788 wxActivateEvent *result;
19789 PyObject * obj0 = 0 ;
19790 PyObject * obj1 = 0 ;
19791 PyObject * obj2 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "type",(char *) "active",(char *) "Id", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19797 if (obj0) {
19798 {
19799 arg1 = (wxEventType)(SWIG_As_int(obj0));
19800 if (SWIG_arg_fail(1)) SWIG_fail;
19801 }
19802 }
19803 if (obj1) {
19804 {
19805 arg2 = (bool)(SWIG_As_bool(obj1));
19806 if (SWIG_arg_fail(2)) SWIG_fail;
19807 }
19808 }
19809 if (obj2) {
19810 {
19811 arg3 = (int)(SWIG_As_int(obj2));
19812 if (SWIG_arg_fail(3)) SWIG_fail;
19813 }
19814 }
19815 {
19816 PyThreadState* __tstate = wxPyBeginAllowThreads();
19817 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19818
19819 wxPyEndAllowThreads(__tstate);
19820 if (PyErr_Occurred()) SWIG_fail;
19821 }
19822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19830 PyObject *resultobj;
19831 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19832 bool result;
19833 PyObject * obj0 = 0 ;
19834 char *kwnames[] = {
19835 (char *) "self", NULL
19836 };
19837
19838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19840 if (SWIG_arg_fail(1)) SWIG_fail;
19841 {
19842 PyThreadState* __tstate = wxPyBeginAllowThreads();
19843 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19844
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19858 PyObject *obj;
19859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19860 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19861 Py_INCREF(obj);
19862 return Py_BuildValue((char *)"");
19863 }
19864 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19865 PyObject *resultobj;
19866 int arg1 = (int) 0 ;
19867 wxInitDialogEvent *result;
19868 PyObject * obj0 = 0 ;
19869 char *kwnames[] = {
19870 (char *) "Id", NULL
19871 };
19872
19873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19874 if (obj0) {
19875 {
19876 arg1 = (int)(SWIG_As_int(obj0));
19877 if (SWIG_arg_fail(1)) SWIG_fail;
19878 }
19879 }
19880 {
19881 PyThreadState* __tstate = wxPyBeginAllowThreads();
19882 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19883
19884 wxPyEndAllowThreads(__tstate);
19885 if (PyErr_Occurred()) SWIG_fail;
19886 }
19887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19888 return resultobj;
19889 fail:
19890 return NULL;
19891 }
19892
19893
19894 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19895 PyObject *obj;
19896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19897 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19898 Py_INCREF(obj);
19899 return Py_BuildValue((char *)"");
19900 }
19901 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19902 PyObject *resultobj;
19903 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19904 int arg2 = (int) 0 ;
19905 wxMenu *arg3 = (wxMenu *) NULL ;
19906 wxMenuEvent *result;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 PyObject * obj2 = 0 ;
19910 char *kwnames[] = {
19911 (char *) "type",(char *) "winid",(char *) "menu", NULL
19912 };
19913
19914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19915 if (obj0) {
19916 {
19917 arg1 = (wxEventType)(SWIG_As_int(obj0));
19918 if (SWIG_arg_fail(1)) SWIG_fail;
19919 }
19920 }
19921 if (obj1) {
19922 {
19923 arg2 = (int)(SWIG_As_int(obj1));
19924 if (SWIG_arg_fail(2)) SWIG_fail;
19925 }
19926 }
19927 if (obj2) {
19928 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(3)) SWIG_fail;
19930 }
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj;
19947 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19948 int result;
19949 PyObject * obj0 = 0 ;
19950 char *kwnames[] = {
19951 (char *) "self", NULL
19952 };
19953
19954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19956 if (SWIG_arg_fail(1)) SWIG_fail;
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19960
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 {
19965 resultobj = SWIG_From_int((int)(result));
19966 }
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj;
19975 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19976 bool result;
19977 PyObject * obj0 = 0 ;
19978 char *kwnames[] = {
19979 (char *) "self", NULL
19980 };
19981
19982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19984 if (SWIG_arg_fail(1)) SWIG_fail;
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19988
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 {
19993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19994 }
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20004 wxMenu *result;
20005 PyObject * obj0 = 0 ;
20006 char *kwnames[] = {
20007 (char *) "self", NULL
20008 };
20009
20010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20012 if (SWIG_arg_fail(1)) SWIG_fail;
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20016
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 {
20021 resultobj = wxPyMake_wxObject(result, 0);
20022 }
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20030 PyObject *obj;
20031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20032 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20033 Py_INCREF(obj);
20034 return Py_BuildValue((char *)"");
20035 }
20036 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj;
20038 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20039 int arg2 = (int) 0 ;
20040 wxCloseEvent *result;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "type",(char *) "winid", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20048 if (obj0) {
20049 {
20050 arg1 = (wxEventType)(SWIG_As_int(obj0));
20051 if (SWIG_arg_fail(1)) SWIG_fail;
20052 }
20053 }
20054 if (obj1) {
20055 {
20056 arg2 = (int)(SWIG_As_int(obj1));
20057 if (SWIG_arg_fail(2)) SWIG_fail;
20058 }
20059 }
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20063
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj;
20076 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20077 bool arg2 ;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char *kwnames[] = {
20081 (char *) "self",(char *) "logOff", NULL
20082 };
20083
20084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20086 if (SWIG_arg_fail(1)) SWIG_fail;
20087 {
20088 arg2 = (bool)(SWIG_As_bool(obj1));
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 }
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 (arg1)->SetLoggingOff(arg2);
20094
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 Py_INCREF(Py_None); resultobj = Py_None;
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj;
20107 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20108 bool result;
20109 PyObject * obj0 = 0 ;
20110 char *kwnames[] = {
20111 (char *) "self", NULL
20112 };
20113
20114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20116 if (SWIG_arg_fail(1)) SWIG_fail;
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20120
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 {
20125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20126 }
20127 return resultobj;
20128 fail:
20129 return NULL;
20130 }
20131
20132
20133 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20134 PyObject *resultobj;
20135 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20136 bool arg2 = (bool) true ;
20137 PyObject * obj0 = 0 ;
20138 PyObject * obj1 = 0 ;
20139 char *kwnames[] = {
20140 (char *) "self",(char *) "veto", NULL
20141 };
20142
20143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20145 if (SWIG_arg_fail(1)) SWIG_fail;
20146 if (obj1) {
20147 {
20148 arg2 = (bool)(SWIG_As_bool(obj1));
20149 if (SWIG_arg_fail(2)) SWIG_fail;
20150 }
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 (arg1)->Veto(arg2);
20155
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 Py_INCREF(Py_None); resultobj = Py_None;
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20169 bool arg2 ;
20170 PyObject * obj0 = 0 ;
20171 PyObject * obj1 = 0 ;
20172 char *kwnames[] = {
20173 (char *) "self",(char *) "canVeto", NULL
20174 };
20175
20176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20178 if (SWIG_arg_fail(1)) SWIG_fail;
20179 {
20180 arg2 = (bool)(SWIG_As_bool(obj1));
20181 if (SWIG_arg_fail(2)) SWIG_fail;
20182 }
20183 {
20184 PyThreadState* __tstate = wxPyBeginAllowThreads();
20185 (arg1)->SetCanVeto(arg2);
20186
20187 wxPyEndAllowThreads(__tstate);
20188 if (PyErr_Occurred()) SWIG_fail;
20189 }
20190 Py_INCREF(Py_None); resultobj = Py_None;
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20198 PyObject *resultobj;
20199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20200 bool result;
20201 PyObject * obj0 = 0 ;
20202 char *kwnames[] = {
20203 (char *) "self", NULL
20204 };
20205
20206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20208 if (SWIG_arg_fail(1)) SWIG_fail;
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20212
20213 wxPyEndAllowThreads(__tstate);
20214 if (PyErr_Occurred()) SWIG_fail;
20215 }
20216 {
20217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20218 }
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj;
20227 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20228 bool result;
20229 PyObject * obj0 = 0 ;
20230 char *kwnames[] = {
20231 (char *) "self", NULL
20232 };
20233
20234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20236 if (SWIG_arg_fail(1)) SWIG_fail;
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20240
20241 wxPyEndAllowThreads(__tstate);
20242 if (PyErr_Occurred()) SWIG_fail;
20243 }
20244 {
20245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20246 }
20247 return resultobj;
20248 fail:
20249 return NULL;
20250 }
20251
20252
20253 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20254 PyObject *obj;
20255 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20256 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20257 Py_INCREF(obj);
20258 return Py_BuildValue((char *)"");
20259 }
20260 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20261 PyObject *resultobj;
20262 int arg1 = (int) 0 ;
20263 bool arg2 = (bool) false ;
20264 wxShowEvent *result;
20265 PyObject * obj0 = 0 ;
20266 PyObject * obj1 = 0 ;
20267 char *kwnames[] = {
20268 (char *) "winid",(char *) "show", NULL
20269 };
20270
20271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20272 if (obj0) {
20273 {
20274 arg1 = (int)(SWIG_As_int(obj0));
20275 if (SWIG_arg_fail(1)) SWIG_fail;
20276 }
20277 }
20278 if (obj1) {
20279 {
20280 arg2 = (bool)(SWIG_As_bool(obj1));
20281 if (SWIG_arg_fail(2)) SWIG_fail;
20282 }
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20301 bool arg2 ;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "self",(char *) "show", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20310 if (SWIG_arg_fail(1)) SWIG_fail;
20311 {
20312 arg2 = (bool)(SWIG_As_bool(obj1));
20313 if (SWIG_arg_fail(2)) SWIG_fail;
20314 }
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 (arg1)->SetShow(arg2);
20318
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 Py_INCREF(Py_None); resultobj = Py_None;
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20332 bool result;
20333 PyObject * obj0 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "self", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20340 if (SWIG_arg_fail(1)) SWIG_fail;
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20344
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 {
20349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20350 }
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20358 PyObject *obj;
20359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20360 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20361 Py_INCREF(obj);
20362 return Py_BuildValue((char *)"");
20363 }
20364 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 int arg1 = (int) 0 ;
20367 bool arg2 = (bool) true ;
20368 wxIconizeEvent *result;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 char *kwnames[] = {
20372 (char *) "id",(char *) "iconized", NULL
20373 };
20374
20375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20376 if (obj0) {
20377 {
20378 arg1 = (int)(SWIG_As_int(obj0));
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 }
20381 }
20382 if (obj1) {
20383 {
20384 arg2 = (bool)(SWIG_As_bool(obj1));
20385 if (SWIG_arg_fail(2)) SWIG_fail;
20386 }
20387 }
20388 {
20389 PyThreadState* __tstate = wxPyBeginAllowThreads();
20390 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20391
20392 wxPyEndAllowThreads(__tstate);
20393 if (PyErr_Occurred()) SWIG_fail;
20394 }
20395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20396 return resultobj;
20397 fail:
20398 return NULL;
20399 }
20400
20401
20402 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20403 PyObject *resultobj;
20404 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20405 bool result;
20406 PyObject * obj0 = 0 ;
20407 char *kwnames[] = {
20408 (char *) "self", NULL
20409 };
20410
20411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20413 if (SWIG_arg_fail(1)) SWIG_fail;
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (bool)(arg1)->Iconized();
20417
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 {
20422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20423 }
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20431 PyObject *obj;
20432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20433 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20434 Py_INCREF(obj);
20435 return Py_BuildValue((char *)"");
20436 }
20437 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20438 PyObject *resultobj;
20439 int arg1 = (int) 0 ;
20440 wxMaximizeEvent *result;
20441 PyObject * obj0 = 0 ;
20442 char *kwnames[] = {
20443 (char *) "id", NULL
20444 };
20445
20446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20447 if (obj0) {
20448 {
20449 arg1 = (int)(SWIG_As_int(obj0));
20450 if (SWIG_arg_fail(1)) SWIG_fail;
20451 }
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20456
20457 wxPyEndAllowThreads(__tstate);
20458 if (PyErr_Occurred()) SWIG_fail;
20459 }
20460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20468 PyObject *obj;
20469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20470 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20471 Py_INCREF(obj);
20472 return Py_BuildValue((char *)"");
20473 }
20474 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20477 wxPoint result;
20478 PyObject * obj0 = 0 ;
20479 char *kwnames[] = {
20480 (char *) "self", NULL
20481 };
20482
20483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20485 if (SWIG_arg_fail(1)) SWIG_fail;
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (arg1)->GetPosition();
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 {
20494 wxPoint * resultptr;
20495 resultptr = new wxPoint((wxPoint &)(result));
20496 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj;
20506 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20507 int result;
20508 PyObject * obj0 = 0 ;
20509 char *kwnames[] = {
20510 (char *) "self", NULL
20511 };
20512
20513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20515 if (SWIG_arg_fail(1)) SWIG_fail;
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 result = (int)(arg1)->GetNumberOfFiles();
20519
20520 wxPyEndAllowThreads(__tstate);
20521 if (PyErr_Occurred()) SWIG_fail;
20522 }
20523 {
20524 resultobj = SWIG_From_int((int)(result));
20525 }
20526 return resultobj;
20527 fail:
20528 return NULL;
20529 }
20530
20531
20532 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj;
20534 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20535 PyObject *result;
20536 PyObject * obj0 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20547
20548 wxPyEndAllowThreads(__tstate);
20549 if (PyErr_Occurred()) SWIG_fail;
20550 }
20551 resultobj = result;
20552 return resultobj;
20553 fail:
20554 return NULL;
20555 }
20556
20557
20558 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20559 PyObject *obj;
20560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20561 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20562 Py_INCREF(obj);
20563 return Py_BuildValue((char *)"");
20564 }
20565 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj;
20567 int arg1 = (int) 0 ;
20568 wxUpdateUIEvent *result;
20569 PyObject * obj0 = 0 ;
20570 char *kwnames[] = {
20571 (char *) "commandId", NULL
20572 };
20573
20574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20575 if (obj0) {
20576 {
20577 arg1 = (int)(SWIG_As_int(obj0));
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 }
20580 }
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20584
20585 wxPyEndAllowThreads(__tstate);
20586 if (PyErr_Occurred()) SWIG_fail;
20587 }
20588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj;
20597 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20598 bool result;
20599 PyObject * obj0 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "self", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(1)) SWIG_fail;
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 {
20615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20616 }
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20624 PyObject *resultobj;
20625 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20626 bool result;
20627 PyObject * obj0 = 0 ;
20628 char *kwnames[] = {
20629 (char *) "self", NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20634 if (SWIG_arg_fail(1)) SWIG_fail;
20635 {
20636 PyThreadState* __tstate = wxPyBeginAllowThreads();
20637 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20638
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 {
20643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj;
20653 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20654 wxString result;
20655 PyObject * obj0 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "self", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20662 if (SWIG_arg_fail(1)) SWIG_fail;
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20666
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 {
20671 #if wxUSE_UNICODE
20672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20673 #else
20674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20675 #endif
20676 }
20677 return resultobj;
20678 fail:
20679 return NULL;
20680 }
20681
20682
20683 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj;
20685 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20686 bool result;
20687 PyObject * obj0 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "self", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20694 if (SWIG_arg_fail(1)) SWIG_fail;
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20698
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 {
20703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20704 }
20705 return resultobj;
20706 fail:
20707 return NULL;
20708 }
20709
20710
20711 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20712 PyObject *resultobj;
20713 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20714 bool result;
20715 PyObject * obj0 = 0 ;
20716 char *kwnames[] = {
20717 (char *) "self", NULL
20718 };
20719
20720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20722 if (SWIG_arg_fail(1)) SWIG_fail;
20723 {
20724 PyThreadState* __tstate = wxPyBeginAllowThreads();
20725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20726
20727 wxPyEndAllowThreads(__tstate);
20728 if (PyErr_Occurred()) SWIG_fail;
20729 }
20730 {
20731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20732 }
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20740 PyObject *resultobj;
20741 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20742 bool result;
20743 PyObject * obj0 = 0 ;
20744 char *kwnames[] = {
20745 (char *) "self", NULL
20746 };
20747
20748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20750 if (SWIG_arg_fail(1)) SWIG_fail;
20751 {
20752 PyThreadState* __tstate = wxPyBeginAllowThreads();
20753 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20754
20755 wxPyEndAllowThreads(__tstate);
20756 if (PyErr_Occurred()) SWIG_fail;
20757 }
20758 {
20759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20760 }
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj;
20769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20770 bool arg2 ;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 char *kwnames[] = {
20774 (char *) "self",(char *) "check", NULL
20775 };
20776
20777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20779 if (SWIG_arg_fail(1)) SWIG_fail;
20780 {
20781 arg2 = (bool)(SWIG_As_bool(obj1));
20782 if (SWIG_arg_fail(2)) SWIG_fail;
20783 }
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 (arg1)->Check(arg2);
20787
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 Py_INCREF(Py_None); resultobj = Py_None;
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20801 bool arg2 ;
20802 PyObject * obj0 = 0 ;
20803 PyObject * obj1 = 0 ;
20804 char *kwnames[] = {
20805 (char *) "self",(char *) "enable", NULL
20806 };
20807
20808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20810 if (SWIG_arg_fail(1)) SWIG_fail;
20811 {
20812 arg2 = (bool)(SWIG_As_bool(obj1));
20813 if (SWIG_arg_fail(2)) SWIG_fail;
20814 }
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 (arg1)->Enable(arg2);
20818
20819 wxPyEndAllowThreads(__tstate);
20820 if (PyErr_Occurred()) SWIG_fail;
20821 }
20822 Py_INCREF(Py_None); resultobj = Py_None;
20823 return resultobj;
20824 fail:
20825 return NULL;
20826 }
20827
20828
20829 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20830 PyObject *resultobj;
20831 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20832 wxString *arg2 = 0 ;
20833 bool temp2 = false ;
20834 PyObject * obj0 = 0 ;
20835 PyObject * obj1 = 0 ;
20836 char *kwnames[] = {
20837 (char *) "self",(char *) "text", NULL
20838 };
20839
20840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20842 if (SWIG_arg_fail(1)) SWIG_fail;
20843 {
20844 arg2 = wxString_in_helper(obj1);
20845 if (arg2 == NULL) SWIG_fail;
20846 temp2 = true;
20847 }
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 (arg1)->SetText((wxString const &)*arg2);
20851
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 Py_INCREF(Py_None); resultobj = Py_None;
20856 {
20857 if (temp2)
20858 delete arg2;
20859 }
20860 return resultobj;
20861 fail:
20862 {
20863 if (temp2)
20864 delete arg2;
20865 }
20866 return NULL;
20867 }
20868
20869
20870 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20871 PyObject *resultobj;
20872 long arg1 ;
20873 PyObject * obj0 = 0 ;
20874 char *kwnames[] = {
20875 (char *) "updateInterval", NULL
20876 };
20877
20878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20879 {
20880 arg1 = (long)(SWIG_As_long(obj0));
20881 if (SWIG_arg_fail(1)) SWIG_fail;
20882 }
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 wxUpdateUIEvent::SetUpdateInterval(arg1);
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 Py_INCREF(Py_None); resultobj = Py_None;
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 long result;
20900 char *kwnames[] = {
20901 NULL
20902 };
20903
20904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20908
20909 wxPyEndAllowThreads(__tstate);
20910 if (PyErr_Occurred()) SWIG_fail;
20911 }
20912 {
20913 resultobj = SWIG_From_long((long)(result));
20914 }
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20922 PyObject *resultobj;
20923 wxWindow *arg1 = (wxWindow *) 0 ;
20924 bool result;
20925 PyObject * obj0 = 0 ;
20926 char *kwnames[] = {
20927 (char *) "win", NULL
20928 };
20929
20930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20932 if (SWIG_arg_fail(1)) SWIG_fail;
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20936
20937 wxPyEndAllowThreads(__tstate);
20938 if (PyErr_Occurred()) SWIG_fail;
20939 }
20940 {
20941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20942 }
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20950 PyObject *resultobj;
20951 char *kwnames[] = {
20952 NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 wxUpdateUIEvent::ResetUpdateTime();
20959
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 Py_INCREF(Py_None); resultobj = Py_None;
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxUpdateUIMode arg1 ;
20973 PyObject * obj0 = 0 ;
20974 char *kwnames[] = {
20975 (char *) "mode", NULL
20976 };
20977
20978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20979 {
20980 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 }
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20986
20987 wxPyEndAllowThreads(__tstate);
20988 if (PyErr_Occurred()) SWIG_fail;
20989 }
20990 Py_INCREF(Py_None); resultobj = Py_None;
20991 return resultobj;
20992 fail:
20993 return NULL;
20994 }
20995
20996
20997 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20998 PyObject *resultobj;
20999 wxUpdateUIMode result;
21000 char *kwnames[] = {
21001 NULL
21002 };
21003
21004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21008
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 resultobj = SWIG_From_int((result));
21013 return resultobj;
21014 fail:
21015 return NULL;
21016 }
21017
21018
21019 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21020 PyObject *obj;
21021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21022 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21023 Py_INCREF(obj);
21024 return Py_BuildValue((char *)"");
21025 }
21026 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21027 PyObject *resultobj;
21028 wxSysColourChangedEvent *result;
21029 char *kwnames[] = {
21030 NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21037
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21049 PyObject *obj;
21050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21051 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21052 Py_INCREF(obj);
21053 return Py_BuildValue((char *)"");
21054 }
21055 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21056 PyObject *resultobj;
21057 int arg1 = (int) 0 ;
21058 wxWindow *arg2 = (wxWindow *) NULL ;
21059 wxMouseCaptureChangedEvent *result;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 char *kwnames[] = {
21063 (char *) "winid",(char *) "gainedCapture", NULL
21064 };
21065
21066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21067 if (obj0) {
21068 {
21069 arg1 = (int)(SWIG_As_int(obj0));
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 }
21072 }
21073 if (obj1) {
21074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21075 if (SWIG_arg_fail(2)) SWIG_fail;
21076 }
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21080
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21092 PyObject *resultobj;
21093 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21094 wxWindow *result;
21095 PyObject * obj0 = 0 ;
21096 char *kwnames[] = {
21097 (char *) "self", NULL
21098 };
21099
21100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21102 if (SWIG_arg_fail(1)) SWIG_fail;
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21106
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 {
21111 resultobj = wxPyMake_wxObject(result, 0);
21112 }
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21120 PyObject *obj;
21121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21122 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21123 Py_INCREF(obj);
21124 return Py_BuildValue((char *)"");
21125 }
21126 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj;
21128 wxDisplayChangedEvent *result;
21129 char *kwnames[] = {
21130 NULL
21131 };
21132
21133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21137
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21149 PyObject *obj;
21150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21151 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21152 Py_INCREF(obj);
21153 return Py_BuildValue((char *)"");
21154 }
21155 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21156 PyObject *resultobj;
21157 int arg1 = (int) 0 ;
21158 wxPaletteChangedEvent *result;
21159 PyObject * obj0 = 0 ;
21160 char *kwnames[] = {
21161 (char *) "id", NULL
21162 };
21163
21164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21165 if (obj0) {
21166 {
21167 arg1 = (int)(SWIG_As_int(obj0));
21168 if (SWIG_arg_fail(1)) SWIG_fail;
21169 }
21170 }
21171 {
21172 PyThreadState* __tstate = wxPyBeginAllowThreads();
21173 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21174
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21186 PyObject *resultobj;
21187 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21188 wxWindow *arg2 = (wxWindow *) 0 ;
21189 PyObject * obj0 = 0 ;
21190 PyObject * obj1 = 0 ;
21191 char *kwnames[] = {
21192 (char *) "self",(char *) "win", NULL
21193 };
21194
21195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21197 if (SWIG_arg_fail(1)) SWIG_fail;
21198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21199 if (SWIG_arg_fail(2)) SWIG_fail;
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 (arg1)->SetChangedWindow(arg2);
21203
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 Py_INCREF(Py_None); resultobj = Py_None;
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21215 PyObject *resultobj;
21216 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21217 wxWindow *result;
21218 PyObject * obj0 = 0 ;
21219 char *kwnames[] = {
21220 (char *) "self", NULL
21221 };
21222
21223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21225 if (SWIG_arg_fail(1)) SWIG_fail;
21226 {
21227 PyThreadState* __tstate = wxPyBeginAllowThreads();
21228 result = (wxWindow *)(arg1)->GetChangedWindow();
21229
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 {
21234 resultobj = wxPyMake_wxObject(result, 0);
21235 }
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21243 PyObject *obj;
21244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21245 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21246 Py_INCREF(obj);
21247 return Py_BuildValue((char *)"");
21248 }
21249 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21250 PyObject *resultobj;
21251 int arg1 = (int) 0 ;
21252 wxQueryNewPaletteEvent *result;
21253 PyObject * obj0 = 0 ;
21254 char *kwnames[] = {
21255 (char *) "winid", NULL
21256 };
21257
21258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21259 if (obj0) {
21260 {
21261 arg1 = (int)(SWIG_As_int(obj0));
21262 if (SWIG_arg_fail(1)) SWIG_fail;
21263 }
21264 }
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21280 PyObject *resultobj;
21281 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21282 bool arg2 ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char *kwnames[] = {
21286 (char *) "self",(char *) "realized", NULL
21287 };
21288
21289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21291 if (SWIG_arg_fail(1)) SWIG_fail;
21292 {
21293 arg2 = (bool)(SWIG_As_bool(obj1));
21294 if (SWIG_arg_fail(2)) SWIG_fail;
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 (arg1)->SetPaletteRealized(arg2);
21299
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 Py_INCREF(Py_None); resultobj = Py_None;
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj;
21312 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21313 bool result;
21314 PyObject * obj0 = 0 ;
21315 char *kwnames[] = {
21316 (char *) "self", NULL
21317 };
21318
21319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21321 if (SWIG_arg_fail(1)) SWIG_fail;
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21325
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 {
21330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21331 }
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21339 PyObject *obj;
21340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21341 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21342 Py_INCREF(obj);
21343 return Py_BuildValue((char *)"");
21344 }
21345 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21346 PyObject *resultobj;
21347 wxNavigationKeyEvent *result;
21348 char *kwnames[] = {
21349 NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21356
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj;
21369 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21370 bool result;
21371 PyObject * obj0 = 0 ;
21372 char *kwnames[] = {
21373 (char *) "self", NULL
21374 };
21375
21376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21378 if (SWIG_arg_fail(1)) SWIG_fail;
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21382
21383 wxPyEndAllowThreads(__tstate);
21384 if (PyErr_Occurred()) SWIG_fail;
21385 }
21386 {
21387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21388 }
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21396 PyObject *resultobj;
21397 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21398 bool arg2 ;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char *kwnames[] = {
21402 (char *) "self",(char *) "forward", NULL
21403 };
21404
21405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21407 if (SWIG_arg_fail(1)) SWIG_fail;
21408 {
21409 arg2 = (bool)(SWIG_As_bool(obj1));
21410 if (SWIG_arg_fail(2)) SWIG_fail;
21411 }
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 (arg1)->SetDirection(arg2);
21415
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 Py_INCREF(Py_None); resultobj = Py_None;
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj;
21428 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21429 bool result;
21430 PyObject * obj0 = 0 ;
21431 char *kwnames[] = {
21432 (char *) "self", NULL
21433 };
21434
21435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21437 if (SWIG_arg_fail(1)) SWIG_fail;
21438 {
21439 PyThreadState* __tstate = wxPyBeginAllowThreads();
21440 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21441
21442 wxPyEndAllowThreads(__tstate);
21443 if (PyErr_Occurred()) SWIG_fail;
21444 }
21445 {
21446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21447 }
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21455 PyObject *resultobj;
21456 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21457 bool arg2 ;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 char *kwnames[] = {
21461 (char *) "self",(char *) "ischange", NULL
21462 };
21463
21464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21466 if (SWIG_arg_fail(1)) SWIG_fail;
21467 {
21468 arg2 = (bool)(SWIG_As_bool(obj1));
21469 if (SWIG_arg_fail(2)) SWIG_fail;
21470 }
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 (arg1)->SetWindowChange(arg2);
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 Py_INCREF(Py_None); resultobj = Py_None;
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21486 PyObject *resultobj;
21487 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21488 bool result;
21489 PyObject * obj0 = 0 ;
21490 char *kwnames[] = {
21491 (char *) "self", NULL
21492 };
21493
21494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21496 if (SWIG_arg_fail(1)) SWIG_fail;
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21500
21501 wxPyEndAllowThreads(__tstate);
21502 if (PyErr_Occurred()) SWIG_fail;
21503 }
21504 {
21505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21506 }
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21514 PyObject *resultobj;
21515 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21516 bool arg2 ;
21517 PyObject * obj0 = 0 ;
21518 PyObject * obj1 = 0 ;
21519 char *kwnames[] = {
21520 (char *) "self",(char *) "bIs", NULL
21521 };
21522
21523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21525 if (SWIG_arg_fail(1)) SWIG_fail;
21526 {
21527 arg2 = (bool)(SWIG_As_bool(obj1));
21528 if (SWIG_arg_fail(2)) SWIG_fail;
21529 }
21530 {
21531 PyThreadState* __tstate = wxPyBeginAllowThreads();
21532 (arg1)->SetFromTab(arg2);
21533
21534 wxPyEndAllowThreads(__tstate);
21535 if (PyErr_Occurred()) SWIG_fail;
21536 }
21537 Py_INCREF(Py_None); resultobj = Py_None;
21538 return resultobj;
21539 fail:
21540 return NULL;
21541 }
21542
21543
21544 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21545 PyObject *resultobj;
21546 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21547 long arg2 ;
21548 PyObject * obj0 = 0 ;
21549 PyObject * obj1 = 0 ;
21550 char *kwnames[] = {
21551 (char *) "self",(char *) "flags", NULL
21552 };
21553
21554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21556 if (SWIG_arg_fail(1)) SWIG_fail;
21557 {
21558 arg2 = (long)(SWIG_As_long(obj1));
21559 if (SWIG_arg_fail(2)) SWIG_fail;
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 (arg1)->SetFlags(arg2);
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 Py_INCREF(Py_None); resultobj = Py_None;
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21578 wxWindow *result;
21579 PyObject * obj0 = 0 ;
21580 char *kwnames[] = {
21581 (char *) "self", NULL
21582 };
21583
21584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21586 if (SWIG_arg_fail(1)) SWIG_fail;
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21590
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 {
21595 resultobj = wxPyMake_wxObject(result, 0);
21596 }
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21604 PyObject *resultobj;
21605 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21606 wxWindow *arg2 = (wxWindow *) 0 ;
21607 PyObject * obj0 = 0 ;
21608 PyObject * obj1 = 0 ;
21609 char *kwnames[] = {
21610 (char *) "self",(char *) "win", NULL
21611 };
21612
21613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21615 if (SWIG_arg_fail(1)) SWIG_fail;
21616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21617 if (SWIG_arg_fail(2)) SWIG_fail;
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 (arg1)->SetCurrentFocus(arg2);
21621
21622 wxPyEndAllowThreads(__tstate);
21623 if (PyErr_Occurred()) SWIG_fail;
21624 }
21625 Py_INCREF(Py_None); resultobj = Py_None;
21626 return resultobj;
21627 fail:
21628 return NULL;
21629 }
21630
21631
21632 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21633 PyObject *obj;
21634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21635 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21636 Py_INCREF(obj);
21637 return Py_BuildValue((char *)"");
21638 }
21639 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj;
21641 wxWindow *arg1 = (wxWindow *) NULL ;
21642 wxWindowCreateEvent *result;
21643 PyObject * obj0 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "win", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21649 if (obj0) {
21650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21651 if (SWIG_arg_fail(1)) SWIG_fail;
21652 }
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21656
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21670 wxWindow *result;
21671 PyObject * obj0 = 0 ;
21672 char *kwnames[] = {
21673 (char *) "self", NULL
21674 };
21675
21676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 {
21687 resultobj = wxPyMake_wxObject(result, 0);
21688 }
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21696 PyObject *obj;
21697 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21698 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21699 Py_INCREF(obj);
21700 return Py_BuildValue((char *)"");
21701 }
21702 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21703 PyObject *resultobj;
21704 wxWindow *arg1 = (wxWindow *) NULL ;
21705 wxWindowDestroyEvent *result;
21706 PyObject * obj0 = 0 ;
21707 char *kwnames[] = {
21708 (char *) "win", NULL
21709 };
21710
21711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21712 if (obj0) {
21713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21714 if (SWIG_arg_fail(1)) SWIG_fail;
21715 }
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21731 PyObject *resultobj;
21732 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21733 wxWindow *result;
21734 PyObject * obj0 = 0 ;
21735 char *kwnames[] = {
21736 (char *) "self", NULL
21737 };
21738
21739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21741 if (SWIG_arg_fail(1)) SWIG_fail;
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21745
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 {
21750 resultobj = wxPyMake_wxObject(result, 0);
21751 }
21752 return resultobj;
21753 fail:
21754 return NULL;
21755 }
21756
21757
21758 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21759 PyObject *obj;
21760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21761 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21762 Py_INCREF(obj);
21763 return Py_BuildValue((char *)"");
21764 }
21765 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj;
21767 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21768 int arg2 = (int) 0 ;
21769 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21770 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21771 wxContextMenuEvent *result;
21772 wxPoint temp3 ;
21773 PyObject * obj0 = 0 ;
21774 PyObject * obj1 = 0 ;
21775 PyObject * obj2 = 0 ;
21776 char *kwnames[] = {
21777 (char *) "type",(char *) "winid",(char *) "pt", NULL
21778 };
21779
21780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21781 if (obj0) {
21782 {
21783 arg1 = (wxEventType)(SWIG_As_int(obj0));
21784 if (SWIG_arg_fail(1)) SWIG_fail;
21785 }
21786 }
21787 if (obj1) {
21788 {
21789 arg2 = (int)(SWIG_As_int(obj1));
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 }
21792 }
21793 if (obj2) {
21794 {
21795 arg3 = &temp3;
21796 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21797 }
21798 }
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21802
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21814 PyObject *resultobj;
21815 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21816 wxPoint *result;
21817 PyObject * obj0 = 0 ;
21818 char *kwnames[] = {
21819 (char *) "self", NULL
21820 };
21821
21822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21824 if (SWIG_arg_fail(1)) SWIG_fail;
21825 {
21826 PyThreadState* __tstate = wxPyBeginAllowThreads();
21827 {
21828 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21829 result = (wxPoint *) &_result_ref;
21830 }
21831
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj;
21844 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21845 wxPoint *arg2 = 0 ;
21846 wxPoint temp2 ;
21847 PyObject * obj0 = 0 ;
21848 PyObject * obj1 = 0 ;
21849 char *kwnames[] = {
21850 (char *) "self",(char *) "pos", NULL
21851 };
21852
21853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21855 if (SWIG_arg_fail(1)) SWIG_fail;
21856 {
21857 arg2 = &temp2;
21858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 (arg1)->SetPosition((wxPoint const &)*arg2);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 Py_INCREF(Py_None); resultobj = Py_None;
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21875 PyObject *obj;
21876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21877 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21878 Py_INCREF(obj);
21879 return Py_BuildValue((char *)"");
21880 }
21881 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj;
21883 wxIdleEvent *result;
21884 char *kwnames[] = {
21885 NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (wxIdleEvent *)new wxIdleEvent();
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj;
21905 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21906 bool arg2 = (bool) true ;
21907 PyObject * obj0 = 0 ;
21908 PyObject * obj1 = 0 ;
21909 char *kwnames[] = {
21910 (char *) "self",(char *) "needMore", NULL
21911 };
21912
21913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21915 if (SWIG_arg_fail(1)) SWIG_fail;
21916 if (obj1) {
21917 {
21918 arg2 = (bool)(SWIG_As_bool(obj1));
21919 if (SWIG_arg_fail(2)) SWIG_fail;
21920 }
21921 }
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 (arg1)->RequestMore(arg2);
21925
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 Py_INCREF(Py_None); resultobj = Py_None;
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj;
21938 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21939 bool result;
21940 PyObject * obj0 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "self", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21947 if (SWIG_arg_fail(1)) SWIG_fail;
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21951
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21957 }
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj;
21966 wxIdleMode arg1 ;
21967 PyObject * obj0 = 0 ;
21968 char *kwnames[] = {
21969 (char *) "mode", NULL
21970 };
21971
21972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21973 {
21974 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21975 if (SWIG_arg_fail(1)) SWIG_fail;
21976 }
21977 {
21978 PyThreadState* __tstate = wxPyBeginAllowThreads();
21979 wxIdleEvent::SetMode((wxIdleMode )arg1);
21980
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 Py_INCREF(Py_None); resultobj = Py_None;
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj;
21993 wxIdleMode result;
21994 char *kwnames[] = {
21995 NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (wxIdleMode)wxIdleEvent::GetMode();
22002
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 resultobj = SWIG_From_int((result));
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22014 PyObject *resultobj;
22015 wxWindow *arg1 = (wxWindow *) 0 ;
22016 bool result;
22017 PyObject * obj0 = 0 ;
22018 char *kwnames[] = {
22019 (char *) "win", NULL
22020 };
22021
22022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22024 if (SWIG_arg_fail(1)) SWIG_fail;
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 result = (bool)wxIdleEvent::CanSend(arg1);
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 {
22033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22034 }
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22042 PyObject *obj;
22043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22044 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22045 Py_INCREF(obj);
22046 return Py_BuildValue((char *)"");
22047 }
22048 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj;
22050 int arg1 = (int) 0 ;
22051 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22052 wxPyEvent *result;
22053 PyObject * obj0 = 0 ;
22054 PyObject * obj1 = 0 ;
22055 char *kwnames[] = {
22056 (char *) "winid",(char *) "commandType", NULL
22057 };
22058
22059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22060 if (obj0) {
22061 {
22062 arg1 = (int)(SWIG_As_int(obj0));
22063 if (SWIG_arg_fail(1)) SWIG_fail;
22064 }
22065 }
22066 if (obj1) {
22067 {
22068 arg2 = (wxEventType)(SWIG_As_int(obj1));
22069 if (SWIG_arg_fail(2)) SWIG_fail;
22070 }
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22075
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22087 PyObject *resultobj;
22088 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22089 PyObject * obj0 = 0 ;
22090 char *kwnames[] = {
22091 (char *) "self", NULL
22092 };
22093
22094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22096 if (SWIG_arg_fail(1)) SWIG_fail;
22097 {
22098 PyThreadState* __tstate = wxPyBeginAllowThreads();
22099 delete arg1;
22100
22101 wxPyEndAllowThreads(__tstate);
22102 if (PyErr_Occurred()) SWIG_fail;
22103 }
22104 Py_INCREF(Py_None); resultobj = Py_None;
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj;
22113 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22114 PyObject *arg2 = (PyObject *) 0 ;
22115 PyObject * obj0 = 0 ;
22116 PyObject * obj1 = 0 ;
22117 char *kwnames[] = {
22118 (char *) "self",(char *) "self", NULL
22119 };
22120
22121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22123 if (SWIG_arg_fail(1)) SWIG_fail;
22124 arg2 = obj1;
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 (arg1)->SetSelf(arg2);
22128
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 Py_INCREF(Py_None); resultobj = Py_None;
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj;
22141 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22142 PyObject *result;
22143 PyObject * obj0 = 0 ;
22144 char *kwnames[] = {
22145 (char *) "self", NULL
22146 };
22147
22148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(1)) SWIG_fail;
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (PyObject *)(arg1)->GetSelf();
22154
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = result;
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22166 PyObject *obj;
22167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22168 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22169 Py_INCREF(obj);
22170 return Py_BuildValue((char *)"");
22171 }
22172 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22173 PyObject *resultobj;
22174 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22175 int arg2 = (int) 0 ;
22176 wxPyCommandEvent *result;
22177 PyObject * obj0 = 0 ;
22178 PyObject * obj1 = 0 ;
22179 char *kwnames[] = {
22180 (char *) "commandType",(char *) "id", NULL
22181 };
22182
22183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22184 if (obj0) {
22185 {
22186 arg1 = (wxEventType)(SWIG_As_int(obj0));
22187 if (SWIG_arg_fail(1)) SWIG_fail;
22188 }
22189 }
22190 if (obj1) {
22191 {
22192 arg2 = (int)(SWIG_As_int(obj1));
22193 if (SWIG_arg_fail(2)) SWIG_fail;
22194 }
22195 }
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22199
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj;
22212 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22213 PyObject * obj0 = 0 ;
22214 char *kwnames[] = {
22215 (char *) "self", NULL
22216 };
22217
22218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22220 if (SWIG_arg_fail(1)) SWIG_fail;
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 delete arg1;
22224
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 Py_INCREF(Py_None); resultobj = Py_None;
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22236 PyObject *resultobj;
22237 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22238 PyObject *arg2 = (PyObject *) 0 ;
22239 PyObject * obj0 = 0 ;
22240 PyObject * obj1 = 0 ;
22241 char *kwnames[] = {
22242 (char *) "self",(char *) "self", NULL
22243 };
22244
22245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22247 if (SWIG_arg_fail(1)) SWIG_fail;
22248 arg2 = obj1;
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 (arg1)->SetSelf(arg2);
22252
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 Py_INCREF(Py_None); resultobj = Py_None;
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22266 PyObject *result;
22267 PyObject * obj0 = 0 ;
22268 char *kwnames[] = {
22269 (char *) "self", NULL
22270 };
22271
22272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22274 if (SWIG_arg_fail(1)) SWIG_fail;
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 result = (PyObject *)(arg1)->GetSelf();
22278
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = result;
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22290 PyObject *obj;
22291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22292 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22293 Py_INCREF(obj);
22294 return Py_BuildValue((char *)"");
22295 }
22296 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22297 PyObject *resultobj;
22298 wxWindow *arg1 = (wxWindow *) 0 ;
22299 wxDateTime *arg2 = 0 ;
22300 wxEventType arg3 ;
22301 wxDateEvent *result;
22302 PyObject * obj0 = 0 ;
22303 PyObject * obj1 = 0 ;
22304 PyObject * obj2 = 0 ;
22305 char *kwnames[] = {
22306 (char *) "win",(char *) "dt",(char *) "type", NULL
22307 };
22308
22309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22311 if (SWIG_arg_fail(1)) SWIG_fail;
22312 {
22313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(2)) SWIG_fail;
22315 if (arg2 == NULL) {
22316 SWIG_null_ref("wxDateTime");
22317 }
22318 if (SWIG_arg_fail(2)) SWIG_fail;
22319 }
22320 {
22321 arg3 = (wxEventType)(SWIG_As_int(obj2));
22322 if (SWIG_arg_fail(3)) SWIG_fail;
22323 }
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22327
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj;
22340 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22341 wxDateTime *result;
22342 PyObject * obj0 = 0 ;
22343 char *kwnames[] = {
22344 (char *) "self", NULL
22345 };
22346
22347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22349 if (SWIG_arg_fail(1)) SWIG_fail;
22350 {
22351 PyThreadState* __tstate = wxPyBeginAllowThreads();
22352 {
22353 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22354 result = (wxDateTime *) &_result_ref;
22355 }
22356
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22368 PyObject *resultobj;
22369 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22370 wxDateTime *arg2 = 0 ;
22371 PyObject * obj0 = 0 ;
22372 PyObject * obj1 = 0 ;
22373 char *kwnames[] = {
22374 (char *) "self",(char *) "date", NULL
22375 };
22376
22377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22379 if (SWIG_arg_fail(1)) SWIG_fail;
22380 {
22381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22382 if (SWIG_arg_fail(2)) SWIG_fail;
22383 if (arg2 == NULL) {
22384 SWIG_null_ref("wxDateTime");
22385 }
22386 if (SWIG_arg_fail(2)) SWIG_fail;
22387 }
22388 {
22389 PyThreadState* __tstate = wxPyBeginAllowThreads();
22390 (arg1)->SetDate((wxDateTime const &)*arg2);
22391
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 Py_INCREF(Py_None); resultobj = Py_None;
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22403 PyObject *obj;
22404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22405 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22406 Py_INCREF(obj);
22407 return Py_BuildValue((char *)"");
22408 }
22409 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22410 PyObject *resultobj;
22411 wxPyApp *result;
22412 char *kwnames[] = {
22413 NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = (wxPyApp *)new_wxPyApp();
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj;
22433 wxPyApp *arg1 = (wxPyApp *) 0 ;
22434 PyObject * obj0 = 0 ;
22435 char *kwnames[] = {
22436 (char *) "self", NULL
22437 };
22438
22439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22441 if (SWIG_arg_fail(1)) SWIG_fail;
22442 {
22443 PyThreadState* __tstate = wxPyBeginAllowThreads();
22444 delete arg1;
22445
22446 wxPyEndAllowThreads(__tstate);
22447 if (PyErr_Occurred()) SWIG_fail;
22448 }
22449 Py_INCREF(Py_None); resultobj = Py_None;
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22457 PyObject *resultobj;
22458 wxPyApp *arg1 = (wxPyApp *) 0 ;
22459 PyObject *arg2 = (PyObject *) 0 ;
22460 PyObject *arg3 = (PyObject *) 0 ;
22461 PyObject * obj0 = 0 ;
22462 PyObject * obj1 = 0 ;
22463 PyObject * obj2 = 0 ;
22464 char *kwnames[] = {
22465 (char *) "self",(char *) "self",(char *) "_class", NULL
22466 };
22467
22468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22470 if (SWIG_arg_fail(1)) SWIG_fail;
22471 arg2 = obj1;
22472 arg3 = obj2;
22473 {
22474 PyThreadState* __tstate = wxPyBeginAllowThreads();
22475 (arg1)->_setCallbackInfo(arg2,arg3);
22476
22477 wxPyEndAllowThreads(__tstate);
22478 if (PyErr_Occurred()) SWIG_fail;
22479 }
22480 Py_INCREF(Py_None); resultobj = Py_None;
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22488 PyObject *resultobj;
22489 wxPyApp *arg1 = (wxPyApp *) 0 ;
22490 wxString result;
22491 PyObject * obj0 = 0 ;
22492 char *kwnames[] = {
22493 (char *) "self", NULL
22494 };
22495
22496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22498 if (SWIG_arg_fail(1)) SWIG_fail;
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 result = ((wxPyApp const *)arg1)->GetAppName();
22502
22503 wxPyEndAllowThreads(__tstate);
22504 if (PyErr_Occurred()) SWIG_fail;
22505 }
22506 {
22507 #if wxUSE_UNICODE
22508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22509 #else
22510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22511 #endif
22512 }
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22520 PyObject *resultobj;
22521 wxPyApp *arg1 = (wxPyApp *) 0 ;
22522 wxString *arg2 = 0 ;
22523 bool temp2 = false ;
22524 PyObject * obj0 = 0 ;
22525 PyObject * obj1 = 0 ;
22526 char *kwnames[] = {
22527 (char *) "self",(char *) "name", NULL
22528 };
22529
22530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22532 if (SWIG_arg_fail(1)) SWIG_fail;
22533 {
22534 arg2 = wxString_in_helper(obj1);
22535 if (arg2 == NULL) SWIG_fail;
22536 temp2 = true;
22537 }
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 (arg1)->SetAppName((wxString const &)*arg2);
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 Py_INCREF(Py_None); resultobj = Py_None;
22546 {
22547 if (temp2)
22548 delete arg2;
22549 }
22550 return resultobj;
22551 fail:
22552 {
22553 if (temp2)
22554 delete arg2;
22555 }
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 wxString result;
22564 PyObject * obj0 = 0 ;
22565 char *kwnames[] = {
22566 (char *) "self", NULL
22567 };
22568
22569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22571 if (SWIG_arg_fail(1)) SWIG_fail;
22572 {
22573 PyThreadState* __tstate = wxPyBeginAllowThreads();
22574 result = ((wxPyApp const *)arg1)->GetClassName();
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 {
22580 #if wxUSE_UNICODE
22581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22582 #else
22583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22584 #endif
22585 }
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22593 PyObject *resultobj;
22594 wxPyApp *arg1 = (wxPyApp *) 0 ;
22595 wxString *arg2 = 0 ;
22596 bool temp2 = false ;
22597 PyObject * obj0 = 0 ;
22598 PyObject * obj1 = 0 ;
22599 char *kwnames[] = {
22600 (char *) "self",(char *) "name", NULL
22601 };
22602
22603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(1)) SWIG_fail;
22606 {
22607 arg2 = wxString_in_helper(obj1);
22608 if (arg2 == NULL) SWIG_fail;
22609 temp2 = true;
22610 }
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 (arg1)->SetClassName((wxString const &)*arg2);
22614
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 Py_INCREF(Py_None); resultobj = Py_None;
22619 {
22620 if (temp2)
22621 delete arg2;
22622 }
22623 return resultobj;
22624 fail:
22625 {
22626 if (temp2)
22627 delete arg2;
22628 }
22629 return NULL;
22630 }
22631
22632
22633 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj;
22635 wxPyApp *arg1 = (wxPyApp *) 0 ;
22636 wxString *result;
22637 PyObject * obj0 = 0 ;
22638 char *kwnames[] = {
22639 (char *) "self", NULL
22640 };
22641
22642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22644 if (SWIG_arg_fail(1)) SWIG_fail;
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 {
22648 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22649 result = (wxString *) &_result_ref;
22650 }
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 {
22656 #if wxUSE_UNICODE
22657 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22658 #else
22659 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22660 #endif
22661 }
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj;
22670 wxPyApp *arg1 = (wxPyApp *) 0 ;
22671 wxString *arg2 = 0 ;
22672 bool temp2 = false ;
22673 PyObject * obj0 = 0 ;
22674 PyObject * obj1 = 0 ;
22675 char *kwnames[] = {
22676 (char *) "self",(char *) "name", NULL
22677 };
22678
22679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22681 if (SWIG_arg_fail(1)) SWIG_fail;
22682 {
22683 arg2 = wxString_in_helper(obj1);
22684 if (arg2 == NULL) SWIG_fail;
22685 temp2 = true;
22686 }
22687 {
22688 PyThreadState* __tstate = wxPyBeginAllowThreads();
22689 (arg1)->SetVendorName((wxString const &)*arg2);
22690
22691 wxPyEndAllowThreads(__tstate);
22692 if (PyErr_Occurred()) SWIG_fail;
22693 }
22694 Py_INCREF(Py_None); resultobj = Py_None;
22695 {
22696 if (temp2)
22697 delete arg2;
22698 }
22699 return resultobj;
22700 fail:
22701 {
22702 if (temp2)
22703 delete arg2;
22704 }
22705 return NULL;
22706 }
22707
22708
22709 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22710 PyObject *resultobj;
22711 wxPyApp *arg1 = (wxPyApp *) 0 ;
22712 wxAppTraits *result;
22713 PyObject * obj0 = 0 ;
22714 char *kwnames[] = {
22715 (char *) "self", NULL
22716 };
22717
22718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22720 if (SWIG_arg_fail(1)) SWIG_fail;
22721 {
22722 PyThreadState* __tstate = wxPyBeginAllowThreads();
22723 result = (wxAppTraits *)(arg1)->GetTraits();
22724
22725 wxPyEndAllowThreads(__tstate);
22726 if (PyErr_Occurred()) SWIG_fail;
22727 }
22728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj;
22737 wxPyApp *arg1 = (wxPyApp *) 0 ;
22738 PyObject * obj0 = 0 ;
22739 char *kwnames[] = {
22740 (char *) "self", NULL
22741 };
22742
22743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22745 if (SWIG_arg_fail(1)) SWIG_fail;
22746 {
22747 PyThreadState* __tstate = wxPyBeginAllowThreads();
22748 (arg1)->ProcessPendingEvents();
22749
22750 wxPyEndAllowThreads(__tstate);
22751 if (PyErr_Occurred()) SWIG_fail;
22752 }
22753 Py_INCREF(Py_None); resultobj = Py_None;
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj;
22762 wxPyApp *arg1 = (wxPyApp *) 0 ;
22763 bool arg2 = (bool) false ;
22764 bool result;
22765 PyObject * obj0 = 0 ;
22766 PyObject * obj1 = 0 ;
22767 char *kwnames[] = {
22768 (char *) "self",(char *) "onlyIfNeeded", NULL
22769 };
22770
22771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22773 if (SWIG_arg_fail(1)) SWIG_fail;
22774 if (obj1) {
22775 {
22776 arg2 = (bool)(SWIG_As_bool(obj1));
22777 if (SWIG_arg_fail(2)) SWIG_fail;
22778 }
22779 }
22780 {
22781 PyThreadState* __tstate = wxPyBeginAllowThreads();
22782 result = (bool)(arg1)->Yield(arg2);
22783
22784 wxPyEndAllowThreads(__tstate);
22785 if (PyErr_Occurred()) SWIG_fail;
22786 }
22787 {
22788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22789 }
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj;
22798 wxPyApp *arg1 = (wxPyApp *) 0 ;
22799 PyObject * obj0 = 0 ;
22800 char *kwnames[] = {
22801 (char *) "self", NULL
22802 };
22803
22804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22806 if (SWIG_arg_fail(1)) SWIG_fail;
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 (arg1)->WakeUpIdle();
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 Py_INCREF(Py_None); resultobj = Py_None;
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj;
22823 bool result;
22824 char *kwnames[] = {
22825 NULL
22826 };
22827
22828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22829 {
22830 PyThreadState* __tstate = wxPyBeginAllowThreads();
22831 result = (bool)wxPyApp::IsMainLoopRunning();
22832
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 {
22837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22838 }
22839 return resultobj;
22840 fail:
22841 return NULL;
22842 }
22843
22844
22845 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22846 PyObject *resultobj;
22847 wxPyApp *arg1 = (wxPyApp *) 0 ;
22848 int result;
22849 PyObject * obj0 = 0 ;
22850 char *kwnames[] = {
22851 (char *) "self", NULL
22852 };
22853
22854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22856 if (SWIG_arg_fail(1)) SWIG_fail;
22857 {
22858 PyThreadState* __tstate = wxPyBeginAllowThreads();
22859 result = (int)(arg1)->MainLoop();
22860
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 {
22865 resultobj = SWIG_From_int((int)(result));
22866 }
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22874 PyObject *resultobj;
22875 wxPyApp *arg1 = (wxPyApp *) 0 ;
22876 PyObject * obj0 = 0 ;
22877 char *kwnames[] = {
22878 (char *) "self", NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(1)) SWIG_fail;
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 (arg1)->Exit();
22887
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 Py_INCREF(Py_None); resultobj = Py_None;
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj;
22900 wxPyApp *arg1 = (wxPyApp *) 0 ;
22901 PyObject * obj0 = 0 ;
22902 char *kwnames[] = {
22903 (char *) "self", NULL
22904 };
22905
22906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 PyThreadState* __tstate = wxPyBeginAllowThreads();
22911 (arg1)->ExitMainLoop();
22912
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 Py_INCREF(Py_None); resultobj = Py_None;
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22924 PyObject *resultobj;
22925 wxPyApp *arg1 = (wxPyApp *) 0 ;
22926 bool result;
22927 PyObject * obj0 = 0 ;
22928 char *kwnames[] = {
22929 (char *) "self", NULL
22930 };
22931
22932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22934 if (SWIG_arg_fail(1)) SWIG_fail;
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (bool)(arg1)->Pending();
22938
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22944 }
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22952 PyObject *resultobj;
22953 wxPyApp *arg1 = (wxPyApp *) 0 ;
22954 bool result;
22955 PyObject * obj0 = 0 ;
22956 char *kwnames[] = {
22957 (char *) "self", NULL
22958 };
22959
22960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22962 if (SWIG_arg_fail(1)) SWIG_fail;
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 result = (bool)(arg1)->Dispatch();
22966
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 {
22971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22972 }
22973 return resultobj;
22974 fail:
22975 return NULL;
22976 }
22977
22978
22979 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj;
22981 wxPyApp *arg1 = (wxPyApp *) 0 ;
22982 bool result;
22983 PyObject * obj0 = 0 ;
22984 char *kwnames[] = {
22985 (char *) "self", NULL
22986 };
22987
22988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22990 if (SWIG_arg_fail(1)) SWIG_fail;
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 result = (bool)(arg1)->ProcessIdle();
22994
22995 wxPyEndAllowThreads(__tstate);
22996 if (PyErr_Occurred()) SWIG_fail;
22997 }
22998 {
22999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23000 }
23001 return resultobj;
23002 fail:
23003 return NULL;
23004 }
23005
23006
23007 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23008 PyObject *resultobj;
23009 wxPyApp *arg1 = (wxPyApp *) 0 ;
23010 wxWindow *arg2 = (wxWindow *) 0 ;
23011 wxIdleEvent *arg3 = 0 ;
23012 bool result;
23013 PyObject * obj0 = 0 ;
23014 PyObject * obj1 = 0 ;
23015 PyObject * obj2 = 0 ;
23016 char *kwnames[] = {
23017 (char *) "self",(char *) "win",(char *) "event", NULL
23018 };
23019
23020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23022 if (SWIG_arg_fail(1)) SWIG_fail;
23023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(2)) SWIG_fail;
23025 {
23026 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23027 if (SWIG_arg_fail(3)) SWIG_fail;
23028 if (arg3 == NULL) {
23029 SWIG_null_ref("wxIdleEvent");
23030 }
23031 if (SWIG_arg_fail(3)) SWIG_fail;
23032 }
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23036
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 {
23041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23050 PyObject *resultobj;
23051 wxPyApp *arg1 = (wxPyApp *) 0 ;
23052 bool result;
23053 PyObject * obj0 = 0 ;
23054 char *kwnames[] = {
23055 (char *) "self", NULL
23056 };
23057
23058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23060 if (SWIG_arg_fail(1)) SWIG_fail;
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = (bool)((wxPyApp const *)arg1)->IsActive();
23064
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 {
23069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23070 }
23071 return resultobj;
23072 fail:
23073 return NULL;
23074 }
23075
23076
23077 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23078 PyObject *resultobj;
23079 wxPyApp *arg1 = (wxPyApp *) 0 ;
23080 wxWindow *arg2 = (wxWindow *) 0 ;
23081 PyObject * obj0 = 0 ;
23082 PyObject * obj1 = 0 ;
23083 char *kwnames[] = {
23084 (char *) "self",(char *) "win", NULL
23085 };
23086
23087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(1)) SWIG_fail;
23090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(2)) SWIG_fail;
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 (arg1)->SetTopWindow(arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 Py_INCREF(Py_None); resultobj = Py_None;
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj;
23108 wxPyApp *arg1 = (wxPyApp *) 0 ;
23109 wxWindow *result;
23110 PyObject * obj0 = 0 ;
23111 char *kwnames[] = {
23112 (char *) "self", NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(1)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = wxPyMake_wxObject(result, 0);
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj;
23136 wxPyApp *arg1 = (wxPyApp *) 0 ;
23137 bool arg2 ;
23138 PyObject * obj0 = 0 ;
23139 PyObject * obj1 = 0 ;
23140 char *kwnames[] = {
23141 (char *) "self",(char *) "flag", NULL
23142 };
23143
23144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23146 if (SWIG_arg_fail(1)) SWIG_fail;
23147 {
23148 arg2 = (bool)(SWIG_As_bool(obj1));
23149 if (SWIG_arg_fail(2)) SWIG_fail;
23150 }
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 (arg1)->SetExitOnFrameDelete(arg2);
23154
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 Py_INCREF(Py_None); resultobj = Py_None;
23159 return resultobj;
23160 fail:
23161 return NULL;
23162 }
23163
23164
23165 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23166 PyObject *resultobj;
23167 wxPyApp *arg1 = (wxPyApp *) 0 ;
23168 bool result;
23169 PyObject * obj0 = 0 ;
23170 char *kwnames[] = {
23171 (char *) "self", NULL
23172 };
23173
23174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23176 if (SWIG_arg_fail(1)) SWIG_fail;
23177 {
23178 PyThreadState* __tstate = wxPyBeginAllowThreads();
23179 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23180
23181 wxPyEndAllowThreads(__tstate);
23182 if (PyErr_Occurred()) SWIG_fail;
23183 }
23184 {
23185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23186 }
23187 return resultobj;
23188 fail:
23189 return NULL;
23190 }
23191
23192
23193 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23194 PyObject *resultobj;
23195 wxPyApp *arg1 = (wxPyApp *) 0 ;
23196 bool arg2 ;
23197 PyObject * obj0 = 0 ;
23198 PyObject * obj1 = 0 ;
23199 char *kwnames[] = {
23200 (char *) "self",(char *) "flag", NULL
23201 };
23202
23203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23205 if (SWIG_arg_fail(1)) SWIG_fail;
23206 {
23207 arg2 = (bool)(SWIG_As_bool(obj1));
23208 if (SWIG_arg_fail(2)) SWIG_fail;
23209 }
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 (arg1)->SetUseBestVisual(arg2);
23213
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 Py_INCREF(Py_None); resultobj = Py_None;
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23225 PyObject *resultobj;
23226 wxPyApp *arg1 = (wxPyApp *) 0 ;
23227 bool result;
23228 PyObject * obj0 = 0 ;
23229 char *kwnames[] = {
23230 (char *) "self", NULL
23231 };
23232
23233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23235 if (SWIG_arg_fail(1)) SWIG_fail;
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23239
23240 wxPyEndAllowThreads(__tstate);
23241 if (PyErr_Occurred()) SWIG_fail;
23242 }
23243 {
23244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23245 }
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23253 PyObject *resultobj;
23254 wxPyApp *arg1 = (wxPyApp *) 0 ;
23255 int arg2 ;
23256 PyObject * obj0 = 0 ;
23257 PyObject * obj1 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "self",(char *) "mode", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(1)) SWIG_fail;
23265 {
23266 arg2 = (int)(SWIG_As_int(obj1));
23267 if (SWIG_arg_fail(2)) SWIG_fail;
23268 }
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 (arg1)->SetPrintMode(arg2);
23272
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 Py_INCREF(Py_None); resultobj = Py_None;
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj;
23285 wxPyApp *arg1 = (wxPyApp *) 0 ;
23286 int result;
23287 PyObject * obj0 = 0 ;
23288 char *kwnames[] = {
23289 (char *) "self", NULL
23290 };
23291
23292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(1)) SWIG_fail;
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23298
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 {
23303 resultobj = SWIG_From_int((int)(result));
23304 }
23305 return resultobj;
23306 fail:
23307 return NULL;
23308 }
23309
23310
23311 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23312 PyObject *resultobj;
23313 wxPyApp *arg1 = (wxPyApp *) 0 ;
23314 int arg2 ;
23315 PyObject * obj0 = 0 ;
23316 PyObject * obj1 = 0 ;
23317 char *kwnames[] = {
23318 (char *) "self",(char *) "mode", NULL
23319 };
23320
23321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23323 if (SWIG_arg_fail(1)) SWIG_fail;
23324 {
23325 arg2 = (int)(SWIG_As_int(obj1));
23326 if (SWIG_arg_fail(2)) SWIG_fail;
23327 }
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 (arg1)->SetAssertMode(arg2);
23331
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 Py_INCREF(Py_None); resultobj = Py_None;
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23343 PyObject *resultobj;
23344 wxPyApp *arg1 = (wxPyApp *) 0 ;
23345 int result;
23346 PyObject * obj0 = 0 ;
23347 char *kwnames[] = {
23348 (char *) "self", NULL
23349 };
23350
23351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23353 if (SWIG_arg_fail(1)) SWIG_fail;
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = (int)(arg1)->GetAssertMode();
23357
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 {
23362 resultobj = SWIG_From_int((int)(result));
23363 }
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj;
23372 bool result;
23373 char *kwnames[] = {
23374 NULL
23375 };
23376
23377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23378 {
23379 PyThreadState* __tstate = wxPyBeginAllowThreads();
23380 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23381
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 {
23386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23387 }
23388 return resultobj;
23389 fail:
23390 return NULL;
23391 }
23392
23393
23394 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23395 PyObject *resultobj;
23396 long result;
23397 char *kwnames[] = {
23398 NULL
23399 };
23400
23401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23402 {
23403 PyThreadState* __tstate = wxPyBeginAllowThreads();
23404 result = (long)wxPyApp::GetMacAboutMenuItemId();
23405
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 {
23410 resultobj = SWIG_From_long((long)(result));
23411 }
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23419 PyObject *resultobj;
23420 long result;
23421 char *kwnames[] = {
23422 NULL
23423 };
23424
23425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23429
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 {
23434 resultobj = SWIG_From_long((long)(result));
23435 }
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 long result;
23445 char *kwnames[] = {
23446 NULL
23447 };
23448
23449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 result = (long)wxPyApp::GetMacExitMenuItemId();
23453
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 {
23458 resultobj = SWIG_From_long((long)(result));
23459 }
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj;
23468 wxString result;
23469 char *kwnames[] = {
23470 NULL
23471 };
23472
23473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23474 {
23475 PyThreadState* __tstate = wxPyBeginAllowThreads();
23476 result = wxPyApp::GetMacHelpMenuTitleName();
23477
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 {
23482 #if wxUSE_UNICODE
23483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23484 #else
23485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23486 #endif
23487 }
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23495 PyObject *resultobj;
23496 bool arg1 ;
23497 PyObject * obj0 = 0 ;
23498 char *kwnames[] = {
23499 (char *) "val", NULL
23500 };
23501
23502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23503 {
23504 arg1 = (bool)(SWIG_As_bool(obj0));
23505 if (SWIG_arg_fail(1)) SWIG_fail;
23506 }
23507 {
23508 PyThreadState* __tstate = wxPyBeginAllowThreads();
23509 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23510
23511 wxPyEndAllowThreads(__tstate);
23512 if (PyErr_Occurred()) SWIG_fail;
23513 }
23514 Py_INCREF(Py_None); resultobj = Py_None;
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23522 PyObject *resultobj;
23523 long arg1 ;
23524 PyObject * obj0 = 0 ;
23525 char *kwnames[] = {
23526 (char *) "val", NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23530 {
23531 arg1 = (long)(SWIG_As_long(obj0));
23532 if (SWIG_arg_fail(1)) SWIG_fail;
23533 }
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 wxPyApp::SetMacAboutMenuItemId(arg1);
23537
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 Py_INCREF(Py_None); resultobj = Py_None;
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 long arg1 ;
23551 PyObject * obj0 = 0 ;
23552 char *kwnames[] = {
23553 (char *) "val", NULL
23554 };
23555
23556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23557 {
23558 arg1 = (long)(SWIG_As_long(obj0));
23559 if (SWIG_arg_fail(1)) SWIG_fail;
23560 }
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23564
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 Py_INCREF(Py_None); resultobj = Py_None;
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj;
23577 long arg1 ;
23578 PyObject * obj0 = 0 ;
23579 char *kwnames[] = {
23580 (char *) "val", NULL
23581 };
23582
23583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23584 {
23585 arg1 = (long)(SWIG_As_long(obj0));
23586 if (SWIG_arg_fail(1)) SWIG_fail;
23587 }
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 wxPyApp::SetMacExitMenuItemId(arg1);
23591
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 Py_INCREF(Py_None); resultobj = Py_None;
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj;
23604 wxString *arg1 = 0 ;
23605 bool temp1 = false ;
23606 PyObject * obj0 = 0 ;
23607 char *kwnames[] = {
23608 (char *) "val", NULL
23609 };
23610
23611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23612 {
23613 arg1 = wxString_in_helper(obj0);
23614 if (arg1 == NULL) SWIG_fail;
23615 temp1 = true;
23616 }
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23620
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 Py_INCREF(Py_None); resultobj = Py_None;
23625 {
23626 if (temp1)
23627 delete arg1;
23628 }
23629 return resultobj;
23630 fail:
23631 {
23632 if (temp1)
23633 delete arg1;
23634 }
23635 return NULL;
23636 }
23637
23638
23639 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23640 PyObject *resultobj;
23641 wxPyApp *arg1 = (wxPyApp *) 0 ;
23642 PyObject * obj0 = 0 ;
23643 char *kwnames[] = {
23644 (char *) "self", NULL
23645 };
23646
23647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23649 if (SWIG_arg_fail(1)) SWIG_fail;
23650 {
23651 PyThreadState* __tstate = wxPyBeginAllowThreads();
23652 (arg1)->_BootstrapApp();
23653
23654 wxPyEndAllowThreads(__tstate);
23655 if (PyErr_Occurred()) SWIG_fail;
23656 }
23657 Py_INCREF(Py_None); resultobj = Py_None;
23658 return resultobj;
23659 fail:
23660 return NULL;
23661 }
23662
23663
23664 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23665 PyObject *resultobj;
23666 int result;
23667 char *kwnames[] = {
23668 NULL
23669 };
23670
23671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (int)wxPyApp::GetComCtl32Version();
23675
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 {
23680 resultobj = SWIG_From_int((int)(result));
23681 }
23682 return resultobj;
23683 fail:
23684 return NULL;
23685 }
23686
23687
23688 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23689 PyObject *obj;
23690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23691 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23692 Py_INCREF(obj);
23693 return Py_BuildValue((char *)"");
23694 }
23695 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj;
23697 char *kwnames[] = {
23698 NULL
23699 };
23700
23701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23702 {
23703 PyThreadState* __tstate = wxPyBeginAllowThreads();
23704 wxExit();
23705
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 Py_INCREF(Py_None); resultobj = Py_None;
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23717 PyObject *resultobj;
23718 bool result;
23719 char *kwnames[] = {
23720 NULL
23721 };
23722
23723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 result = (bool)wxYield();
23727
23728 wxPyEndAllowThreads(__tstate);
23729 if (PyErr_Occurred()) SWIG_fail;
23730 }
23731 {
23732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23733 }
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 bool result;
23743 char *kwnames[] = {
23744 NULL
23745 };
23746
23747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = (bool)wxYieldIfNeeded();
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 {
23756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23757 }
23758 return resultobj;
23759 fail:
23760 return NULL;
23761 }
23762
23763
23764 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23765 PyObject *resultobj;
23766 wxWindow *arg1 = (wxWindow *) NULL ;
23767 bool arg2 = (bool) false ;
23768 bool result;
23769 PyObject * obj0 = 0 ;
23770 PyObject * obj1 = 0 ;
23771 char *kwnames[] = {
23772 (char *) "win",(char *) "onlyIfNeeded", NULL
23773 };
23774
23775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23776 if (obj0) {
23777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23778 if (SWIG_arg_fail(1)) SWIG_fail;
23779 }
23780 if (obj1) {
23781 {
23782 arg2 = (bool)(SWIG_As_bool(obj1));
23783 if (SWIG_arg_fail(2)) SWIG_fail;
23784 }
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (bool)wxSafeYield(arg1,arg2);
23789
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 {
23794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23795 }
23796 return resultobj;
23797 fail:
23798 return NULL;
23799 }
23800
23801
23802 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23803 PyObject *resultobj;
23804 char *kwnames[] = {
23805 NULL
23806 };
23807
23808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 wxWakeUpIdle();
23812
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 Py_INCREF(Py_None); resultobj = Py_None;
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23826 wxEvent *arg2 = 0 ;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 char *kwnames[] = {
23830 (char *) "dest",(char *) "event", NULL
23831 };
23832
23833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23835 if (SWIG_arg_fail(1)) SWIG_fail;
23836 {
23837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23838 if (SWIG_arg_fail(2)) SWIG_fail;
23839 if (arg2 == NULL) {
23840 SWIG_null_ref("wxEvent");
23841 }
23842 if (SWIG_arg_fail(2)) SWIG_fail;
23843 }
23844 {
23845 PyThreadState* __tstate = wxPyBeginAllowThreads();
23846 wxPostEvent(arg1,*arg2);
23847
23848 wxPyEndAllowThreads(__tstate);
23849 if (PyErr_Occurred()) SWIG_fail;
23850 }
23851 Py_INCREF(Py_None); resultobj = Py_None;
23852 return resultobj;
23853 fail:
23854 return NULL;
23855 }
23856
23857
23858 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23859 PyObject *resultobj;
23860 char *kwnames[] = {
23861 NULL
23862 };
23863
23864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 wxApp_CleanUp();
23868
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 Py_INCREF(Py_None); resultobj = Py_None;
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj;
23881 wxPyApp *result;
23882 char *kwnames[] = {
23883 NULL
23884 };
23885
23886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 result = (wxPyApp *)wxPyGetApp();
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 {
23895 resultobj = wxPyMake_wxObject(result, 0);
23896 }
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23904 PyObject *resultobj;
23905 char *arg1 = (char *) 0 ;
23906 PyObject * obj0 = 0 ;
23907 char *kwnames[] = {
23908 (char *) "encoding", NULL
23909 };
23910
23911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23912 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23913 SWIG_arg_fail(1);SWIG_fail;
23914 }
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 wxSetDefaultPyEncoding((char const *)arg1);
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 Py_INCREF(Py_None); resultobj = Py_None;
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 char *result;
23932 char *kwnames[] = {
23933 NULL
23934 };
23935
23936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (char *)wxGetDefaultPyEncoding();
23940
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_FromCharPtr(result);
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj;
23953 wxEventLoop *result;
23954 char *kwnames[] = {
23955 NULL
23956 };
23957
23958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (wxEventLoop *)new wxEventLoop();
23962
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23976 PyObject * obj0 = 0 ;
23977 char *kwnames[] = {
23978 (char *) "self", NULL
23979 };
23980
23981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23983 if (SWIG_arg_fail(1)) SWIG_fail;
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 delete arg1;
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 Py_INCREF(Py_None); resultobj = Py_None;
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj;
24000 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24001 int result;
24002 PyObject * obj0 = 0 ;
24003 char *kwnames[] = {
24004 (char *) "self", NULL
24005 };
24006
24007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24009 if (SWIG_arg_fail(1)) SWIG_fail;
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (int)(arg1)->Run();
24013
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 {
24018 resultobj = SWIG_From_int((int)(result));
24019 }
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24029 int arg2 = (int) 0 ;
24030 PyObject * obj0 = 0 ;
24031 PyObject * obj1 = 0 ;
24032 char *kwnames[] = {
24033 (char *) "self",(char *) "rc", NULL
24034 };
24035
24036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24038 if (SWIG_arg_fail(1)) SWIG_fail;
24039 if (obj1) {
24040 {
24041 arg2 = (int)(SWIG_As_int(obj1));
24042 if (SWIG_arg_fail(2)) SWIG_fail;
24043 }
24044 }
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 (arg1)->Exit(arg2);
24048
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 Py_INCREF(Py_None); resultobj = Py_None;
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24060 PyObject *resultobj;
24061 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24062 bool result;
24063 PyObject * obj0 = 0 ;
24064 char *kwnames[] = {
24065 (char *) "self", NULL
24066 };
24067
24068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24070 if (SWIG_arg_fail(1)) SWIG_fail;
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = (bool)((wxEventLoop const *)arg1)->Pending();
24074
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 {
24079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24080 }
24081 return resultobj;
24082 fail:
24083 return NULL;
24084 }
24085
24086
24087 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24088 PyObject *resultobj;
24089 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24090 bool result;
24091 PyObject * obj0 = 0 ;
24092 char *kwnames[] = {
24093 (char *) "self", NULL
24094 };
24095
24096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24098 if (SWIG_arg_fail(1)) SWIG_fail;
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (bool)(arg1)->Dispatch();
24102
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 {
24107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24116 PyObject *resultobj;
24117 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24118 bool result;
24119 PyObject * obj0 = 0 ;
24120 char *kwnames[] = {
24121 (char *) "self", NULL
24122 };
24123
24124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24126 if (SWIG_arg_fail(1)) SWIG_fail;
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24130
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj;
24145 wxEventLoop *result;
24146 char *kwnames[] = {
24147 NULL
24148 };
24149
24150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24151 {
24152 PyThreadState* __tstate = wxPyBeginAllowThreads();
24153 result = (wxEventLoop *)wxEventLoop::GetActive();
24154
24155 wxPyEndAllowThreads(__tstate);
24156 if (PyErr_Occurred()) SWIG_fail;
24157 }
24158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24159 return resultobj;
24160 fail:
24161 return NULL;
24162 }
24163
24164
24165 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj;
24167 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24168 PyObject * obj0 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "loop", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 {
24177 PyThreadState* __tstate = wxPyBeginAllowThreads();
24178 wxEventLoop::SetActive(arg1);
24179
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 Py_INCREF(Py_None); resultobj = Py_None;
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24191 PyObject *obj;
24192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24193 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24194 Py_INCREF(obj);
24195 return Py_BuildValue((char *)"");
24196 }
24197 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj;
24199 int arg1 = (int) 0 ;
24200 int arg2 = (int) 0 ;
24201 int arg3 = (int) 0 ;
24202 wxAcceleratorEntry *result;
24203 PyObject * obj0 = 0 ;
24204 PyObject * obj1 = 0 ;
24205 PyObject * obj2 = 0 ;
24206 char *kwnames[] = {
24207 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24211 if (obj0) {
24212 {
24213 arg1 = (int)(SWIG_As_int(obj0));
24214 if (SWIG_arg_fail(1)) SWIG_fail;
24215 }
24216 }
24217 if (obj1) {
24218 {
24219 arg2 = (int)(SWIG_As_int(obj1));
24220 if (SWIG_arg_fail(2)) SWIG_fail;
24221 }
24222 }
24223 if (obj2) {
24224 {
24225 arg3 = (int)(SWIG_As_int(obj2));
24226 if (SWIG_arg_fail(3)) SWIG_fail;
24227 }
24228 }
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24232
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj;
24245 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24246 PyObject * obj0 = 0 ;
24247 char *kwnames[] = {
24248 (char *) "self", NULL
24249 };
24250
24251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24253 if (SWIG_arg_fail(1)) SWIG_fail;
24254 {
24255 PyThreadState* __tstate = wxPyBeginAllowThreads();
24256 delete arg1;
24257
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 Py_INCREF(Py_None); resultobj = Py_None;
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24269 PyObject *resultobj;
24270 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24271 int arg2 ;
24272 int arg3 ;
24273 int arg4 ;
24274 PyObject * obj0 = 0 ;
24275 PyObject * obj1 = 0 ;
24276 PyObject * obj2 = 0 ;
24277 PyObject * obj3 = 0 ;
24278 char *kwnames[] = {
24279 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24280 };
24281
24282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24284 if (SWIG_arg_fail(1)) SWIG_fail;
24285 {
24286 arg2 = (int)(SWIG_As_int(obj1));
24287 if (SWIG_arg_fail(2)) SWIG_fail;
24288 }
24289 {
24290 arg3 = (int)(SWIG_As_int(obj2));
24291 if (SWIG_arg_fail(3)) SWIG_fail;
24292 }
24293 {
24294 arg4 = (int)(SWIG_As_int(obj3));
24295 if (SWIG_arg_fail(4)) SWIG_fail;
24296 }
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 (arg1)->Set(arg2,arg3,arg4);
24300
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 Py_INCREF(Py_None); resultobj = Py_None;
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj;
24313 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24314 int result;
24315 PyObject * obj0 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "self", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (int)(arg1)->GetFlags();
24326
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = SWIG_From_int((int)(result));
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj;
24341 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24342 int result;
24343 PyObject * obj0 = 0 ;
24344 char *kwnames[] = {
24345 (char *) "self", NULL
24346 };
24347
24348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24350 if (SWIG_arg_fail(1)) SWIG_fail;
24351 {
24352 PyThreadState* __tstate = wxPyBeginAllowThreads();
24353 result = (int)(arg1)->GetKeyCode();
24354
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 {
24359 resultobj = SWIG_From_int((int)(result));
24360 }
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj;
24369 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24370 int result;
24371 PyObject * obj0 = 0 ;
24372 char *kwnames[] = {
24373 (char *) "self", NULL
24374 };
24375
24376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24378 if (SWIG_arg_fail(1)) SWIG_fail;
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = (int)(arg1)->GetCommand();
24382
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 {
24387 resultobj = SWIG_From_int((int)(result));
24388 }
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24396 PyObject *obj;
24397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24398 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24399 Py_INCREF(obj);
24400 return Py_BuildValue((char *)"");
24401 }
24402 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 int arg1 ;
24405 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24406 wxAcceleratorTable *result;
24407 PyObject * obj0 = 0 ;
24408 char *kwnames[] = {
24409 (char *) "n", NULL
24410 };
24411
24412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24413 {
24414 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24415 if (arg2) arg1 = PyList_Size(obj0);
24416 else arg1 = 0;
24417 }
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24421
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24426 {
24427 delete [] arg2;
24428 }
24429 return resultobj;
24430 fail:
24431 {
24432 delete [] arg2;
24433 }
24434 return NULL;
24435 }
24436
24437
24438 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj;
24440 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24441 PyObject * obj0 = 0 ;
24442 char *kwnames[] = {
24443 (char *) "self", NULL
24444 };
24445
24446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24448 if (SWIG_arg_fail(1)) SWIG_fail;
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 delete arg1;
24452
24453 wxPyEndAllowThreads(__tstate);
24454 if (PyErr_Occurred()) SWIG_fail;
24455 }
24456 Py_INCREF(Py_None); resultobj = Py_None;
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj;
24465 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24466 bool result;
24467 PyObject * obj0 = 0 ;
24468 char *kwnames[] = {
24469 (char *) "self", NULL
24470 };
24471
24472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24474 if (SWIG_arg_fail(1)) SWIG_fail;
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24492 PyObject *obj;
24493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24494 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24495 Py_INCREF(obj);
24496 return Py_BuildValue((char *)"");
24497 }
24498 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24499 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24500 return 1;
24501 }
24502
24503
24504 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24505 PyObject *pyobj;
24506
24507 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24508 return pyobj;
24509 }
24510
24511
24512 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24513 PyObject *resultobj;
24514 wxString *arg1 = 0 ;
24515 wxAcceleratorEntry *result;
24516 bool temp1 = false ;
24517 PyObject * obj0 = 0 ;
24518 char *kwnames[] = {
24519 (char *) "label", NULL
24520 };
24521
24522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24523 {
24524 arg1 = wxString_in_helper(obj0);
24525 if (arg1 == NULL) SWIG_fail;
24526 temp1 = true;
24527 }
24528 {
24529 PyThreadState* __tstate = wxPyBeginAllowThreads();
24530 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24531
24532 wxPyEndAllowThreads(__tstate);
24533 if (PyErr_Occurred()) SWIG_fail;
24534 }
24535 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24536 {
24537 if (temp1)
24538 delete arg1;
24539 }
24540 return resultobj;
24541 fail:
24542 {
24543 if (temp1)
24544 delete arg1;
24545 }
24546 return NULL;
24547 }
24548
24549
24550 static int _wrap_PanelNameStr_set(PyObject *) {
24551 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24552 return 1;
24553 }
24554
24555
24556 static PyObject *_wrap_PanelNameStr_get(void) {
24557 PyObject *pyobj;
24558
24559 {
24560 #if wxUSE_UNICODE
24561 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24562 #else
24563 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24564 #endif
24565 }
24566 return pyobj;
24567 }
24568
24569
24570 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj;
24572 wxVisualAttributes *result;
24573 char *kwnames[] = {
24574 NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 result = (wxVisualAttributes *)new_wxVisualAttributes();
24581
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24593 PyObject *resultobj;
24594 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24595 PyObject * obj0 = 0 ;
24596 char *kwnames[] = {
24597 (char *) "self", NULL
24598 };
24599
24600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(1)) SWIG_fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 delete_wxVisualAttributes(arg1);
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 Py_INCREF(Py_None); resultobj = Py_None;
24611 return resultobj;
24612 fail:
24613 return NULL;
24614 }
24615
24616
24617 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24618 PyObject *resultobj;
24619 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24620 wxFont *arg2 = (wxFont *) 0 ;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char *kwnames[] = {
24624 (char *) "self",(char *) "font", NULL
24625 };
24626
24627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24629 if (SWIG_arg_fail(1)) SWIG_fail;
24630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24631 if (SWIG_arg_fail(2)) SWIG_fail;
24632 if (arg1) (arg1)->font = *arg2;
24633
24634 Py_INCREF(Py_None); resultobj = Py_None;
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj;
24643 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24644 wxFont *result;
24645 PyObject * obj0 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 result = (wxFont *)& ((arg1)->font);
24654
24655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj;
24664 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24665 wxColour *arg2 = (wxColour *) 0 ;
24666 PyObject * obj0 = 0 ;
24667 PyObject * obj1 = 0 ;
24668 char *kwnames[] = {
24669 (char *) "self",(char *) "colFg", NULL
24670 };
24671
24672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24674 if (SWIG_arg_fail(1)) SWIG_fail;
24675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24676 if (SWIG_arg_fail(2)) SWIG_fail;
24677 if (arg1) (arg1)->colFg = *arg2;
24678
24679 Py_INCREF(Py_None); resultobj = Py_None;
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24687 PyObject *resultobj;
24688 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24689 wxColour *result;
24690 PyObject * obj0 = 0 ;
24691 char *kwnames[] = {
24692 (char *) "self", NULL
24693 };
24694
24695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(1)) SWIG_fail;
24698 result = (wxColour *)& ((arg1)->colFg);
24699
24700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24708 PyObject *resultobj;
24709 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24710 wxColour *arg2 = (wxColour *) 0 ;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 char *kwnames[] = {
24714 (char *) "self",(char *) "colBg", NULL
24715 };
24716
24717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24719 if (SWIG_arg_fail(1)) SWIG_fail;
24720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24721 if (SWIG_arg_fail(2)) SWIG_fail;
24722 if (arg1) (arg1)->colBg = *arg2;
24723
24724 Py_INCREF(Py_None); resultobj = Py_None;
24725 return resultobj;
24726 fail:
24727 return NULL;
24728 }
24729
24730
24731 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj;
24733 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24734 wxColour *result;
24735 PyObject * obj0 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "self", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24742 if (SWIG_arg_fail(1)) SWIG_fail;
24743 result = (wxColour *)& ((arg1)->colBg);
24744
24745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24753 PyObject *obj;
24754 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24755 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24756 Py_INCREF(obj);
24757 return Py_BuildValue((char *)"");
24758 }
24759 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24760 PyObject *resultobj;
24761 wxWindow *arg1 = (wxWindow *) 0 ;
24762 int arg2 = (int) (int)-1 ;
24763 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24764 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24765 wxSize const &arg4_defvalue = wxDefaultSize ;
24766 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24767 long arg5 = (long) 0 ;
24768 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24769 wxString *arg6 = (wxString *) &arg6_defvalue ;
24770 wxWindow *result;
24771 wxPoint temp3 ;
24772 wxSize temp4 ;
24773 bool temp6 = false ;
24774 PyObject * obj0 = 0 ;
24775 PyObject * obj1 = 0 ;
24776 PyObject * obj2 = 0 ;
24777 PyObject * obj3 = 0 ;
24778 PyObject * obj4 = 0 ;
24779 PyObject * obj5 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 if (obj1) {
24788 {
24789 arg2 = (int const)(SWIG_As_int(obj1));
24790 if (SWIG_arg_fail(2)) SWIG_fail;
24791 }
24792 }
24793 if (obj2) {
24794 {
24795 arg3 = &temp3;
24796 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24797 }
24798 }
24799 if (obj3) {
24800 {
24801 arg4 = &temp4;
24802 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24803 }
24804 }
24805 if (obj4) {
24806 {
24807 arg5 = (long)(SWIG_As_long(obj4));
24808 if (SWIG_arg_fail(5)) SWIG_fail;
24809 }
24810 }
24811 if (obj5) {
24812 {
24813 arg6 = wxString_in_helper(obj5);
24814 if (arg6 == NULL) SWIG_fail;
24815 temp6 = true;
24816 }
24817 }
24818 {
24819 if (!wxPyCheckForApp()) SWIG_fail;
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24822
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24827 {
24828 if (temp6)
24829 delete arg6;
24830 }
24831 return resultobj;
24832 fail:
24833 {
24834 if (temp6)
24835 delete arg6;
24836 }
24837 return NULL;
24838 }
24839
24840
24841 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24842 PyObject *resultobj;
24843 wxWindow *result;
24844 char *kwnames[] = {
24845 NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24849 {
24850 if (!wxPyCheckForApp()) SWIG_fail;
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 result = (wxWindow *)new wxWindow();
24853
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj;
24866 wxWindow *arg1 = (wxWindow *) 0 ;
24867 wxWindow *arg2 = (wxWindow *) 0 ;
24868 int arg3 = (int) (int)-1 ;
24869 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24870 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24871 wxSize const &arg5_defvalue = wxDefaultSize ;
24872 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24873 long arg6 = (long) 0 ;
24874 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24875 wxString *arg7 = (wxString *) &arg7_defvalue ;
24876 bool result;
24877 wxPoint temp4 ;
24878 wxSize temp5 ;
24879 bool temp7 = false ;
24880 PyObject * obj0 = 0 ;
24881 PyObject * obj1 = 0 ;
24882 PyObject * obj2 = 0 ;
24883 PyObject * obj3 = 0 ;
24884 PyObject * obj4 = 0 ;
24885 PyObject * obj5 = 0 ;
24886 PyObject * obj6 = 0 ;
24887 char *kwnames[] = {
24888 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24889 };
24890
24891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24893 if (SWIG_arg_fail(1)) SWIG_fail;
24894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24895 if (SWIG_arg_fail(2)) SWIG_fail;
24896 if (obj2) {
24897 {
24898 arg3 = (int const)(SWIG_As_int(obj2));
24899 if (SWIG_arg_fail(3)) SWIG_fail;
24900 }
24901 }
24902 if (obj3) {
24903 {
24904 arg4 = &temp4;
24905 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24906 }
24907 }
24908 if (obj4) {
24909 {
24910 arg5 = &temp5;
24911 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24912 }
24913 }
24914 if (obj5) {
24915 {
24916 arg6 = (long)(SWIG_As_long(obj5));
24917 if (SWIG_arg_fail(6)) SWIG_fail;
24918 }
24919 }
24920 if (obj6) {
24921 {
24922 arg7 = wxString_in_helper(obj6);
24923 if (arg7 == NULL) SWIG_fail;
24924 temp7 = true;
24925 }
24926 }
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24930
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 {
24935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24936 }
24937 {
24938 if (temp7)
24939 delete arg7;
24940 }
24941 return resultobj;
24942 fail:
24943 {
24944 if (temp7)
24945 delete arg7;
24946 }
24947 return NULL;
24948 }
24949
24950
24951 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj;
24953 wxWindow *arg1 = (wxWindow *) 0 ;
24954 bool arg2 = (bool) false ;
24955 bool result;
24956 PyObject * obj0 = 0 ;
24957 PyObject * obj1 = 0 ;
24958 char *kwnames[] = {
24959 (char *) "self",(char *) "force", NULL
24960 };
24961
24962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24964 if (SWIG_arg_fail(1)) SWIG_fail;
24965 if (obj1) {
24966 {
24967 arg2 = (bool)(SWIG_As_bool(obj1));
24968 if (SWIG_arg_fail(2)) SWIG_fail;
24969 }
24970 }
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = (bool)(arg1)->Close(arg2);
24974
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24980 }
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24988 PyObject *resultobj;
24989 wxWindow *arg1 = (wxWindow *) 0 ;
24990 bool result;
24991 PyObject * obj0 = 0 ;
24992 char *kwnames[] = {
24993 (char *) "self", NULL
24994 };
24995
24996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24998 if (SWIG_arg_fail(1)) SWIG_fail;
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (bool)(arg1)->Destroy();
25002
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 {
25007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25008 }
25009 return resultobj;
25010 fail:
25011 return NULL;
25012 }
25013
25014
25015 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25016 PyObject *resultobj;
25017 wxWindow *arg1 = (wxWindow *) 0 ;
25018 bool result;
25019 PyObject * obj0 = 0 ;
25020 char *kwnames[] = {
25021 (char *) "self", NULL
25022 };
25023
25024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25026 if (SWIG_arg_fail(1)) SWIG_fail;
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (bool)(arg1)->DestroyChildren();
25030
25031 wxPyEndAllowThreads(__tstate);
25032 if (PyErr_Occurred()) SWIG_fail;
25033 }
25034 {
25035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25036 }
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25044 PyObject *resultobj;
25045 wxWindow *arg1 = (wxWindow *) 0 ;
25046 bool result;
25047 PyObject * obj0 = 0 ;
25048 char *kwnames[] = {
25049 (char *) "self", NULL
25050 };
25051
25052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25054 if (SWIG_arg_fail(1)) SWIG_fail;
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25058
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 {
25063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj;
25073 wxWindow *arg1 = (wxWindow *) 0 ;
25074 wxString *arg2 = 0 ;
25075 bool temp2 = false ;
25076 PyObject * obj0 = 0 ;
25077 PyObject * obj1 = 0 ;
25078 char *kwnames[] = {
25079 (char *) "self",(char *) "title", NULL
25080 };
25081
25082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25084 if (SWIG_arg_fail(1)) SWIG_fail;
25085 {
25086 arg2 = wxString_in_helper(obj1);
25087 if (arg2 == NULL) SWIG_fail;
25088 temp2 = true;
25089 }
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 (arg1)->SetTitle((wxString const &)*arg2);
25093
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 Py_INCREF(Py_None); resultobj = Py_None;
25098 {
25099 if (temp2)
25100 delete arg2;
25101 }
25102 return resultobj;
25103 fail:
25104 {
25105 if (temp2)
25106 delete arg2;
25107 }
25108 return NULL;
25109 }
25110
25111
25112 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj;
25114 wxWindow *arg1 = (wxWindow *) 0 ;
25115 wxString result;
25116 PyObject * obj0 = 0 ;
25117 char *kwnames[] = {
25118 (char *) "self", NULL
25119 };
25120
25121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = ((wxWindow const *)arg1)->GetTitle();
25127
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 {
25132 #if wxUSE_UNICODE
25133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25134 #else
25135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25136 #endif
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj;
25146 wxWindow *arg1 = (wxWindow *) 0 ;
25147 wxString *arg2 = 0 ;
25148 bool temp2 = false ;
25149 PyObject * obj0 = 0 ;
25150 PyObject * obj1 = 0 ;
25151 char *kwnames[] = {
25152 (char *) "self",(char *) "label", NULL
25153 };
25154
25155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25157 if (SWIG_arg_fail(1)) SWIG_fail;
25158 {
25159 arg2 = wxString_in_helper(obj1);
25160 if (arg2 == NULL) SWIG_fail;
25161 temp2 = true;
25162 }
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 (arg1)->SetLabel((wxString const &)*arg2);
25166
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 Py_INCREF(Py_None); resultobj = Py_None;
25171 {
25172 if (temp2)
25173 delete arg2;
25174 }
25175 return resultobj;
25176 fail:
25177 {
25178 if (temp2)
25179 delete arg2;
25180 }
25181 return NULL;
25182 }
25183
25184
25185 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj;
25187 wxWindow *arg1 = (wxWindow *) 0 ;
25188 wxString result;
25189 PyObject * obj0 = 0 ;
25190 char *kwnames[] = {
25191 (char *) "self", NULL
25192 };
25193
25194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25196 if (SWIG_arg_fail(1)) SWIG_fail;
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = ((wxWindow const *)arg1)->GetLabel();
25200
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 {
25205 #if wxUSE_UNICODE
25206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25207 #else
25208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25209 #endif
25210 }
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj;
25219 wxWindow *arg1 = (wxWindow *) 0 ;
25220 wxString *arg2 = 0 ;
25221 bool temp2 = false ;
25222 PyObject * obj0 = 0 ;
25223 PyObject * obj1 = 0 ;
25224 char *kwnames[] = {
25225 (char *) "self",(char *) "name", NULL
25226 };
25227
25228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25230 if (SWIG_arg_fail(1)) SWIG_fail;
25231 {
25232 arg2 = wxString_in_helper(obj1);
25233 if (arg2 == NULL) SWIG_fail;
25234 temp2 = true;
25235 }
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 (arg1)->SetName((wxString const &)*arg2);
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 Py_INCREF(Py_None); resultobj = Py_None;
25244 {
25245 if (temp2)
25246 delete arg2;
25247 }
25248 return resultobj;
25249 fail:
25250 {
25251 if (temp2)
25252 delete arg2;
25253 }
25254 return NULL;
25255 }
25256
25257
25258 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25259 PyObject *resultobj;
25260 wxWindow *arg1 = (wxWindow *) 0 ;
25261 wxString result;
25262 PyObject * obj0 = 0 ;
25263 char *kwnames[] = {
25264 (char *) "self", NULL
25265 };
25266
25267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25269 if (SWIG_arg_fail(1)) SWIG_fail;
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 result = ((wxWindow const *)arg1)->GetName();
25273
25274 wxPyEndAllowThreads(__tstate);
25275 if (PyErr_Occurred()) SWIG_fail;
25276 }
25277 {
25278 #if wxUSE_UNICODE
25279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25280 #else
25281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25282 #endif
25283 }
25284 return resultobj;
25285 fail:
25286 return NULL;
25287 }
25288
25289
25290 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25291 PyObject *resultobj;
25292 wxWindow *arg1 = (wxWindow *) 0 ;
25293 wxWindowVariant arg2 ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "self",(char *) "variant", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25302 if (SWIG_arg_fail(1)) SWIG_fail;
25303 {
25304 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25305 if (SWIG_arg_fail(2)) SWIG_fail;
25306 }
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25310
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 Py_INCREF(Py_None); resultobj = Py_None;
25315 return resultobj;
25316 fail:
25317 return NULL;
25318 }
25319
25320
25321 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25322 PyObject *resultobj;
25323 wxWindow *arg1 = (wxWindow *) 0 ;
25324 wxWindowVariant result;
25325 PyObject * obj0 = 0 ;
25326 char *kwnames[] = {
25327 (char *) "self", NULL
25328 };
25329
25330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25332 if (SWIG_arg_fail(1)) SWIG_fail;
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25336
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 resultobj = SWIG_From_int((result));
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25348 PyObject *resultobj;
25349 wxWindow *arg1 = (wxWindow *) 0 ;
25350 int arg2 ;
25351 PyObject * obj0 = 0 ;
25352 PyObject * obj1 = 0 ;
25353 char *kwnames[] = {
25354 (char *) "self",(char *) "winid", NULL
25355 };
25356
25357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25359 if (SWIG_arg_fail(1)) SWIG_fail;
25360 {
25361 arg2 = (int)(SWIG_As_int(obj1));
25362 if (SWIG_arg_fail(2)) SWIG_fail;
25363 }
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 (arg1)->SetId(arg2);
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 Py_INCREF(Py_None); resultobj = Py_None;
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj;
25380 wxWindow *arg1 = (wxWindow *) 0 ;
25381 int result;
25382 PyObject * obj0 = 0 ;
25383 char *kwnames[] = {
25384 (char *) "self", NULL
25385 };
25386
25387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25389 if (SWIG_arg_fail(1)) SWIG_fail;
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 result = (int)((wxWindow const *)arg1)->GetId();
25393
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 {
25398 resultobj = SWIG_From_int((int)(result));
25399 }
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj;
25408 int result;
25409 char *kwnames[] = {
25410 NULL
25411 };
25412
25413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 result = (int)wxWindow::NewControlId();
25417
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 {
25422 resultobj = SWIG_From_int((int)(result));
25423 }
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj;
25432 int arg1 ;
25433 int result;
25434 PyObject * obj0 = 0 ;
25435 char *kwnames[] = {
25436 (char *) "winid", NULL
25437 };
25438
25439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25440 {
25441 arg1 = (int)(SWIG_As_int(obj0));
25442 if (SWIG_arg_fail(1)) SWIG_fail;
25443 }
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = (int)wxWindow::NextControlId(arg1);
25447
25448 wxPyEndAllowThreads(__tstate);
25449 if (PyErr_Occurred()) SWIG_fail;
25450 }
25451 {
25452 resultobj = SWIG_From_int((int)(result));
25453 }
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj;
25462 int arg1 ;
25463 int result;
25464 PyObject * obj0 = 0 ;
25465 char *kwnames[] = {
25466 (char *) "winid", NULL
25467 };
25468
25469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25470 {
25471 arg1 = (int)(SWIG_As_int(obj0));
25472 if (SWIG_arg_fail(1)) SWIG_fail;
25473 }
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 result = (int)wxWindow::PrevControlId(arg1);
25477
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 {
25482 resultobj = SWIG_From_int((int)(result));
25483 }
25484 return resultobj;
25485 fail:
25486 return NULL;
25487 }
25488
25489
25490 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25491 PyObject *resultobj;
25492 wxWindow *arg1 = (wxWindow *) 0 ;
25493 wxSize *arg2 = 0 ;
25494 wxSize temp2 ;
25495 PyObject * obj0 = 0 ;
25496 PyObject * obj1 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "self",(char *) "size", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",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 = &temp2;
25506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25507 }
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 (arg1)->SetSize((wxSize const &)*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_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj;
25524 wxWindow *arg1 = (wxWindow *) 0 ;
25525 int arg2 ;
25526 int arg3 ;
25527 int arg4 ;
25528 int arg5 ;
25529 int arg6 = (int) wxSIZE_AUTO ;
25530 PyObject * obj0 = 0 ;
25531 PyObject * obj1 = 0 ;
25532 PyObject * obj2 = 0 ;
25533 PyObject * obj3 = 0 ;
25534 PyObject * obj4 = 0 ;
25535 PyObject * obj5 = 0 ;
25536 char *kwnames[] = {
25537 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25538 };
25539
25540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25542 if (SWIG_arg_fail(1)) SWIG_fail;
25543 {
25544 arg2 = (int)(SWIG_As_int(obj1));
25545 if (SWIG_arg_fail(2)) SWIG_fail;
25546 }
25547 {
25548 arg3 = (int)(SWIG_As_int(obj2));
25549 if (SWIG_arg_fail(3)) SWIG_fail;
25550 }
25551 {
25552 arg4 = (int)(SWIG_As_int(obj3));
25553 if (SWIG_arg_fail(4)) SWIG_fail;
25554 }
25555 {
25556 arg5 = (int)(SWIG_As_int(obj4));
25557 if (SWIG_arg_fail(5)) SWIG_fail;
25558 }
25559 if (obj5) {
25560 {
25561 arg6 = (int)(SWIG_As_int(obj5));
25562 if (SWIG_arg_fail(6)) SWIG_fail;
25563 }
25564 }
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
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_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj;
25581 wxWindow *arg1 = (wxWindow *) 0 ;
25582 wxRect *arg2 = 0 ;
25583 int arg3 = (int) wxSIZE_AUTO ;
25584 wxRect temp2 ;
25585 PyObject * obj0 = 0 ;
25586 PyObject * obj1 = 0 ;
25587 PyObject * obj2 = 0 ;
25588 char *kwnames[] = {
25589 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25590 };
25591
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25594 if (SWIG_arg_fail(1)) SWIG_fail;
25595 {
25596 arg2 = &temp2;
25597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25598 }
25599 if (obj2) {
25600 {
25601 arg3 = (int)(SWIG_As_int(obj2));
25602 if (SWIG_arg_fail(3)) SWIG_fail;
25603 }
25604 }
25605 {
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25608
25609 wxPyEndAllowThreads(__tstate);
25610 if (PyErr_Occurred()) SWIG_fail;
25611 }
25612 Py_INCREF(Py_None); resultobj = Py_None;
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25620 PyObject *resultobj;
25621 wxWindow *arg1 = (wxWindow *) 0 ;
25622 int arg2 ;
25623 int arg3 ;
25624 PyObject * obj0 = 0 ;
25625 PyObject * obj1 = 0 ;
25626 PyObject * obj2 = 0 ;
25627 char *kwnames[] = {
25628 (char *) "self",(char *) "width",(char *) "height", NULL
25629 };
25630
25631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25633 if (SWIG_arg_fail(1)) SWIG_fail;
25634 {
25635 arg2 = (int)(SWIG_As_int(obj1));
25636 if (SWIG_arg_fail(2)) SWIG_fail;
25637 }
25638 {
25639 arg3 = (int)(SWIG_As_int(obj2));
25640 if (SWIG_arg_fail(3)) SWIG_fail;
25641 }
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 (arg1)->SetSize(arg2,arg3);
25645
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 Py_INCREF(Py_None); resultobj = Py_None;
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25657 PyObject *resultobj;
25658 wxWindow *arg1 = (wxWindow *) 0 ;
25659 wxPoint *arg2 = 0 ;
25660 int arg3 = (int) wxSIZE_USE_EXISTING ;
25661 wxPoint temp2 ;
25662 PyObject * obj0 = 0 ;
25663 PyObject * obj1 = 0 ;
25664 PyObject * obj2 = 0 ;
25665 char *kwnames[] = {
25666 (char *) "self",(char *) "pt",(char *) "flags", NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25671 if (SWIG_arg_fail(1)) SWIG_fail;
25672 {
25673 arg2 = &temp2;
25674 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25675 }
25676 if (obj2) {
25677 {
25678 arg3 = (int)(SWIG_As_int(obj2));
25679 if (SWIG_arg_fail(3)) SWIG_fail;
25680 }
25681 }
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 (arg1)->Move((wxPoint const &)*arg2,arg3);
25685
25686 wxPyEndAllowThreads(__tstate);
25687 if (PyErr_Occurred()) SWIG_fail;
25688 }
25689 Py_INCREF(Py_None); resultobj = Py_None;
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj;
25698 wxWindow *arg1 = (wxWindow *) 0 ;
25699 int arg2 ;
25700 int arg3 ;
25701 int arg4 = (int) wxSIZE_USE_EXISTING ;
25702 PyObject * obj0 = 0 ;
25703 PyObject * obj1 = 0 ;
25704 PyObject * obj2 = 0 ;
25705 PyObject * obj3 = 0 ;
25706 char *kwnames[] = {
25707 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25708 };
25709
25710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25712 if (SWIG_arg_fail(1)) SWIG_fail;
25713 {
25714 arg2 = (int)(SWIG_As_int(obj1));
25715 if (SWIG_arg_fail(2)) SWIG_fail;
25716 }
25717 {
25718 arg3 = (int)(SWIG_As_int(obj2));
25719 if (SWIG_arg_fail(3)) SWIG_fail;
25720 }
25721 if (obj3) {
25722 {
25723 arg4 = (int)(SWIG_As_int(obj3));
25724 if (SWIG_arg_fail(4)) SWIG_fail;
25725 }
25726 }
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 (arg1)->Move(arg2,arg3,arg4);
25730
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 Py_INCREF(Py_None); resultobj = Py_None;
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj;
25743 wxWindow *arg1 = (wxWindow *) 0 ;
25744 wxSize const &arg2_defvalue = wxDefaultSize ;
25745 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25746 wxSize temp2 ;
25747 PyObject * obj0 = 0 ;
25748 PyObject * obj1 = 0 ;
25749 char *kwnames[] = {
25750 (char *) "self",(char *) "size", NULL
25751 };
25752
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 if (obj1) {
25757 {
25758 arg2 = &temp2;
25759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25760 }
25761 }
25762 {
25763 PyThreadState* __tstate = wxPyBeginAllowThreads();
25764 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25765
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 Py_INCREF(Py_None); resultobj = Py_None;
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj;
25778 wxWindow *arg1 = (wxWindow *) 0 ;
25779 PyObject * obj0 = 0 ;
25780 char *kwnames[] = {
25781 (char *) "self", NULL
25782 };
25783
25784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25786 if (SWIG_arg_fail(1)) SWIG_fail;
25787 {
25788 PyThreadState* __tstate = wxPyBeginAllowThreads();
25789 (arg1)->Raise();
25790
25791 wxPyEndAllowThreads(__tstate);
25792 if (PyErr_Occurred()) SWIG_fail;
25793 }
25794 Py_INCREF(Py_None); resultobj = Py_None;
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxWindow *arg1 = (wxWindow *) 0 ;
25804 PyObject * obj0 = 0 ;
25805 char *kwnames[] = {
25806 (char *) "self", NULL
25807 };
25808
25809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25811 if (SWIG_arg_fail(1)) SWIG_fail;
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 (arg1)->Lower();
25815
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 Py_INCREF(Py_None); resultobj = Py_None;
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj;
25828 wxWindow *arg1 = (wxWindow *) 0 ;
25829 wxSize *arg2 = 0 ;
25830 wxSize temp2 ;
25831 PyObject * obj0 = 0 ;
25832 PyObject * obj1 = 0 ;
25833 char *kwnames[] = {
25834 (char *) "self",(char *) "size", NULL
25835 };
25836
25837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25839 if (SWIG_arg_fail(1)) SWIG_fail;
25840 {
25841 arg2 = &temp2;
25842 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25843 }
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 (arg1)->SetClientSize((wxSize const &)*arg2);
25847
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 Py_INCREF(Py_None); resultobj = Py_None;
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj;
25860 wxWindow *arg1 = (wxWindow *) 0 ;
25861 int arg2 ;
25862 int arg3 ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 PyObject * obj2 = 0 ;
25866 char *kwnames[] = {
25867 (char *) "self",(char *) "width",(char *) "height", NULL
25868 };
25869
25870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",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 = (int)(SWIG_As_int(obj1));
25875 if (SWIG_arg_fail(2)) SWIG_fail;
25876 }
25877 {
25878 arg3 = (int)(SWIG_As_int(obj2));
25879 if (SWIG_arg_fail(3)) SWIG_fail;
25880 }
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 (arg1)->SetClientSize(arg2,arg3);
25884
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 Py_INCREF(Py_None); resultobj = Py_None;
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj;
25897 wxWindow *arg1 = (wxWindow *) 0 ;
25898 wxRect *arg2 = 0 ;
25899 wxRect temp2 ;
25900 PyObject * obj0 = 0 ;
25901 PyObject * obj1 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "rect", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 arg2 = &temp2;
25911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25912 }
25913 {
25914 PyThreadState* __tstate = wxPyBeginAllowThreads();
25915 (arg1)->SetClientSize((wxRect const &)*arg2);
25916
25917 wxPyEndAllowThreads(__tstate);
25918 if (PyErr_Occurred()) SWIG_fail;
25919 }
25920 Py_INCREF(Py_None); resultobj = Py_None;
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj;
25929 wxWindow *arg1 = (wxWindow *) 0 ;
25930 wxPoint result;
25931 PyObject * obj0 = 0 ;
25932 char *kwnames[] = {
25933 (char *) "self", NULL
25934 };
25935
25936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25938 if (SWIG_arg_fail(1)) SWIG_fail;
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 result = (arg1)->GetPosition();
25942
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 {
25947 wxPoint * resultptr;
25948 resultptr = new wxPoint((wxPoint &)(result));
25949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25950 }
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj;
25959 wxWindow *arg1 = (wxWindow *) 0 ;
25960 int *arg2 = (int *) 0 ;
25961 int *arg3 = (int *) 0 ;
25962 int temp2 ;
25963 int res2 = 0 ;
25964 int temp3 ;
25965 int res3 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self", NULL
25969 };
25970
25971 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25972 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25975 if (SWIG_arg_fail(1)) SWIG_fail;
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 (arg1)->GetPosition(arg2,arg3);
25979
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 Py_INCREF(Py_None); resultobj = Py_None;
25984 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25985 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25986 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25987 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25995 PyObject *resultobj;
25996 wxWindow *arg1 = (wxWindow *) 0 ;
25997 wxSize result;
25998 PyObject * obj0 = 0 ;
25999 char *kwnames[] = {
26000 (char *) "self", NULL
26001 };
26002
26003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26005 if (SWIG_arg_fail(1)) SWIG_fail;
26006 {
26007 PyThreadState* __tstate = wxPyBeginAllowThreads();
26008 result = ((wxWindow const *)arg1)->GetSize();
26009
26010 wxPyEndAllowThreads(__tstate);
26011 if (PyErr_Occurred()) SWIG_fail;
26012 }
26013 {
26014 wxSize * resultptr;
26015 resultptr = new wxSize((wxSize &)(result));
26016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26017 }
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj;
26026 wxWindow *arg1 = (wxWindow *) 0 ;
26027 int *arg2 = (int *) 0 ;
26028 int *arg3 = (int *) 0 ;
26029 int temp2 ;
26030 int res2 = 0 ;
26031 int temp3 ;
26032 int res3 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 char *kwnames[] = {
26035 (char *) "self", NULL
26036 };
26037
26038 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26039 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26042 if (SWIG_arg_fail(1)) SWIG_fail;
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26046
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 Py_INCREF(Py_None); resultobj = Py_None;
26051 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26052 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26053 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26054 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26062 PyObject *resultobj;
26063 wxWindow *arg1 = (wxWindow *) 0 ;
26064 wxRect result;
26065 PyObject * obj0 = 0 ;
26066 char *kwnames[] = {
26067 (char *) "self", NULL
26068 };
26069
26070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26072 if (SWIG_arg_fail(1)) SWIG_fail;
26073 {
26074 PyThreadState* __tstate = wxPyBeginAllowThreads();
26075 result = ((wxWindow const *)arg1)->GetRect();
26076
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 wxRect * resultptr;
26082 resultptr = new wxRect((wxRect &)(result));
26083 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26084 }
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj;
26093 wxWindow *arg1 = (wxWindow *) 0 ;
26094 wxSize result;
26095 PyObject * obj0 = 0 ;
26096 char *kwnames[] = {
26097 (char *) "self", NULL
26098 };
26099
26100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26102 if (SWIG_arg_fail(1)) SWIG_fail;
26103 {
26104 PyThreadState* __tstate = wxPyBeginAllowThreads();
26105 result = ((wxWindow const *)arg1)->GetClientSize();
26106
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 {
26111 wxSize * resultptr;
26112 resultptr = new wxSize((wxSize &)(result));
26113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26114 }
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26122 PyObject *resultobj;
26123 wxWindow *arg1 = (wxWindow *) 0 ;
26124 int *arg2 = (int *) 0 ;
26125 int *arg3 = (int *) 0 ;
26126 int temp2 ;
26127 int res2 = 0 ;
26128 int temp3 ;
26129 int res3 = 0 ;
26130 PyObject * obj0 = 0 ;
26131 char *kwnames[] = {
26132 (char *) "self", NULL
26133 };
26134
26135 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26136 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",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 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26143
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 Py_INCREF(Py_None); resultobj = Py_None;
26148 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26149 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26150 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26151 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj;
26160 wxWindow *arg1 = (wxWindow *) 0 ;
26161 wxPoint result;
26162 PyObject * obj0 = 0 ;
26163 char *kwnames[] = {
26164 (char *) "self", NULL
26165 };
26166
26167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26169 if (SWIG_arg_fail(1)) SWIG_fail;
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26173
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 {
26178 wxPoint * resultptr;
26179 resultptr = new wxPoint((wxPoint &)(result));
26180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26181 }
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26189 PyObject *resultobj;
26190 wxWindow *arg1 = (wxWindow *) 0 ;
26191 wxRect result;
26192 PyObject * obj0 = 0 ;
26193 char *kwnames[] = {
26194 (char *) "self", NULL
26195 };
26196
26197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(1)) SWIG_fail;
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 result = ((wxWindow const *)arg1)->GetClientRect();
26203
26204 wxPyEndAllowThreads(__tstate);
26205 if (PyErr_Occurred()) SWIG_fail;
26206 }
26207 {
26208 wxRect * resultptr;
26209 resultptr = new wxRect((wxRect &)(result));
26210 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26211 }
26212 return resultobj;
26213 fail:
26214 return NULL;
26215 }
26216
26217
26218 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26219 PyObject *resultobj;
26220 wxWindow *arg1 = (wxWindow *) 0 ;
26221 wxSize result;
26222 PyObject * obj0 = 0 ;
26223 char *kwnames[] = {
26224 (char *) "self", NULL
26225 };
26226
26227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26229 if (SWIG_arg_fail(1)) SWIG_fail;
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = ((wxWindow const *)arg1)->GetBestSize();
26233
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 {
26238 wxSize * resultptr;
26239 resultptr = new wxSize((wxSize &)(result));
26240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj;
26250 wxWindow *arg1 = (wxWindow *) 0 ;
26251 int *arg2 = (int *) 0 ;
26252 int *arg3 = (int *) 0 ;
26253 int temp2 ;
26254 int res2 = 0 ;
26255 int temp3 ;
26256 int res3 = 0 ;
26257 PyObject * obj0 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self", NULL
26260 };
26261
26262 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26263 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26266 if (SWIG_arg_fail(1)) SWIG_fail;
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 Py_INCREF(Py_None); resultobj = Py_None;
26275 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26276 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26277 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26278 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj;
26287 wxWindow *arg1 = (wxWindow *) 0 ;
26288 PyObject * obj0 = 0 ;
26289 char *kwnames[] = {
26290 (char *) "self", NULL
26291 };
26292
26293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26295 if (SWIG_arg_fail(1)) SWIG_fail;
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 (arg1)->InvalidateBestSize();
26299
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 Py_INCREF(Py_None); resultobj = Py_None;
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26311 PyObject *resultobj;
26312 wxWindow *arg1 = (wxWindow *) 0 ;
26313 wxSize result;
26314 PyObject * obj0 = 0 ;
26315 char *kwnames[] = {
26316 (char *) "self", NULL
26317 };
26318
26319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26321 if (SWIG_arg_fail(1)) SWIG_fail;
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26325
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 {
26330 wxSize * resultptr;
26331 resultptr = new wxSize((wxSize &)(result));
26332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26333 }
26334 return resultobj;
26335 fail:
26336 return NULL;
26337 }
26338
26339
26340 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26341 PyObject *resultobj;
26342 wxWindow *arg1 = (wxWindow *) 0 ;
26343 wxSize result;
26344 PyObject * obj0 = 0 ;
26345 char *kwnames[] = {
26346 (char *) "self", NULL
26347 };
26348
26349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26351 if (SWIG_arg_fail(1)) SWIG_fail;
26352 {
26353 PyThreadState* __tstate = wxPyBeginAllowThreads();
26354 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26355
26356 wxPyEndAllowThreads(__tstate);
26357 if (PyErr_Occurred()) SWIG_fail;
26358 }
26359 {
26360 wxSize * resultptr;
26361 resultptr = new wxSize((wxSize &)(result));
26362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26363 }
26364 return resultobj;
26365 fail:
26366 return NULL;
26367 }
26368
26369
26370 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26371 PyObject *resultobj;
26372 wxWindow *arg1 = (wxWindow *) 0 ;
26373 int arg2 = (int) wxBOTH ;
26374 PyObject * obj0 = 0 ;
26375 PyObject * obj1 = 0 ;
26376 char *kwnames[] = {
26377 (char *) "self",(char *) "direction", NULL
26378 };
26379
26380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26382 if (SWIG_arg_fail(1)) SWIG_fail;
26383 if (obj1) {
26384 {
26385 arg2 = (int)(SWIG_As_int(obj1));
26386 if (SWIG_arg_fail(2)) SWIG_fail;
26387 }
26388 }
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 (arg1)->Center(arg2);
26392
26393 wxPyEndAllowThreads(__tstate);
26394 if (PyErr_Occurred()) SWIG_fail;
26395 }
26396 Py_INCREF(Py_None); resultobj = Py_None;
26397 return resultobj;
26398 fail:
26399 return NULL;
26400 }
26401
26402
26403 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj;
26405 wxWindow *arg1 = (wxWindow *) 0 ;
26406 int arg2 = (int) wxBOTH ;
26407 PyObject * obj0 = 0 ;
26408 PyObject * obj1 = 0 ;
26409 char *kwnames[] = {
26410 (char *) "self",(char *) "dir", NULL
26411 };
26412
26413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26415 if (SWIG_arg_fail(1)) SWIG_fail;
26416 if (obj1) {
26417 {
26418 arg2 = (int)(SWIG_As_int(obj1));
26419 if (SWIG_arg_fail(2)) SWIG_fail;
26420 }
26421 }
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 (arg1)->CenterOnScreen(arg2);
26425
26426 wxPyEndAllowThreads(__tstate);
26427 if (PyErr_Occurred()) SWIG_fail;
26428 }
26429 Py_INCREF(Py_None); resultobj = Py_None;
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj;
26438 wxWindow *arg1 = (wxWindow *) 0 ;
26439 int arg2 = (int) wxBOTH ;
26440 PyObject * obj0 = 0 ;
26441 PyObject * obj1 = 0 ;
26442 char *kwnames[] = {
26443 (char *) "self",(char *) "dir", NULL
26444 };
26445
26446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26448 if (SWIG_arg_fail(1)) SWIG_fail;
26449 if (obj1) {
26450 {
26451 arg2 = (int)(SWIG_As_int(obj1));
26452 if (SWIG_arg_fail(2)) SWIG_fail;
26453 }
26454 }
26455 {
26456 PyThreadState* __tstate = wxPyBeginAllowThreads();
26457 (arg1)->CenterOnParent(arg2);
26458
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 Py_INCREF(Py_None); resultobj = Py_None;
26463 return resultobj;
26464 fail:
26465 return NULL;
26466 }
26467
26468
26469 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26470 PyObject *resultobj;
26471 wxWindow *arg1 = (wxWindow *) 0 ;
26472 PyObject * obj0 = 0 ;
26473 char *kwnames[] = {
26474 (char *) "self", NULL
26475 };
26476
26477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26479 if (SWIG_arg_fail(1)) SWIG_fail;
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 (arg1)->Fit();
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 Py_INCREF(Py_None); resultobj = Py_None;
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxWindow *arg1 = (wxWindow *) 0 ;
26497 PyObject * obj0 = 0 ;
26498 char *kwnames[] = {
26499 (char *) "self", NULL
26500 };
26501
26502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26504 if (SWIG_arg_fail(1)) SWIG_fail;
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 (arg1)->FitInside();
26508
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 Py_INCREF(Py_None); resultobj = Py_None;
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26520 PyObject *resultobj;
26521 wxWindow *arg1 = (wxWindow *) 0 ;
26522 int arg2 ;
26523 int arg3 ;
26524 int arg4 = (int) -1 ;
26525 int arg5 = (int) -1 ;
26526 int arg6 = (int) -1 ;
26527 int arg7 = (int) -1 ;
26528 PyObject * obj0 = 0 ;
26529 PyObject * obj1 = 0 ;
26530 PyObject * obj2 = 0 ;
26531 PyObject * obj3 = 0 ;
26532 PyObject * obj4 = 0 ;
26533 PyObject * obj5 = 0 ;
26534 PyObject * obj6 = 0 ;
26535 char *kwnames[] = {
26536 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26537 };
26538
26539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26541 if (SWIG_arg_fail(1)) SWIG_fail;
26542 {
26543 arg2 = (int)(SWIG_As_int(obj1));
26544 if (SWIG_arg_fail(2)) SWIG_fail;
26545 }
26546 {
26547 arg3 = (int)(SWIG_As_int(obj2));
26548 if (SWIG_arg_fail(3)) SWIG_fail;
26549 }
26550 if (obj3) {
26551 {
26552 arg4 = (int)(SWIG_As_int(obj3));
26553 if (SWIG_arg_fail(4)) SWIG_fail;
26554 }
26555 }
26556 if (obj4) {
26557 {
26558 arg5 = (int)(SWIG_As_int(obj4));
26559 if (SWIG_arg_fail(5)) SWIG_fail;
26560 }
26561 }
26562 if (obj5) {
26563 {
26564 arg6 = (int)(SWIG_As_int(obj5));
26565 if (SWIG_arg_fail(6)) SWIG_fail;
26566 }
26567 }
26568 if (obj6) {
26569 {
26570 arg7 = (int)(SWIG_As_int(obj6));
26571 if (SWIG_arg_fail(7)) SWIG_fail;
26572 }
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 Py_INCREF(Py_None); resultobj = Py_None;
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj;
26590 wxWindow *arg1 = (wxWindow *) 0 ;
26591 wxSize *arg2 = 0 ;
26592 wxSize const &arg3_defvalue = wxDefaultSize ;
26593 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26594 wxSize const &arg4_defvalue = wxDefaultSize ;
26595 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26596 wxSize temp2 ;
26597 wxSize temp3 ;
26598 wxSize temp4 ;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 PyObject * obj2 = 0 ;
26602 PyObject * obj3 = 0 ;
26603 char *kwnames[] = {
26604 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26605 };
26606
26607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26609 if (SWIG_arg_fail(1)) SWIG_fail;
26610 {
26611 arg2 = &temp2;
26612 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26613 }
26614 if (obj2) {
26615 {
26616 arg3 = &temp3;
26617 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26618 }
26619 }
26620 if (obj3) {
26621 {
26622 arg4 = &temp4;
26623 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26624 }
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26629
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 Py_INCREF(Py_None); resultobj = Py_None;
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj;
26642 wxWindow *arg1 = (wxWindow *) 0 ;
26643 int arg2 ;
26644 int arg3 ;
26645 int arg4 = (int) -1 ;
26646 int arg5 = (int) -1 ;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649 PyObject * obj2 = 0 ;
26650 PyObject * obj3 = 0 ;
26651 PyObject * obj4 = 0 ;
26652 char *kwnames[] = {
26653 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26654 };
26655
26656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26658 if (SWIG_arg_fail(1)) SWIG_fail;
26659 {
26660 arg2 = (int)(SWIG_As_int(obj1));
26661 if (SWIG_arg_fail(2)) SWIG_fail;
26662 }
26663 {
26664 arg3 = (int)(SWIG_As_int(obj2));
26665 if (SWIG_arg_fail(3)) SWIG_fail;
26666 }
26667 if (obj3) {
26668 {
26669 arg4 = (int)(SWIG_As_int(obj3));
26670 if (SWIG_arg_fail(4)) SWIG_fail;
26671 }
26672 }
26673 if (obj4) {
26674 {
26675 arg5 = (int)(SWIG_As_int(obj4));
26676 if (SWIG_arg_fail(5)) SWIG_fail;
26677 }
26678 }
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 Py_INCREF(Py_None); resultobj = Py_None;
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj;
26695 wxWindow *arg1 = (wxWindow *) 0 ;
26696 wxSize *arg2 = 0 ;
26697 wxSize const &arg3_defvalue = wxDefaultSize ;
26698 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26699 wxSize temp2 ;
26700 wxSize temp3 ;
26701 PyObject * obj0 = 0 ;
26702 PyObject * obj1 = 0 ;
26703 PyObject * obj2 = 0 ;
26704 char *kwnames[] = {
26705 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26706 };
26707
26708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26710 if (SWIG_arg_fail(1)) SWIG_fail;
26711 {
26712 arg2 = &temp2;
26713 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26714 }
26715 if (obj2) {
26716 {
26717 arg3 = &temp3;
26718 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26719 }
26720 }
26721 {
26722 PyThreadState* __tstate = wxPyBeginAllowThreads();
26723 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26724
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 Py_INCREF(Py_None); resultobj = Py_None;
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxWindow *arg1 = (wxWindow *) 0 ;
26738 wxSize result;
26739 PyObject * obj0 = 0 ;
26740 char *kwnames[] = {
26741 (char *) "self", NULL
26742 };
26743
26744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26746 if (SWIG_arg_fail(1)) SWIG_fail;
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 result = ((wxWindow const *)arg1)->GetMaxSize();
26750
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 {
26755 wxSize * resultptr;
26756 resultptr = new wxSize((wxSize &)(result));
26757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26758 }
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj;
26767 wxWindow *arg1 = (wxWindow *) 0 ;
26768 wxSize result;
26769 PyObject * obj0 = 0 ;
26770 char *kwnames[] = {
26771 (char *) "self", NULL
26772 };
26773
26774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26776 if (SWIG_arg_fail(1)) SWIG_fail;
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = ((wxWindow const *)arg1)->GetMinSize();
26780
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 {
26785 wxSize * resultptr;
26786 resultptr = new wxSize((wxSize &)(result));
26787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26788 }
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj;
26797 wxWindow *arg1 = (wxWindow *) 0 ;
26798 wxSize *arg2 = 0 ;
26799 wxSize temp2 ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self",(char *) "minSize", NULL
26804 };
26805
26806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 {
26810 arg2 = &temp2;
26811 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26812 }
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 (arg1)->SetMinSize((wxSize const &)*arg2);
26816
26817 wxPyEndAllowThreads(__tstate);
26818 if (PyErr_Occurred()) SWIG_fail;
26819 }
26820 Py_INCREF(Py_None); resultobj = Py_None;
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj;
26829 wxWindow *arg1 = (wxWindow *) 0 ;
26830 wxSize *arg2 = 0 ;
26831 wxSize temp2 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 char *kwnames[] = {
26835 (char *) "self",(char *) "maxSize", NULL
26836 };
26837
26838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26840 if (SWIG_arg_fail(1)) SWIG_fail;
26841 {
26842 arg2 = &temp2;
26843 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26844 }
26845 {
26846 PyThreadState* __tstate = wxPyBeginAllowThreads();
26847 (arg1)->SetMaxSize((wxSize const &)*arg2);
26848
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 Py_INCREF(Py_None); resultobj = Py_None;
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxWindow *arg1 = (wxWindow *) 0 ;
26862 int result;
26863 PyObject * obj0 = 0 ;
26864 char *kwnames[] = {
26865 (char *) "self", NULL
26866 };
26867
26868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26870 if (SWIG_arg_fail(1)) SWIG_fail;
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26874
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 {
26879 resultobj = SWIG_From_int((int)(result));
26880 }
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj;
26889 wxWindow *arg1 = (wxWindow *) 0 ;
26890 int result;
26891 PyObject * obj0 = 0 ;
26892 char *kwnames[] = {
26893 (char *) "self", NULL
26894 };
26895
26896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26898 if (SWIG_arg_fail(1)) SWIG_fail;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 resultobj = SWIG_From_int((int)(result));
26908 }
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26916 PyObject *resultobj;
26917 wxWindow *arg1 = (wxWindow *) 0 ;
26918 int result;
26919 PyObject * obj0 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26930
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 {
26935 resultobj = SWIG_From_int((int)(result));
26936 }
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj;
26945 wxWindow *arg1 = (wxWindow *) 0 ;
26946 int result;
26947 PyObject * obj0 = 0 ;
26948 char *kwnames[] = {
26949 (char *) "self", NULL
26950 };
26951
26952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26954 if (SWIG_arg_fail(1)) SWIG_fail;
26955 {
26956 PyThreadState* __tstate = wxPyBeginAllowThreads();
26957 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26958
26959 wxPyEndAllowThreads(__tstate);
26960 if (PyErr_Occurred()) SWIG_fail;
26961 }
26962 {
26963 resultobj = SWIG_From_int((int)(result));
26964 }
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj;
26973 wxWindow *arg1 = (wxWindow *) 0 ;
26974 wxSize *arg2 = 0 ;
26975 wxSize temp2 ;
26976 PyObject * obj0 = 0 ;
26977 PyObject * obj1 = 0 ;
26978 char *kwnames[] = {
26979 (char *) "self",(char *) "size", NULL
26980 };
26981
26982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26984 if (SWIG_arg_fail(1)) SWIG_fail;
26985 {
26986 arg2 = &temp2;
26987 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26988 }
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26992
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 Py_INCREF(Py_None); resultobj = Py_None;
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27004 PyObject *resultobj;
27005 wxWindow *arg1 = (wxWindow *) 0 ;
27006 int arg2 ;
27007 int arg3 ;
27008 PyObject * obj0 = 0 ;
27009 PyObject * obj1 = 0 ;
27010 PyObject * obj2 = 0 ;
27011 char *kwnames[] = {
27012 (char *) "self",(char *) "w",(char *) "h", NULL
27013 };
27014
27015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27017 if (SWIG_arg_fail(1)) SWIG_fail;
27018 {
27019 arg2 = (int)(SWIG_As_int(obj1));
27020 if (SWIG_arg_fail(2)) SWIG_fail;
27021 }
27022 {
27023 arg3 = (int)(SWIG_As_int(obj2));
27024 if (SWIG_arg_fail(3)) SWIG_fail;
27025 }
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 (arg1)->SetVirtualSize(arg2,arg3);
27029
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 Py_INCREF(Py_None); resultobj = Py_None;
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj;
27042 wxWindow *arg1 = (wxWindow *) 0 ;
27043 wxSize result;
27044 PyObject * obj0 = 0 ;
27045 char *kwnames[] = {
27046 (char *) "self", NULL
27047 };
27048
27049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27051 if (SWIG_arg_fail(1)) SWIG_fail;
27052 {
27053 PyThreadState* __tstate = wxPyBeginAllowThreads();
27054 result = ((wxWindow const *)arg1)->GetVirtualSize();
27055
27056 wxPyEndAllowThreads(__tstate);
27057 if (PyErr_Occurred()) SWIG_fail;
27058 }
27059 {
27060 wxSize * resultptr;
27061 resultptr = new wxSize((wxSize &)(result));
27062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27063 }
27064 return resultobj;
27065 fail:
27066 return NULL;
27067 }
27068
27069
27070 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27071 PyObject *resultobj;
27072 wxWindow *arg1 = (wxWindow *) 0 ;
27073 int *arg2 = (int *) 0 ;
27074 int *arg3 = (int *) 0 ;
27075 int temp2 ;
27076 int res2 = 0 ;
27077 int temp3 ;
27078 int res3 = 0 ;
27079 PyObject * obj0 = 0 ;
27080 char *kwnames[] = {
27081 (char *) "self", NULL
27082 };
27083
27084 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27085 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27088 if (SWIG_arg_fail(1)) SWIG_fail;
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27092
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 Py_INCREF(Py_None); resultobj = Py_None;
27097 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27098 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27099 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27100 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27101 return resultobj;
27102 fail:
27103 return NULL;
27104 }
27105
27106
27107 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27108 PyObject *resultobj;
27109 wxWindow *arg1 = (wxWindow *) 0 ;
27110 wxSize result;
27111 PyObject * obj0 = 0 ;
27112 char *kwnames[] = {
27113 (char *) "self", NULL
27114 };
27115
27116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27118 if (SWIG_arg_fail(1)) SWIG_fail;
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27122
27123 wxPyEndAllowThreads(__tstate);
27124 if (PyErr_Occurred()) SWIG_fail;
27125 }
27126 {
27127 wxSize * resultptr;
27128 resultptr = new wxSize((wxSize &)(result));
27129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27130 }
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27138 PyObject *resultobj;
27139 wxWindow *arg1 = (wxWindow *) 0 ;
27140 bool arg2 = (bool) true ;
27141 bool result;
27142 PyObject * obj0 = 0 ;
27143 PyObject * obj1 = 0 ;
27144 char *kwnames[] = {
27145 (char *) "self",(char *) "show", NULL
27146 };
27147
27148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(1)) SWIG_fail;
27151 if (obj1) {
27152 {
27153 arg2 = (bool)(SWIG_As_bool(obj1));
27154 if (SWIG_arg_fail(2)) SWIG_fail;
27155 }
27156 }
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (bool)(arg1)->Show(arg2);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 {
27165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27166 }
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27174 PyObject *resultobj;
27175 wxWindow *arg1 = (wxWindow *) 0 ;
27176 bool result;
27177 PyObject * obj0 = 0 ;
27178 char *kwnames[] = {
27179 (char *) "self", NULL
27180 };
27181
27182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(1)) SWIG_fail;
27185 {
27186 PyThreadState* __tstate = wxPyBeginAllowThreads();
27187 result = (bool)(arg1)->Hide();
27188
27189 wxPyEndAllowThreads(__tstate);
27190 if (PyErr_Occurred()) SWIG_fail;
27191 }
27192 {
27193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27194 }
27195 return resultobj;
27196 fail:
27197 return NULL;
27198 }
27199
27200
27201 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27202 PyObject *resultobj;
27203 wxWindow *arg1 = (wxWindow *) 0 ;
27204 bool arg2 = (bool) true ;
27205 bool result;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self",(char *) "enable", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27214 if (SWIG_arg_fail(1)) SWIG_fail;
27215 if (obj1) {
27216 {
27217 arg2 = (bool)(SWIG_As_bool(obj1));
27218 if (SWIG_arg_fail(2)) SWIG_fail;
27219 }
27220 }
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = (bool)(arg1)->Enable(arg2);
27224
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 {
27229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27230 }
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 bool result;
27241 PyObject * obj0 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = (bool)(arg1)->Disable();
27252
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 {
27257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27258 }
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 bool result;
27269 PyObject * obj0 = 0 ;
27270 char *kwnames[] = {
27271 (char *) "self", NULL
27272 };
27273
27274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = (bool)((wxWindow const *)arg1)->IsShown();
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 {
27285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27286 }
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj;
27295 wxWindow *arg1 = (wxWindow *) 0 ;
27296 bool result;
27297 PyObject * obj0 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self", NULL
27300 };
27301
27302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27304 if (SWIG_arg_fail(1)) SWIG_fail;
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 {
27313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27314 }
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj;
27323 wxWindow *arg1 = (wxWindow *) 0 ;
27324 long arg2 ;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "style", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 {
27335 arg2 = (long)(SWIG_As_long(obj1));
27336 if (SWIG_arg_fail(2)) SWIG_fail;
27337 }
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 (arg1)->SetWindowStyleFlag(arg2);
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 Py_INCREF(Py_None); resultobj = Py_None;
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj;
27354 wxWindow *arg1 = (wxWindow *) 0 ;
27355 long result;
27356 PyObject * obj0 = 0 ;
27357 char *kwnames[] = {
27358 (char *) "self", NULL
27359 };
27360
27361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27363 if (SWIG_arg_fail(1)) SWIG_fail;
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27367
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 {
27372 resultobj = SWIG_From_long((long)(result));
27373 }
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27381 PyObject *resultobj;
27382 wxWindow *arg1 = (wxWindow *) 0 ;
27383 int arg2 ;
27384 bool result;
27385 PyObject * obj0 = 0 ;
27386 PyObject * obj1 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self",(char *) "flag", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 {
27395 arg2 = (int)(SWIG_As_int(obj1));
27396 if (SWIG_arg_fail(2)) SWIG_fail;
27397 }
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27401
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27415 PyObject *resultobj;
27416 wxWindow *arg1 = (wxWindow *) 0 ;
27417 bool result;
27418 PyObject * obj0 = 0 ;
27419 char *kwnames[] = {
27420 (char *) "self", NULL
27421 };
27422
27423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27425 if (SWIG_arg_fail(1)) SWIG_fail;
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = (bool)((wxWindow const *)arg1)->IsRetained();
27429
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj;
27444 wxWindow *arg1 = (wxWindow *) 0 ;
27445 long arg2 ;
27446 PyObject * obj0 = 0 ;
27447 PyObject * obj1 = 0 ;
27448 char *kwnames[] = {
27449 (char *) "self",(char *) "exStyle", NULL
27450 };
27451
27452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27454 if (SWIG_arg_fail(1)) SWIG_fail;
27455 {
27456 arg2 = (long)(SWIG_As_long(obj1));
27457 if (SWIG_arg_fail(2)) SWIG_fail;
27458 }
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 (arg1)->SetExtraStyle(arg2);
27462
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 Py_INCREF(Py_None); resultobj = Py_None;
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27474 PyObject *resultobj;
27475 wxWindow *arg1 = (wxWindow *) 0 ;
27476 long result;
27477 PyObject * obj0 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(1)) SWIG_fail;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = SWIG_From_long((long)(result));
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj;
27503 wxWindow *arg1 = (wxWindow *) 0 ;
27504 bool arg2 = (bool) true ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self",(char *) "modal", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 if (obj1) {
27515 {
27516 arg2 = (bool)(SWIG_As_bool(obj1));
27517 if (SWIG_arg_fail(2)) SWIG_fail;
27518 }
27519 }
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 (arg1)->MakeModal(arg2);
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 Py_INCREF(Py_None); resultobj = Py_None;
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 bool arg2 ;
27538 PyObject * obj0 = 0 ;
27539 PyObject * obj1 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "enableTheme", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 {
27548 arg2 = (bool)(SWIG_As_bool(obj1));
27549 if (SWIG_arg_fail(2)) SWIG_fail;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 (arg1)->SetThemeEnabled(arg2);
27554
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 Py_INCREF(Py_None); resultobj = Py_None;
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27566 PyObject *resultobj;
27567 wxWindow *arg1 = (wxWindow *) 0 ;
27568 bool result;
27569 PyObject * obj0 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 PyObject * obj0 = 0 ;
27597 char *kwnames[] = {
27598 (char *) "self", NULL
27599 };
27600
27601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27603 if (SWIG_arg_fail(1)) SWIG_fail;
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 (arg1)->SetFocus();
27607
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 Py_INCREF(Py_None); resultobj = Py_None;
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27619 PyObject *resultobj;
27620 wxWindow *arg1 = (wxWindow *) 0 ;
27621 PyObject * obj0 = 0 ;
27622 char *kwnames[] = {
27623 (char *) "self", NULL
27624 };
27625
27626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27628 if (SWIG_arg_fail(1)) SWIG_fail;
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 (arg1)->SetFocusFromKbd();
27632
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 Py_INCREF(Py_None); resultobj = Py_None;
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27644 PyObject *resultobj;
27645 wxWindow *result;
27646 char *kwnames[] = {
27647 NULL
27648 };
27649
27650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27651 {
27652 if (!wxPyCheckForApp()) SWIG_fail;
27653 PyThreadState* __tstate = wxPyBeginAllowThreads();
27654 result = (wxWindow *)wxWindow::FindFocus();
27655
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 {
27660 resultobj = wxPyMake_wxObject(result, 0);
27661 }
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27669 PyObject *resultobj;
27670 wxWindow *arg1 = (wxWindow *) 0 ;
27671 bool result;
27672 PyObject * obj0 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(1)) SWIG_fail;
27680 {
27681 PyThreadState* __tstate = wxPyBeginAllowThreads();
27682 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27683
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 {
27688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27689 }
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxWindow *arg1 = (wxWindow *) 0 ;
27699 bool result;
27700 PyObject * obj0 = 0 ;
27701 char *kwnames[] = {
27702 (char *) "self", NULL
27703 };
27704
27705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27707 if (SWIG_arg_fail(1)) SWIG_fail;
27708 {
27709 PyThreadState* __tstate = wxPyBeginAllowThreads();
27710 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27711
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 {
27716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27717 }
27718 return resultobj;
27719 fail:
27720 return NULL;
27721 }
27722
27723
27724 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27725 PyObject *resultobj;
27726 wxWindow *arg1 = (wxWindow *) 0 ;
27727 wxWindow *result;
27728 PyObject * obj0 = 0 ;
27729 char *kwnames[] = {
27730 (char *) "self", NULL
27731 };
27732
27733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27735 if (SWIG_arg_fail(1)) SWIG_fail;
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27739
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = wxPyMake_wxObject(result, 0);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj;
27754 wxWindow *arg1 = (wxWindow *) 0 ;
27755 wxWindow *arg2 = (wxWindow *) 0 ;
27756 wxWindow *result;
27757 PyObject * obj0 = 0 ;
27758 PyObject * obj1 = 0 ;
27759 char *kwnames[] = {
27760 (char *) "self",(char *) "child", NULL
27761 };
27762
27763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27765 if (SWIG_arg_fail(1)) SWIG_fail;
27766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27767 if (SWIG_arg_fail(2)) SWIG_fail;
27768 {
27769 PyThreadState* __tstate = wxPyBeginAllowThreads();
27770 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27771
27772 wxPyEndAllowThreads(__tstate);
27773 if (PyErr_Occurred()) SWIG_fail;
27774 }
27775 {
27776 resultobj = wxPyMake_wxObject(result, 0);
27777 }
27778 return resultobj;
27779 fail:
27780 return NULL;
27781 }
27782
27783
27784 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27785 PyObject *resultobj;
27786 wxWindow *arg1 = (wxWindow *) 0 ;
27787 wxWindow *arg2 = (wxWindow *) 0 ;
27788 PyObject * obj0 = 0 ;
27789 PyObject * obj1 = 0 ;
27790 char *kwnames[] = {
27791 (char *) "self",(char *) "win", NULL
27792 };
27793
27794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27796 if (SWIG_arg_fail(1)) SWIG_fail;
27797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27798 if (SWIG_arg_fail(2)) SWIG_fail;
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 (arg1)->SetTmpDefaultItem(arg2);
27802
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 Py_INCREF(Py_None); resultobj = Py_None;
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27817 bool result;
27818 PyObject * obj0 = 0 ;
27819 PyObject * obj1 = 0 ;
27820 char *kwnames[] = {
27821 (char *) "self",(char *) "flags", NULL
27822 };
27823
27824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27826 if (SWIG_arg_fail(1)) SWIG_fail;
27827 if (obj1) {
27828 {
27829 arg2 = (int)(SWIG_As_int(obj1));
27830 if (SWIG_arg_fail(2)) SWIG_fail;
27831 }
27832 }
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = (bool)(arg1)->Navigate(arg2);
27836
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 {
27841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27842 }
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27850 PyObject *resultobj;
27851 wxWindow *arg1 = (wxWindow *) 0 ;
27852 wxWindow *arg2 = (wxWindow *) 0 ;
27853 PyObject * obj0 = 0 ;
27854 PyObject * obj1 = 0 ;
27855 char *kwnames[] = {
27856 (char *) "self",(char *) "win", NULL
27857 };
27858
27859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27861 if (SWIG_arg_fail(1)) SWIG_fail;
27862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27863 if (SWIG_arg_fail(2)) SWIG_fail;
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 (arg1)->MoveAfterInTabOrder(arg2);
27867
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 Py_INCREF(Py_None); resultobj = Py_None;
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27879 PyObject *resultobj;
27880 wxWindow *arg1 = (wxWindow *) 0 ;
27881 wxWindow *arg2 = (wxWindow *) 0 ;
27882 PyObject * obj0 = 0 ;
27883 PyObject * obj1 = 0 ;
27884 char *kwnames[] = {
27885 (char *) "self",(char *) "win", NULL
27886 };
27887
27888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27890 if (SWIG_arg_fail(1)) SWIG_fail;
27891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27892 if (SWIG_arg_fail(2)) SWIG_fail;
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 (arg1)->MoveBeforeInTabOrder(arg2);
27896
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 Py_INCREF(Py_None); resultobj = Py_None;
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj;
27909 wxWindow *arg1 = (wxWindow *) 0 ;
27910 PyObject *result;
27911 PyObject * obj0 = 0 ;
27912 char *kwnames[] = {
27913 (char *) "self", NULL
27914 };
27915
27916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27918 if (SWIG_arg_fail(1)) SWIG_fail;
27919 {
27920 PyThreadState* __tstate = wxPyBeginAllowThreads();
27921 result = (PyObject *)wxWindow_GetChildren(arg1);
27922
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 resultobj = result;
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 wxWindow *result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = wxPyMake_wxObject(result, 0);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 wxWindow *result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = wxPyMake_wxObject(result, 0);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxWindow *arg1 = (wxWindow *) 0 ;
27992 bool result;
27993 PyObject * obj0 = 0 ;
27994 char *kwnames[] = {
27995 (char *) "self", NULL
27996 };
27997
27998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(1)) SWIG_fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 {
28009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj;
28019 wxWindow *arg1 = (wxWindow *) 0 ;
28020 wxWindow *arg2 = (wxWindow *) 0 ;
28021 bool result;
28022 PyObject * obj0 = 0 ;
28023 PyObject * obj1 = 0 ;
28024 char *kwnames[] = {
28025 (char *) "self",(char *) "newParent", NULL
28026 };
28027
28028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28030 if (SWIG_arg_fail(1)) SWIG_fail;
28031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28032 if (SWIG_arg_fail(2)) SWIG_fail;
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 result = (bool)(arg1)->Reparent(arg2);
28036
28037 wxPyEndAllowThreads(__tstate);
28038 if (PyErr_Occurred()) SWIG_fail;
28039 }
28040 {
28041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28042 }
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj;
28051 wxWindow *arg1 = (wxWindow *) 0 ;
28052 wxWindow *arg2 = (wxWindow *) 0 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self",(char *) "child", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(2)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 (arg1)->AddChild(arg2);
28067
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 Py_INCREF(Py_None); resultobj = Py_None;
28072 return resultobj;
28073 fail:
28074 return NULL;
28075 }
28076
28077
28078 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj;
28080 wxWindow *arg1 = (wxWindow *) 0 ;
28081 wxWindow *arg2 = (wxWindow *) 0 ;
28082 PyObject * obj0 = 0 ;
28083 PyObject * obj1 = 0 ;
28084 char *kwnames[] = {
28085 (char *) "self",(char *) "child", NULL
28086 };
28087
28088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28090 if (SWIG_arg_fail(1)) SWIG_fail;
28091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28092 if (SWIG_arg_fail(2)) SWIG_fail;
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 (arg1)->RemoveChild(arg2);
28096
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 Py_INCREF(Py_None); resultobj = Py_None;
28101 return resultobj;
28102 fail:
28103 return NULL;
28104 }
28105
28106
28107 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28108 PyObject *resultobj;
28109 wxWindow *arg1 = (wxWindow *) 0 ;
28110 long arg2 ;
28111 wxWindow *result;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self",(char *) "winid", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 arg2 = (long)(SWIG_As_long(obj1));
28123 if (SWIG_arg_fail(2)) SWIG_fail;
28124 }
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (wxWindow *)(arg1)->FindWindow(arg2);
28128
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 {
28133 resultobj = wxPyMake_wxObject(result, 0);
28134 }
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28142 PyObject *resultobj;
28143 wxWindow *arg1 = (wxWindow *) 0 ;
28144 wxString *arg2 = 0 ;
28145 wxWindow *result;
28146 bool temp2 = false ;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "self",(char *) "name", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 {
28157 arg2 = wxString_in_helper(obj1);
28158 if (arg2 == NULL) SWIG_fail;
28159 temp2 = true;
28160 }
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28164
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 {
28169 resultobj = wxPyMake_wxObject(result, 0);
28170 }
28171 {
28172 if (temp2)
28173 delete arg2;
28174 }
28175 return resultobj;
28176 fail:
28177 {
28178 if (temp2)
28179 delete arg2;
28180 }
28181 return NULL;
28182 }
28183
28184
28185 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj;
28187 wxWindow *arg1 = (wxWindow *) 0 ;
28188 wxEvtHandler *result;
28189 PyObject * obj0 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 {
28205 resultobj = wxPyMake_wxObject(result, 0);
28206 }
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj;
28215 wxWindow *arg1 = (wxWindow *) 0 ;
28216 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28217 PyObject * obj0 = 0 ;
28218 PyObject * obj1 = 0 ;
28219 char *kwnames[] = {
28220 (char *) "self",(char *) "handler", NULL
28221 };
28222
28223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28225 if (SWIG_arg_fail(1)) SWIG_fail;
28226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(2)) SWIG_fail;
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 (arg1)->SetEventHandler(arg2);
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 Py_INCREF(Py_None); resultobj = Py_None;
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj;
28244 wxWindow *arg1 = (wxWindow *) 0 ;
28245 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28246 PyObject * obj0 = 0 ;
28247 PyObject * obj1 = 0 ;
28248 char *kwnames[] = {
28249 (char *) "self",(char *) "handler", NULL
28250 };
28251
28252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28254 if (SWIG_arg_fail(1)) SWIG_fail;
28255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28256 if (SWIG_arg_fail(2)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 (arg1)->PushEventHandler(arg2);
28260
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 Py_INCREF(Py_None); resultobj = Py_None;
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj;
28273 wxWindow *arg1 = (wxWindow *) 0 ;
28274 bool arg2 = (bool) false ;
28275 wxEvtHandler *result;
28276 PyObject * obj0 = 0 ;
28277 PyObject * obj1 = 0 ;
28278 char *kwnames[] = {
28279 (char *) "self",(char *) "deleteHandler", NULL
28280 };
28281
28282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28284 if (SWIG_arg_fail(1)) SWIG_fail;
28285 if (obj1) {
28286 {
28287 arg2 = (bool)(SWIG_As_bool(obj1));
28288 if (SWIG_arg_fail(2)) SWIG_fail;
28289 }
28290 }
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28294
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 {
28299 resultobj = wxPyMake_wxObject(result, 0);
28300 }
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28308 PyObject *resultobj;
28309 wxWindow *arg1 = (wxWindow *) 0 ;
28310 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28311 bool result;
28312 PyObject * obj0 = 0 ;
28313 PyObject * obj1 = 0 ;
28314 char *kwnames[] = {
28315 (char *) "self",(char *) "handler", NULL
28316 };
28317
28318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28320 if (SWIG_arg_fail(1)) SWIG_fail;
28321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(2)) SWIG_fail;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (bool)(arg1)->RemoveEventHandler(arg2);
28326
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 {
28331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28332 }
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28340 PyObject *resultobj;
28341 wxWindow *arg1 = (wxWindow *) 0 ;
28342 wxValidator *arg2 = 0 ;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 char *kwnames[] = {
28346 (char *) "self",(char *) "validator", NULL
28347 };
28348
28349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28351 if (SWIG_arg_fail(1)) SWIG_fail;
28352 {
28353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28354 if (SWIG_arg_fail(2)) SWIG_fail;
28355 if (arg2 == NULL) {
28356 SWIG_null_ref("wxValidator");
28357 }
28358 if (SWIG_arg_fail(2)) SWIG_fail;
28359 }
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 (arg1)->SetValidator((wxValidator const &)*arg2);
28363
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 Py_INCREF(Py_None); resultobj = Py_None;
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj;
28376 wxWindow *arg1 = (wxWindow *) 0 ;
28377 wxValidator *result;
28378 PyObject * obj0 = 0 ;
28379 char *kwnames[] = {
28380 (char *) "self", NULL
28381 };
28382
28383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28385 if (SWIG_arg_fail(1)) SWIG_fail;
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (wxValidator *)(arg1)->GetValidator();
28389
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 {
28394 resultobj = wxPyMake_wxObject(result, 0);
28395 }
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28403 PyObject *resultobj;
28404 wxWindow *arg1 = (wxWindow *) 0 ;
28405 bool result;
28406 PyObject * obj0 = 0 ;
28407 char *kwnames[] = {
28408 (char *) "self", NULL
28409 };
28410
28411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28413 if (SWIG_arg_fail(1)) SWIG_fail;
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (bool)(arg1)->Validate();
28417
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28423 }
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj;
28432 wxWindow *arg1 = (wxWindow *) 0 ;
28433 bool result;
28434 PyObject * obj0 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28441 if (SWIG_arg_fail(1)) SWIG_fail;
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (bool)(arg1)->TransferDataToWindow();
28445
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28459 PyObject *resultobj;
28460 wxWindow *arg1 = (wxWindow *) 0 ;
28461 bool result;
28462 PyObject * obj0 = 0 ;
28463 char *kwnames[] = {
28464 (char *) "self", NULL
28465 };
28466
28467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28469 if (SWIG_arg_fail(1)) SWIG_fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (bool)(arg1)->TransferDataFromWindow();
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj;
28488 wxWindow *arg1 = (wxWindow *) 0 ;
28489 PyObject * obj0 = 0 ;
28490 char *kwnames[] = {
28491 (char *) "self", NULL
28492 };
28493
28494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28496 if (SWIG_arg_fail(1)) SWIG_fail;
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->InitDialog();
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 Py_INCREF(Py_None); resultobj = Py_None;
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28512 PyObject *resultobj;
28513 wxWindow *arg1 = (wxWindow *) 0 ;
28514 wxAcceleratorTable *arg2 = 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 char *kwnames[] = {
28518 (char *) "self",(char *) "accel", NULL
28519 };
28520
28521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(1)) SWIG_fail;
28524 {
28525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28526 if (SWIG_arg_fail(2)) SWIG_fail;
28527 if (arg2 == NULL) {
28528 SWIG_null_ref("wxAcceleratorTable");
28529 }
28530 if (SWIG_arg_fail(2)) SWIG_fail;
28531 }
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 Py_INCREF(Py_None); resultobj = Py_None;
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxWindow *arg1 = (wxWindow *) 0 ;
28549 wxAcceleratorTable *result;
28550 PyObject * obj0 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28561
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj;
28574 wxWindow *arg1 = (wxWindow *) 0 ;
28575 int arg2 ;
28576 int arg3 ;
28577 int arg4 ;
28578 bool result;
28579 PyObject * obj0 = 0 ;
28580 PyObject * obj1 = 0 ;
28581 PyObject * obj2 = 0 ;
28582 PyObject * obj3 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 {
28591 arg2 = (int)(SWIG_As_int(obj1));
28592 if (SWIG_arg_fail(2)) SWIG_fail;
28593 }
28594 {
28595 arg3 = (int)(SWIG_As_int(obj2));
28596 if (SWIG_arg_fail(3)) SWIG_fail;
28597 }
28598 {
28599 arg4 = (int)(SWIG_As_int(obj3));
28600 if (SWIG_arg_fail(4)) SWIG_fail;
28601 }
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj;
28620 wxWindow *arg1 = (wxWindow *) 0 ;
28621 int arg2 ;
28622 bool result;
28623 PyObject * obj0 = 0 ;
28624 PyObject * obj1 = 0 ;
28625 char *kwnames[] = {
28626 (char *) "self",(char *) "hotkeyId", NULL
28627 };
28628
28629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28631 if (SWIG_arg_fail(1)) SWIG_fail;
28632 {
28633 arg2 = (int)(SWIG_As_int(obj1));
28634 if (SWIG_arg_fail(2)) SWIG_fail;
28635 }
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28639
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 {
28644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28645 }
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28653 PyObject *resultobj;
28654 wxWindow *arg1 = (wxWindow *) 0 ;
28655 wxPoint *arg2 = 0 ;
28656 wxPoint result;
28657 wxPoint temp2 ;
28658 PyObject * obj0 = 0 ;
28659 PyObject * obj1 = 0 ;
28660 char *kwnames[] = {
28661 (char *) "self",(char *) "pt", NULL
28662 };
28663
28664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28666 if (SWIG_arg_fail(1)) SWIG_fail;
28667 {
28668 arg2 = &temp2;
28669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28670 }
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28674
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 {
28679 wxPoint * resultptr;
28680 resultptr = new wxPoint((wxPoint &)(result));
28681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28682 }
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj;
28691 wxWindow *arg1 = (wxWindow *) 0 ;
28692 wxSize *arg2 = 0 ;
28693 wxSize result;
28694 wxSize temp2 ;
28695 PyObject * obj0 = 0 ;
28696 PyObject * obj1 = 0 ;
28697 char *kwnames[] = {
28698 (char *) "self",(char *) "sz", NULL
28699 };
28700
28701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(1)) SWIG_fail;
28704 {
28705 arg2 = &temp2;
28706 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28707 }
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28711
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 {
28716 wxSize * resultptr;
28717 resultptr = new wxSize((wxSize &)(result));
28718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28719 }
28720 return resultobj;
28721 fail:
28722 return NULL;
28723 }
28724
28725
28726 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28727 PyObject *resultobj;
28728 wxWindow *arg1 = (wxWindow *) 0 ;
28729 wxPoint *arg2 = 0 ;
28730 wxPoint result;
28731 wxPoint temp2 ;
28732 PyObject * obj0 = 0 ;
28733 PyObject * obj1 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "self",(char *) "pt", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 {
28742 arg2 = &temp2;
28743 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28744 }
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28748
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 {
28753 wxPoint * resultptr;
28754 resultptr = new wxPoint((wxPoint &)(result));
28755 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28756 }
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj;
28765 wxWindow *arg1 = (wxWindow *) 0 ;
28766 wxSize *arg2 = 0 ;
28767 wxSize result;
28768 wxSize temp2 ;
28769 PyObject * obj0 = 0 ;
28770 PyObject * obj1 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self",(char *) "sz", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 arg2 = &temp2;
28780 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28781 }
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 {
28790 wxSize * resultptr;
28791 resultptr = new wxSize((wxSize &)(result));
28792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28793 }
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28801 PyObject *resultobj;
28802 wxWindow *arg1 = (wxWindow *) 0 ;
28803 wxPoint *arg2 = 0 ;
28804 wxPoint result;
28805 wxPoint temp2 ;
28806 PyObject * obj0 = 0 ;
28807 PyObject * obj1 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self",(char *) "pt", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 {
28816 arg2 = &temp2;
28817 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28818 }
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 {
28827 wxPoint * resultptr;
28828 resultptr = new wxPoint((wxPoint &)(result));
28829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28830 }
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj;
28839 wxWindow *arg1 = (wxWindow *) 0 ;
28840 wxSize *arg2 = 0 ;
28841 wxSize result;
28842 wxSize temp2 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self",(char *) "sz", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 {
28853 arg2 = &temp2;
28854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28855 }
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 {
28864 wxSize * resultptr;
28865 resultptr = new wxSize((wxSize &)(result));
28866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28867 }
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj;
28876 wxWindow *arg1 = (wxWindow *) 0 ;
28877 int arg2 ;
28878 int arg3 ;
28879 PyObject * obj0 = 0 ;
28880 PyObject * obj1 = 0 ;
28881 PyObject * obj2 = 0 ;
28882 char *kwnames[] = {
28883 (char *) "self",(char *) "x",(char *) "y", NULL
28884 };
28885
28886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28888 if (SWIG_arg_fail(1)) SWIG_fail;
28889 {
28890 arg2 = (int)(SWIG_As_int(obj1));
28891 if (SWIG_arg_fail(2)) SWIG_fail;
28892 }
28893 {
28894 arg3 = (int)(SWIG_As_int(obj2));
28895 if (SWIG_arg_fail(3)) SWIG_fail;
28896 }
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 (arg1)->WarpPointer(arg2,arg3);
28900
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 Py_INCREF(Py_None); resultobj = Py_None;
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj;
28913 wxWindow *arg1 = (wxWindow *) 0 ;
28914 PyObject * obj0 = 0 ;
28915 char *kwnames[] = {
28916 (char *) "self", NULL
28917 };
28918
28919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(1)) SWIG_fail;
28922 {
28923 PyThreadState* __tstate = wxPyBeginAllowThreads();
28924 (arg1)->CaptureMouse();
28925
28926 wxPyEndAllowThreads(__tstate);
28927 if (PyErr_Occurred()) SWIG_fail;
28928 }
28929 Py_INCREF(Py_None); resultobj = Py_None;
28930 return resultobj;
28931 fail:
28932 return NULL;
28933 }
28934
28935
28936 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28937 PyObject *resultobj;
28938 wxWindow *arg1 = (wxWindow *) 0 ;
28939 PyObject * obj0 = 0 ;
28940 char *kwnames[] = {
28941 (char *) "self", NULL
28942 };
28943
28944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28946 if (SWIG_arg_fail(1)) SWIG_fail;
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 (arg1)->ReleaseMouse();
28950
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 Py_INCREF(Py_None); resultobj = Py_None;
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28962 PyObject *resultobj;
28963 wxWindow *result;
28964 char *kwnames[] = {
28965 NULL
28966 };
28967
28968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28969 {
28970 if (!wxPyCheckForApp()) SWIG_fail;
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (wxWindow *)wxWindow::GetCapture();
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 resultobj = wxPyMake_wxObject(result, 0);
28979 }
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj;
28988 wxWindow *arg1 = (wxWindow *) 0 ;
28989 bool result;
28990 PyObject * obj0 = 0 ;
28991 char *kwnames[] = {
28992 (char *) "self", NULL
28993 };
28994
28995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28997 if (SWIG_arg_fail(1)) SWIG_fail;
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = (bool)((wxWindow const *)arg1)->HasCapture();
29001
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 {
29006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29007 }
29008 return resultobj;
29009 fail:
29010 return NULL;
29011 }
29012
29013
29014 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29015 PyObject *resultobj;
29016 wxWindow *arg1 = (wxWindow *) 0 ;
29017 bool arg2 = (bool) true ;
29018 wxRect *arg3 = (wxRect *) NULL ;
29019 PyObject * obj0 = 0 ;
29020 PyObject * obj1 = 0 ;
29021 PyObject * obj2 = 0 ;
29022 char *kwnames[] = {
29023 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29024 };
29025
29026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29028 if (SWIG_arg_fail(1)) SWIG_fail;
29029 if (obj1) {
29030 {
29031 arg2 = (bool)(SWIG_As_bool(obj1));
29032 if (SWIG_arg_fail(2)) SWIG_fail;
29033 }
29034 }
29035 if (obj2) {
29036 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(3)) SWIG_fail;
29038 }
29039 {
29040 PyThreadState* __tstate = wxPyBeginAllowThreads();
29041 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29042
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 Py_INCREF(Py_None); resultobj = Py_None;
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29054 PyObject *resultobj;
29055 wxWindow *arg1 = (wxWindow *) 0 ;
29056 wxRect *arg2 = 0 ;
29057 bool arg3 = (bool) true ;
29058 wxRect temp2 ;
29059 PyObject * obj0 = 0 ;
29060 PyObject * obj1 = 0 ;
29061 PyObject * obj2 = 0 ;
29062 char *kwnames[] = {
29063 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29064 };
29065
29066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(1)) SWIG_fail;
29069 {
29070 arg2 = &temp2;
29071 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29072 }
29073 if (obj2) {
29074 {
29075 arg3 = (bool)(SWIG_As_bool(obj2));
29076 if (SWIG_arg_fail(3)) SWIG_fail;
29077 }
29078 }
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 Py_INCREF(Py_None); resultobj = Py_None;
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj;
29095 wxWindow *arg1 = (wxWindow *) 0 ;
29096 PyObject * obj0 = 0 ;
29097 char *kwnames[] = {
29098 (char *) "self", NULL
29099 };
29100
29101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29103 if (SWIG_arg_fail(1)) SWIG_fail;
29104 {
29105 PyThreadState* __tstate = wxPyBeginAllowThreads();
29106 (arg1)->Update();
29107
29108 wxPyEndAllowThreads(__tstate);
29109 if (PyErr_Occurred()) SWIG_fail;
29110 }
29111 Py_INCREF(Py_None); resultobj = Py_None;
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj;
29120 wxWindow *arg1 = (wxWindow *) 0 ;
29121 PyObject * obj0 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 {
29130 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 (arg1)->ClearBackground();
29132
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 Py_INCREF(Py_None); resultobj = Py_None;
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29144 PyObject *resultobj;
29145 wxWindow *arg1 = (wxWindow *) 0 ;
29146 PyObject * obj0 = 0 ;
29147 char *kwnames[] = {
29148 (char *) "self", NULL
29149 };
29150
29151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29153 if (SWIG_arg_fail(1)) SWIG_fail;
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 (arg1)->Freeze();
29157
29158 wxPyEndAllowThreads(__tstate);
29159 if (PyErr_Occurred()) SWIG_fail;
29160 }
29161 Py_INCREF(Py_None); resultobj = Py_None;
29162 return resultobj;
29163 fail:
29164 return NULL;
29165 }
29166
29167
29168 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29169 PyObject *resultobj;
29170 wxWindow *arg1 = (wxWindow *) 0 ;
29171 PyObject * obj0 = 0 ;
29172 char *kwnames[] = {
29173 (char *) "self", NULL
29174 };
29175
29176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29178 if (SWIG_arg_fail(1)) SWIG_fail;
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 (arg1)->Thaw();
29182
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 Py_INCREF(Py_None); resultobj = Py_None;
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj;
29195 wxWindow *arg1 = (wxWindow *) 0 ;
29196 wxDC *arg2 = 0 ;
29197 PyObject * obj0 = 0 ;
29198 PyObject * obj1 = 0 ;
29199 char *kwnames[] = {
29200 (char *) "self",(char *) "dc", NULL
29201 };
29202
29203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29205 if (SWIG_arg_fail(1)) SWIG_fail;
29206 {
29207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29208 if (SWIG_arg_fail(2)) SWIG_fail;
29209 if (arg2 == NULL) {
29210 SWIG_null_ref("wxDC");
29211 }
29212 if (SWIG_arg_fail(2)) SWIG_fail;
29213 }
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 (arg1)->PrepareDC(*arg2);
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 Py_INCREF(Py_None); resultobj = Py_None;
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj;
29230 wxWindow *arg1 = (wxWindow *) 0 ;
29231 wxRegion *result;
29232 PyObject * obj0 = 0 ;
29233 char *kwnames[] = {
29234 (char *) "self", NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29239 if (SWIG_arg_fail(1)) SWIG_fail;
29240 {
29241 PyThreadState* __tstate = wxPyBeginAllowThreads();
29242 {
29243 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29244 result = (wxRegion *) &_result_ref;
29245 }
29246
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29258 PyObject *resultobj;
29259 wxWindow *arg1 = (wxWindow *) 0 ;
29260 wxRect result;
29261 PyObject * obj0 = 0 ;
29262 char *kwnames[] = {
29263 (char *) "self", NULL
29264 };
29265
29266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29268 if (SWIG_arg_fail(1)) SWIG_fail;
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 {
29277 wxRect * resultptr;
29278 resultptr = new wxRect((wxRect &)(result));
29279 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29280 }
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29288 PyObject *resultobj;
29289 wxWindow *arg1 = (wxWindow *) 0 ;
29290 int arg2 ;
29291 int arg3 ;
29292 int arg4 = (int) 1 ;
29293 int arg5 = (int) 1 ;
29294 bool result;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 PyObject * obj2 = 0 ;
29298 PyObject * obj3 = 0 ;
29299 PyObject * obj4 = 0 ;
29300 char *kwnames[] = {
29301 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29302 };
29303
29304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29306 if (SWIG_arg_fail(1)) SWIG_fail;
29307 {
29308 arg2 = (int)(SWIG_As_int(obj1));
29309 if (SWIG_arg_fail(2)) SWIG_fail;
29310 }
29311 {
29312 arg3 = (int)(SWIG_As_int(obj2));
29313 if (SWIG_arg_fail(3)) SWIG_fail;
29314 }
29315 if (obj3) {
29316 {
29317 arg4 = (int)(SWIG_As_int(obj3));
29318 if (SWIG_arg_fail(4)) SWIG_fail;
29319 }
29320 }
29321 if (obj4) {
29322 {
29323 arg5 = (int)(SWIG_As_int(obj4));
29324 if (SWIG_arg_fail(5)) SWIG_fail;
29325 }
29326 }
29327 {
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29330
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 {
29335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29336 }
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj;
29345 wxWindow *arg1 = (wxWindow *) 0 ;
29346 wxPoint *arg2 = 0 ;
29347 bool result;
29348 wxPoint temp2 ;
29349 PyObject * obj0 = 0 ;
29350 PyObject * obj1 = 0 ;
29351 char *kwnames[] = {
29352 (char *) "self",(char *) "pt", NULL
29353 };
29354
29355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29357 if (SWIG_arg_fail(1)) SWIG_fail;
29358 {
29359 arg2 = &temp2;
29360 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29361 }
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 {
29370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29371 }
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj;
29380 wxWindow *arg1 = (wxWindow *) 0 ;
29381 wxRect *arg2 = 0 ;
29382 bool result;
29383 wxRect temp2 ;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 char *kwnames[] = {
29387 (char *) "self",(char *) "rect", NULL
29388 };
29389
29390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29392 if (SWIG_arg_fail(1)) SWIG_fail;
29393 {
29394 arg2 = &temp2;
29395 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29396 }
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 {
29405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29406 }
29407 return resultobj;
29408 fail:
29409 return NULL;
29410 }
29411
29412
29413 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29414 PyObject *resultobj;
29415 wxWindow *arg1 = (wxWindow *) 0 ;
29416 wxVisualAttributes result;
29417 PyObject * obj0 = 0 ;
29418 char *kwnames[] = {
29419 (char *) "self", NULL
29420 };
29421
29422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29424 if (SWIG_arg_fail(1)) SWIG_fail;
29425 {
29426 PyThreadState* __tstate = wxPyBeginAllowThreads();
29427 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29428
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 {
29433 wxVisualAttributes * resultptr;
29434 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29436 }
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29444 PyObject *resultobj;
29445 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29446 wxVisualAttributes result;
29447 PyObject * obj0 = 0 ;
29448 char *kwnames[] = {
29449 (char *) "variant", NULL
29450 };
29451
29452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29453 if (obj0) {
29454 {
29455 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29456 if (SWIG_arg_fail(1)) SWIG_fail;
29457 }
29458 }
29459 {
29460 if (!wxPyCheckForApp()) SWIG_fail;
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 wxVisualAttributes * resultptr;
29469 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29471 }
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj;
29480 wxWindow *arg1 = (wxWindow *) 0 ;
29481 wxColour *arg2 = 0 ;
29482 bool result;
29483 wxColour temp2 ;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 char *kwnames[] = {
29487 (char *) "self",(char *) "colour", NULL
29488 };
29489
29490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29492 if (SWIG_arg_fail(1)) SWIG_fail;
29493 {
29494 arg2 = &temp2;
29495 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29496 }
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29500
29501 wxPyEndAllowThreads(__tstate);
29502 if (PyErr_Occurred()) SWIG_fail;
29503 }
29504 {
29505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29506 }
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj;
29515 wxWindow *arg1 = (wxWindow *) 0 ;
29516 wxColour *arg2 = 0 ;
29517 wxColour temp2 ;
29518 PyObject * obj0 = 0 ;
29519 PyObject * obj1 = 0 ;
29520 char *kwnames[] = {
29521 (char *) "self",(char *) "colour", NULL
29522 };
29523
29524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29526 if (SWIG_arg_fail(1)) SWIG_fail;
29527 {
29528 arg2 = &temp2;
29529 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29530 }
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 Py_INCREF(Py_None); resultobj = Py_None;
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxWindow *arg1 = (wxWindow *) 0 ;
29548 wxColour *arg2 = 0 ;
29549 bool result;
29550 wxColour temp2 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self",(char *) "colour", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 {
29561 arg2 = &temp2;
29562 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxWindow *arg1 = (wxWindow *) 0 ;
29583 wxColour *arg2 = 0 ;
29584 wxColour temp2 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char *kwnames[] = {
29588 (char *) "self",(char *) "colour", NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",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 ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29597 }
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 Py_INCREF(Py_None); resultobj = Py_None;
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxWindow *arg1 = (wxWindow *) 0 ;
29615 wxColour result;
29616 PyObject * obj0 = 0 ;
29617 char *kwnames[] = {
29618 (char *) "self", NULL
29619 };
29620
29621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29623 if (SWIG_arg_fail(1)) SWIG_fail;
29624 {
29625 PyThreadState* __tstate = wxPyBeginAllowThreads();
29626 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29627
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 {
29632 wxColour * resultptr;
29633 resultptr = new wxColour((wxColour &)(result));
29634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29635 }
29636 return resultobj;
29637 fail:
29638 return NULL;
29639 }
29640
29641
29642 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29643 PyObject *resultobj;
29644 wxWindow *arg1 = (wxWindow *) 0 ;
29645 wxColour result;
29646 PyObject * obj0 = 0 ;
29647 char *kwnames[] = {
29648 (char *) "self", NULL
29649 };
29650
29651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29653 if (SWIG_arg_fail(1)) SWIG_fail;
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = ((wxWindow const *)arg1)->GetForegroundColour();
29657
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 wxColour * resultptr;
29663 resultptr = new wxColour((wxColour &)(result));
29664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29665 }
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj;
29674 wxWindow *arg1 = (wxWindow *) 0 ;
29675 bool result;
29676 PyObject * obj0 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(1)) SWIG_fail;
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 {
29692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29693 }
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj;
29702 wxWindow *arg1 = (wxWindow *) 0 ;
29703 bool result;
29704 PyObject * obj0 = 0 ;
29705 char *kwnames[] = {
29706 (char *) "self", NULL
29707 };
29708
29709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29711 if (SWIG_arg_fail(1)) SWIG_fail;
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 {
29720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29721 }
29722 return resultobj;
29723 fail:
29724 return NULL;
29725 }
29726
29727
29728 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29729 PyObject *resultobj;
29730 wxWindow *arg1 = (wxWindow *) 0 ;
29731 wxBackgroundStyle arg2 ;
29732 bool result;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 char *kwnames[] = {
29736 (char *) "self",(char *) "style", NULL
29737 };
29738
29739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29741 if (SWIG_arg_fail(1)) SWIG_fail;
29742 {
29743 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29744 if (SWIG_arg_fail(2)) SWIG_fail;
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 {
29754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29755 }
29756 return resultobj;
29757 fail:
29758 return NULL;
29759 }
29760
29761
29762 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29763 PyObject *resultobj;
29764 wxWindow *arg1 = (wxWindow *) 0 ;
29765 wxBackgroundStyle result;
29766 PyObject * obj0 = 0 ;
29767 char *kwnames[] = {
29768 (char *) "self", NULL
29769 };
29770
29771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29773 if (SWIG_arg_fail(1)) SWIG_fail;
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29777
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = SWIG_From_int((result));
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj;
29790 wxWindow *arg1 = (wxWindow *) 0 ;
29791 bool result;
29792 PyObject * obj0 = 0 ;
29793 char *kwnames[] = {
29794 (char *) "self", NULL
29795 };
29796
29797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29799 if (SWIG_arg_fail(1)) SWIG_fail;
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 result = (bool)(arg1)->HasTransparentBackground();
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 {
29808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29809 }
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29817 PyObject *resultobj;
29818 wxWindow *arg1 = (wxWindow *) 0 ;
29819 wxCursor *arg2 = 0 ;
29820 bool result;
29821 PyObject * obj0 = 0 ;
29822 PyObject * obj1 = 0 ;
29823 char *kwnames[] = {
29824 (char *) "self",(char *) "cursor", NULL
29825 };
29826
29827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29829 if (SWIG_arg_fail(1)) SWIG_fail;
29830 {
29831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29832 if (SWIG_arg_fail(2)) SWIG_fail;
29833 if (arg2 == NULL) {
29834 SWIG_null_ref("wxCursor");
29835 }
29836 if (SWIG_arg_fail(2)) SWIG_fail;
29837 }
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29841
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 {
29846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29847 }
29848 return resultobj;
29849 fail:
29850 return NULL;
29851 }
29852
29853
29854 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29855 PyObject *resultobj;
29856 wxWindow *arg1 = (wxWindow *) 0 ;
29857 wxCursor result;
29858 PyObject * obj0 = 0 ;
29859 char *kwnames[] = {
29860 (char *) "self", NULL
29861 };
29862
29863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29865 if (SWIG_arg_fail(1)) SWIG_fail;
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 result = (arg1)->GetCursor();
29869
29870 wxPyEndAllowThreads(__tstate);
29871 if (PyErr_Occurred()) SWIG_fail;
29872 }
29873 {
29874 wxCursor * resultptr;
29875 resultptr = new wxCursor((wxCursor &)(result));
29876 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29877 }
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29885 PyObject *resultobj;
29886 wxWindow *arg1 = (wxWindow *) 0 ;
29887 wxFont *arg2 = 0 ;
29888 bool result;
29889 PyObject * obj0 = 0 ;
29890 PyObject * obj1 = 0 ;
29891 char *kwnames[] = {
29892 (char *) "self",(char *) "font", NULL
29893 };
29894
29895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29897 if (SWIG_arg_fail(1)) SWIG_fail;
29898 {
29899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29900 if (SWIG_arg_fail(2)) SWIG_fail;
29901 if (arg2 == NULL) {
29902 SWIG_null_ref("wxFont");
29903 }
29904 if (SWIG_arg_fail(2)) SWIG_fail;
29905 }
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29909
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 {
29914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29915 }
29916 return resultobj;
29917 fail:
29918 return NULL;
29919 }
29920
29921
29922 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29923 PyObject *resultobj;
29924 wxWindow *arg1 = (wxWindow *) 0 ;
29925 wxFont *arg2 = 0 ;
29926 PyObject * obj0 = 0 ;
29927 PyObject * obj1 = 0 ;
29928 char *kwnames[] = {
29929 (char *) "self",(char *) "font", NULL
29930 };
29931
29932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(1)) SWIG_fail;
29935 {
29936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29937 if (SWIG_arg_fail(2)) SWIG_fail;
29938 if (arg2 == NULL) {
29939 SWIG_null_ref("wxFont");
29940 }
29941 if (SWIG_arg_fail(2)) SWIG_fail;
29942 }
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 (arg1)->SetOwnFont((wxFont const &)*arg2);
29946
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 Py_INCREF(Py_None); resultobj = Py_None;
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29958 PyObject *resultobj;
29959 wxWindow *arg1 = (wxWindow *) 0 ;
29960 wxFont result;
29961 PyObject * obj0 = 0 ;
29962 char *kwnames[] = {
29963 (char *) "self", NULL
29964 };
29965
29966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29968 if (SWIG_arg_fail(1)) SWIG_fail;
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 result = (arg1)->GetFont();
29972
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 {
29977 wxFont * resultptr;
29978 resultptr = new wxFont((wxFont &)(result));
29979 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxWindow *arg1 = (wxWindow *) 0 ;
29990 wxCaret *arg2 = (wxCaret *) 0 ;
29991 PyObject * obj0 = 0 ;
29992 PyObject * obj1 = 0 ;
29993 char *kwnames[] = {
29994 (char *) "self",(char *) "caret", NULL
29995 };
29996
29997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29999 if (SWIG_arg_fail(1)) SWIG_fail;
30000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(2)) SWIG_fail;
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 (arg1)->SetCaret(arg2);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 Py_INCREF(Py_None); resultobj = Py_None;
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj;
30018 wxWindow *arg1 = (wxWindow *) 0 ;
30019 wxCaret *result;
30020 PyObject * obj0 = 0 ;
30021 char *kwnames[] = {
30022 (char *) "self", NULL
30023 };
30024
30025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(1)) SWIG_fail;
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30036 return resultobj;
30037 fail:
30038 return NULL;
30039 }
30040
30041
30042 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30043 PyObject *resultobj;
30044 wxWindow *arg1 = (wxWindow *) 0 ;
30045 int result;
30046 PyObject * obj0 = 0 ;
30047 char *kwnames[] = {
30048 (char *) "self", NULL
30049 };
30050
30051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30053 if (SWIG_arg_fail(1)) SWIG_fail;
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30057
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 {
30062 resultobj = SWIG_From_int((int)(result));
30063 }
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30071 PyObject *resultobj;
30072 wxWindow *arg1 = (wxWindow *) 0 ;
30073 int result;
30074 PyObject * obj0 = 0 ;
30075 char *kwnames[] = {
30076 (char *) "self", NULL
30077 };
30078
30079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30081 if (SWIG_arg_fail(1)) SWIG_fail;
30082 {
30083 PyThreadState* __tstate = wxPyBeginAllowThreads();
30084 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30085
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 {
30090 resultobj = SWIG_From_int((int)(result));
30091 }
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj;
30100 wxWindow *arg1 = (wxWindow *) 0 ;
30101 wxString *arg2 = 0 ;
30102 int *arg3 = (int *) 0 ;
30103 int *arg4 = (int *) 0 ;
30104 bool temp2 = false ;
30105 int temp3 ;
30106 int res3 = 0 ;
30107 int temp4 ;
30108 int res4 = 0 ;
30109 PyObject * obj0 = 0 ;
30110 PyObject * obj1 = 0 ;
30111 char *kwnames[] = {
30112 (char *) "self",(char *) "string", NULL
30113 };
30114
30115 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30116 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30119 if (SWIG_arg_fail(1)) SWIG_fail;
30120 {
30121 arg2 = wxString_in_helper(obj1);
30122 if (arg2 == NULL) SWIG_fail;
30123 temp2 = true;
30124 }
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 Py_INCREF(Py_None); resultobj = Py_None;
30133 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30134 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30135 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30136 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30137 {
30138 if (temp2)
30139 delete arg2;
30140 }
30141 return resultobj;
30142 fail:
30143 {
30144 if (temp2)
30145 delete arg2;
30146 }
30147 return NULL;
30148 }
30149
30150
30151 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30152 PyObject *resultobj;
30153 wxWindow *arg1 = (wxWindow *) 0 ;
30154 wxString *arg2 = 0 ;
30155 int *arg3 = (int *) 0 ;
30156 int *arg4 = (int *) 0 ;
30157 int *arg5 = (int *) 0 ;
30158 int *arg6 = (int *) 0 ;
30159 wxFont *arg7 = (wxFont *) NULL ;
30160 bool temp2 = false ;
30161 int temp3 ;
30162 int res3 = 0 ;
30163 int temp4 ;
30164 int res4 = 0 ;
30165 int temp5 ;
30166 int res5 = 0 ;
30167 int temp6 ;
30168 int res6 = 0 ;
30169 PyObject * obj0 = 0 ;
30170 PyObject * obj1 = 0 ;
30171 PyObject * obj2 = 0 ;
30172 char *kwnames[] = {
30173 (char *) "self",(char *) "string",(char *) "font", NULL
30174 };
30175
30176 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30177 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30178 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30179 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(1)) SWIG_fail;
30183 {
30184 arg2 = wxString_in_helper(obj1);
30185 if (arg2 == NULL) SWIG_fail;
30186 temp2 = true;
30187 }
30188 if (obj2) {
30189 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30190 if (SWIG_arg_fail(7)) SWIG_fail;
30191 }
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30195
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 Py_INCREF(Py_None); resultobj = Py_None;
30200 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30201 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30202 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30203 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30204 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30205 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30206 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30207 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30208 {
30209 if (temp2)
30210 delete arg2;
30211 }
30212 return resultobj;
30213 fail:
30214 {
30215 if (temp2)
30216 delete arg2;
30217 }
30218 return NULL;
30219 }
30220
30221
30222 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30223 PyObject *resultobj;
30224 wxWindow *arg1 = (wxWindow *) 0 ;
30225 int *arg2 = (int *) 0 ;
30226 int *arg3 = (int *) 0 ;
30227 int temp2 ;
30228 int res2 = 0 ;
30229 int temp3 ;
30230 int res3 = 0 ;
30231 PyObject * obj0 = 0 ;
30232 PyObject * obj1 = 0 ;
30233 PyObject * obj2 = 0 ;
30234 char *kwnames[] = {
30235 (char *) "self",(char *) "x",(char *) "y", NULL
30236 };
30237
30238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(1)) SWIG_fail;
30241 {
30242 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30243 temp2 = SWIG_As_int(obj1);
30244 if (SWIG_arg_fail(2)) SWIG_fail;
30245 arg2 = &temp2;
30246 res2 = SWIG_NEWOBJ;
30247 }
30248 }
30249 {
30250 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30251 temp3 = SWIG_As_int(obj2);
30252 if (SWIG_arg_fail(3)) SWIG_fail;
30253 arg3 = &temp3;
30254 res3 = SWIG_NEWOBJ;
30255 }
30256 }
30257 {
30258 PyThreadState* __tstate = wxPyBeginAllowThreads();
30259 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30260
30261 wxPyEndAllowThreads(__tstate);
30262 if (PyErr_Occurred()) SWIG_fail;
30263 }
30264 Py_INCREF(Py_None); resultobj = Py_None;
30265 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30266 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30267 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30268 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj;
30277 wxWindow *arg1 = (wxWindow *) 0 ;
30278 int *arg2 = (int *) 0 ;
30279 int *arg3 = (int *) 0 ;
30280 int temp2 ;
30281 int res2 = 0 ;
30282 int temp3 ;
30283 int res3 = 0 ;
30284 PyObject * obj0 = 0 ;
30285 PyObject * obj1 = 0 ;
30286 PyObject * obj2 = 0 ;
30287 char *kwnames[] = {
30288 (char *) "self",(char *) "x",(char *) "y", NULL
30289 };
30290
30291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30293 if (SWIG_arg_fail(1)) SWIG_fail;
30294 {
30295 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30296 temp2 = SWIG_As_int(obj1);
30297 if (SWIG_arg_fail(2)) SWIG_fail;
30298 arg2 = &temp2;
30299 res2 = SWIG_NEWOBJ;
30300 }
30301 }
30302 {
30303 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30304 temp3 = SWIG_As_int(obj2);
30305 if (SWIG_arg_fail(3)) SWIG_fail;
30306 arg3 = &temp3;
30307 res3 = SWIG_NEWOBJ;
30308 }
30309 }
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30313
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 Py_INCREF(Py_None); resultobj = Py_None;
30318 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30319 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30320 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30321 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj;
30330 wxWindow *arg1 = (wxWindow *) 0 ;
30331 wxPoint *arg2 = 0 ;
30332 wxPoint result;
30333 wxPoint temp2 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char *kwnames[] = {
30337 (char *) "self",(char *) "pt", NULL
30338 };
30339
30340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30342 if (SWIG_arg_fail(1)) SWIG_fail;
30343 {
30344 arg2 = &temp2;
30345 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30346 }
30347 {
30348 PyThreadState* __tstate = wxPyBeginAllowThreads();
30349 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30350
30351 wxPyEndAllowThreads(__tstate);
30352 if (PyErr_Occurred()) SWIG_fail;
30353 }
30354 {
30355 wxPoint * resultptr;
30356 resultptr = new wxPoint((wxPoint &)(result));
30357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30358 }
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj;
30367 wxWindow *arg1 = (wxWindow *) 0 ;
30368 wxPoint *arg2 = 0 ;
30369 wxPoint result;
30370 wxPoint temp2 ;
30371 PyObject * obj0 = 0 ;
30372 PyObject * obj1 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self",(char *) "pt", NULL
30375 };
30376
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 {
30381 arg2 = &temp2;
30382 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30383 }
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30387
30388 wxPyEndAllowThreads(__tstate);
30389 if (PyErr_Occurred()) SWIG_fail;
30390 }
30391 {
30392 wxPoint * resultptr;
30393 resultptr = new wxPoint((wxPoint &)(result));
30394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30395 }
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxWindow *arg1 = (wxWindow *) 0 ;
30405 int arg2 ;
30406 int arg3 ;
30407 wxHitTest result;
30408 PyObject * obj0 = 0 ;
30409 PyObject * obj1 = 0 ;
30410 PyObject * obj2 = 0 ;
30411 char *kwnames[] = {
30412 (char *) "self",(char *) "x",(char *) "y", NULL
30413 };
30414
30415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30417 if (SWIG_arg_fail(1)) SWIG_fail;
30418 {
30419 arg2 = (int)(SWIG_As_int(obj1));
30420 if (SWIG_arg_fail(2)) SWIG_fail;
30421 }
30422 {
30423 arg3 = (int)(SWIG_As_int(obj2));
30424 if (SWIG_arg_fail(3)) SWIG_fail;
30425 }
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30429
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_From_int((result));
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 wxPoint *arg2 = 0 ;
30444 wxHitTest result;
30445 wxPoint temp2 ;
30446 PyObject * obj0 = 0 ;
30447 PyObject * obj1 = 0 ;
30448 char *kwnames[] = {
30449 (char *) "self",(char *) "pt", NULL
30450 };
30451
30452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30454 if (SWIG_arg_fail(1)) SWIG_fail;
30455 {
30456 arg2 = &temp2;
30457 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30458 }
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30462
30463 wxPyEndAllowThreads(__tstate);
30464 if (PyErr_Occurred()) SWIG_fail;
30465 }
30466 resultobj = SWIG_From_int((result));
30467 return resultobj;
30468 fail:
30469 return NULL;
30470 }
30471
30472
30473 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30474 PyObject *resultobj;
30475 wxWindow *arg1 = (wxWindow *) 0 ;
30476 long arg2 ;
30477 wxBorder result;
30478 PyObject * obj0 = 0 ;
30479 PyObject * obj1 = 0 ;
30480
30481 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30483 if (SWIG_arg_fail(1)) SWIG_fail;
30484 {
30485 arg2 = (long)(SWIG_As_long(obj1));
30486 if (SWIG_arg_fail(2)) SWIG_fail;
30487 }
30488 {
30489 PyThreadState* __tstate = wxPyBeginAllowThreads();
30490 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30491
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_From_int((result));
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30503 PyObject *resultobj;
30504 wxWindow *arg1 = (wxWindow *) 0 ;
30505 wxBorder result;
30506 PyObject * obj0 = 0 ;
30507
30508 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30510 if (SWIG_arg_fail(1)) SWIG_fail;
30511 {
30512 PyThreadState* __tstate = wxPyBeginAllowThreads();
30513 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30514
30515 wxPyEndAllowThreads(__tstate);
30516 if (PyErr_Occurred()) SWIG_fail;
30517 }
30518 resultobj = SWIG_From_int((result));
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30526 int argc;
30527 PyObject *argv[3];
30528 int ii;
30529
30530 argc = PyObject_Length(args);
30531 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30532 argv[ii] = PyTuple_GetItem(args,ii);
30533 }
30534 if (argc == 1) {
30535 int _v;
30536 {
30537 void *ptr;
30538 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30539 _v = 0;
30540 PyErr_Clear();
30541 } else {
30542 _v = 1;
30543 }
30544 }
30545 if (_v) {
30546 return _wrap_Window_GetBorder__SWIG_1(self,args);
30547 }
30548 }
30549 if (argc == 2) {
30550 int _v;
30551 {
30552 void *ptr;
30553 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30554 _v = 0;
30555 PyErr_Clear();
30556 } else {
30557 _v = 1;
30558 }
30559 }
30560 if (_v) {
30561 _v = SWIG_Check_long(argv[1]);
30562 if (_v) {
30563 return _wrap_Window_GetBorder__SWIG_0(self,args);
30564 }
30565 }
30566 }
30567
30568 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30569 return NULL;
30570 }
30571
30572
30573 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30574 PyObject *resultobj;
30575 wxWindow *arg1 = (wxWindow *) 0 ;
30576 long arg2 = (long) wxUPDATE_UI_NONE ;
30577 PyObject * obj0 = 0 ;
30578 PyObject * obj1 = 0 ;
30579 char *kwnames[] = {
30580 (char *) "self",(char *) "flags", NULL
30581 };
30582
30583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30585 if (SWIG_arg_fail(1)) SWIG_fail;
30586 if (obj1) {
30587 {
30588 arg2 = (long)(SWIG_As_long(obj1));
30589 if (SWIG_arg_fail(2)) SWIG_fail;
30590 }
30591 }
30592 {
30593 PyThreadState* __tstate = wxPyBeginAllowThreads();
30594 (arg1)->UpdateWindowUI(arg2);
30595
30596 wxPyEndAllowThreads(__tstate);
30597 if (PyErr_Occurred()) SWIG_fail;
30598 }
30599 Py_INCREF(Py_None); resultobj = Py_None;
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj;
30608 wxWindow *arg1 = (wxWindow *) 0 ;
30609 wxMenu *arg2 = (wxMenu *) 0 ;
30610 int arg3 = (int) -1 ;
30611 int arg4 = (int) -1 ;
30612 bool result;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 PyObject * obj2 = 0 ;
30616 PyObject * obj3 = 0 ;
30617 char *kwnames[] = {
30618 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30619 };
30620
30621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30623 if (SWIG_arg_fail(1)) SWIG_fail;
30624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30625 if (SWIG_arg_fail(2)) SWIG_fail;
30626 if (obj2) {
30627 {
30628 arg3 = (int)(SWIG_As_int(obj2));
30629 if (SWIG_arg_fail(3)) SWIG_fail;
30630 }
30631 }
30632 if (obj3) {
30633 {
30634 arg4 = (int)(SWIG_As_int(obj3));
30635 if (SWIG_arg_fail(4)) SWIG_fail;
30636 }
30637 }
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30641
30642 wxPyEndAllowThreads(__tstate);
30643 if (PyErr_Occurred()) SWIG_fail;
30644 }
30645 {
30646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30647 }
30648 return resultobj;
30649 fail:
30650 return NULL;
30651 }
30652
30653
30654 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30655 PyObject *resultobj;
30656 wxWindow *arg1 = (wxWindow *) 0 ;
30657 wxMenu *arg2 = (wxMenu *) 0 ;
30658 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30659 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30660 bool result;
30661 wxPoint temp3 ;
30662 PyObject * obj0 = 0 ;
30663 PyObject * obj1 = 0 ;
30664 PyObject * obj2 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "self",(char *) "menu",(char *) "pos", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30673 if (SWIG_arg_fail(2)) SWIG_fail;
30674 if (obj2) {
30675 {
30676 arg3 = &temp3;
30677 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30678 }
30679 }
30680 {
30681 PyThreadState* __tstate = wxPyBeginAllowThreads();
30682 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30683
30684 wxPyEndAllowThreads(__tstate);
30685 if (PyErr_Occurred()) SWIG_fail;
30686 }
30687 {
30688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30689 }
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30697 PyObject *resultobj;
30698 wxWindow *arg1 = (wxWindow *) 0 ;
30699 long result;
30700 PyObject * obj0 = 0 ;
30701 char *kwnames[] = {
30702 (char *) "self", NULL
30703 };
30704
30705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(1)) SWIG_fail;
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (long)wxWindow_GetHandle(arg1);
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 {
30716 resultobj = SWIG_From_long((long)(result));
30717 }
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj;
30726 wxWindow *arg1 = (wxWindow *) 0 ;
30727 long arg2 ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 char *kwnames[] = {
30731 (char *) "self",(char *) "handle", NULL
30732 };
30733
30734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30736 if (SWIG_arg_fail(1)) SWIG_fail;
30737 {
30738 arg2 = (long)(SWIG_As_long(obj1));
30739 if (SWIG_arg_fail(2)) SWIG_fail;
30740 }
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 wxWindow_AssociateHandle(arg1,arg2);
30744
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 Py_INCREF(Py_None); resultobj = Py_None;
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30756 PyObject *resultobj;
30757 wxWindow *arg1 = (wxWindow *) 0 ;
30758 PyObject * obj0 = 0 ;
30759 char *kwnames[] = {
30760 (char *) "self", NULL
30761 };
30762
30763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30765 if (SWIG_arg_fail(1)) SWIG_fail;
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 (arg1)->DissociateHandle();
30769
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 Py_INCREF(Py_None); resultobj = Py_None;
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxPaintEvent *arg2 = 0 ;
30784 PyObject * obj0 = 0 ;
30785 PyObject * obj1 = 0 ;
30786 char *kwnames[] = {
30787 (char *) "self",(char *) "event", NULL
30788 };
30789
30790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30792 if (SWIG_arg_fail(1)) SWIG_fail;
30793 {
30794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30795 if (SWIG_arg_fail(2)) SWIG_fail;
30796 if (arg2 == NULL) {
30797 SWIG_null_ref("wxPaintEvent");
30798 }
30799 if (SWIG_arg_fail(2)) SWIG_fail;
30800 }
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 (arg1)->OnPaint(*arg2);
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 Py_INCREF(Py_None); resultobj = Py_None;
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 int arg2 ;
30819 bool result;
30820 PyObject * obj0 = 0 ;
30821 PyObject * obj1 = 0 ;
30822 char *kwnames[] = {
30823 (char *) "self",(char *) "orient", NULL
30824 };
30825
30826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30828 if (SWIG_arg_fail(1)) SWIG_fail;
30829 {
30830 arg2 = (int)(SWIG_As_int(obj1));
30831 if (SWIG_arg_fail(2)) SWIG_fail;
30832 }
30833 {
30834 PyThreadState* __tstate = wxPyBeginAllowThreads();
30835 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30836
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 {
30841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30850 PyObject *resultobj;
30851 wxWindow *arg1 = (wxWindow *) 0 ;
30852 int arg2 ;
30853 int arg3 ;
30854 int arg4 ;
30855 int arg5 ;
30856 bool arg6 = (bool) true ;
30857 PyObject * obj0 = 0 ;
30858 PyObject * obj1 = 0 ;
30859 PyObject * obj2 = 0 ;
30860 PyObject * obj3 = 0 ;
30861 PyObject * obj4 = 0 ;
30862 PyObject * obj5 = 0 ;
30863 char *kwnames[] = {
30864 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30865 };
30866
30867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30869 if (SWIG_arg_fail(1)) SWIG_fail;
30870 {
30871 arg2 = (int)(SWIG_As_int(obj1));
30872 if (SWIG_arg_fail(2)) SWIG_fail;
30873 }
30874 {
30875 arg3 = (int)(SWIG_As_int(obj2));
30876 if (SWIG_arg_fail(3)) SWIG_fail;
30877 }
30878 {
30879 arg4 = (int)(SWIG_As_int(obj3));
30880 if (SWIG_arg_fail(4)) SWIG_fail;
30881 }
30882 {
30883 arg5 = (int)(SWIG_As_int(obj4));
30884 if (SWIG_arg_fail(5)) SWIG_fail;
30885 }
30886 if (obj5) {
30887 {
30888 arg6 = (bool)(SWIG_As_bool(obj5));
30889 if (SWIG_arg_fail(6)) SWIG_fail;
30890 }
30891 }
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30895
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 Py_INCREF(Py_None); resultobj = Py_None;
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 int arg2 ;
30910 int arg3 ;
30911 bool arg4 = (bool) true ;
30912 PyObject * obj0 = 0 ;
30913 PyObject * obj1 = 0 ;
30914 PyObject * obj2 = 0 ;
30915 PyObject * obj3 = 0 ;
30916 char *kwnames[] = {
30917 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30918 };
30919
30920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30922 if (SWIG_arg_fail(1)) SWIG_fail;
30923 {
30924 arg2 = (int)(SWIG_As_int(obj1));
30925 if (SWIG_arg_fail(2)) SWIG_fail;
30926 }
30927 {
30928 arg3 = (int)(SWIG_As_int(obj2));
30929 if (SWIG_arg_fail(3)) SWIG_fail;
30930 }
30931 if (obj3) {
30932 {
30933 arg4 = (bool)(SWIG_As_bool(obj3));
30934 if (SWIG_arg_fail(4)) SWIG_fail;
30935 }
30936 }
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 (arg1)->SetScrollPos(arg2,arg3,arg4);
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 Py_INCREF(Py_None); resultobj = Py_None;
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30952 PyObject *resultobj;
30953 wxWindow *arg1 = (wxWindow *) 0 ;
30954 int arg2 ;
30955 int result;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 char *kwnames[] = {
30959 (char *) "self",(char *) "orientation", NULL
30960 };
30961
30962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30964 if (SWIG_arg_fail(1)) SWIG_fail;
30965 {
30966 arg2 = (int)(SWIG_As_int(obj1));
30967 if (SWIG_arg_fail(2)) SWIG_fail;
30968 }
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30972
30973 wxPyEndAllowThreads(__tstate);
30974 if (PyErr_Occurred()) SWIG_fail;
30975 }
30976 {
30977 resultobj = SWIG_From_int((int)(result));
30978 }
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 int arg2 ;
30989 int result;
30990 PyObject * obj0 = 0 ;
30991 PyObject * obj1 = 0 ;
30992 char *kwnames[] = {
30993 (char *) "self",(char *) "orientation", NULL
30994 };
30995
30996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30998 if (SWIG_arg_fail(1)) SWIG_fail;
30999 {
31000 arg2 = (int)(SWIG_As_int(obj1));
31001 if (SWIG_arg_fail(2)) SWIG_fail;
31002 }
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 {
31011 resultobj = SWIG_From_int((int)(result));
31012 }
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31020 PyObject *resultobj;
31021 wxWindow *arg1 = (wxWindow *) 0 ;
31022 int arg2 ;
31023 int result;
31024 PyObject * obj0 = 0 ;
31025 PyObject * obj1 = 0 ;
31026 char *kwnames[] = {
31027 (char *) "self",(char *) "orientation", NULL
31028 };
31029
31030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31032 if (SWIG_arg_fail(1)) SWIG_fail;
31033 {
31034 arg2 = (int)(SWIG_As_int(obj1));
31035 if (SWIG_arg_fail(2)) SWIG_fail;
31036 }
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31040
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 {
31045 resultobj = SWIG_From_int((int)(result));
31046 }
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31054 PyObject *resultobj;
31055 wxWindow *arg1 = (wxWindow *) 0 ;
31056 int arg2 ;
31057 int arg3 ;
31058 wxRect *arg4 = (wxRect *) NULL ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 PyObject * obj3 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(1)) SWIG_fail;
31070 {
31071 arg2 = (int)(SWIG_As_int(obj1));
31072 if (SWIG_arg_fail(2)) SWIG_fail;
31073 }
31074 {
31075 arg3 = (int)(SWIG_As_int(obj2));
31076 if (SWIG_arg_fail(3)) SWIG_fail;
31077 }
31078 if (obj3) {
31079 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31080 if (SWIG_arg_fail(4)) SWIG_fail;
31081 }
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31085
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 Py_INCREF(Py_None); resultobj = Py_None;
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31097 PyObject *resultobj;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 int arg2 ;
31100 bool result;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 char *kwnames[] = {
31104 (char *) "self",(char *) "lines", NULL
31105 };
31106
31107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31109 if (SWIG_arg_fail(1)) SWIG_fail;
31110 {
31111 arg2 = (int)(SWIG_As_int(obj1));
31112 if (SWIG_arg_fail(2)) SWIG_fail;
31113 }
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 result = (bool)(arg1)->ScrollLines(arg2);
31117
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 {
31122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31123 }
31124 return resultobj;
31125 fail:
31126 return NULL;
31127 }
31128
31129
31130 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31131 PyObject *resultobj;
31132 wxWindow *arg1 = (wxWindow *) 0 ;
31133 int arg2 ;
31134 bool result;
31135 PyObject * obj0 = 0 ;
31136 PyObject * obj1 = 0 ;
31137 char *kwnames[] = {
31138 (char *) "self",(char *) "pages", NULL
31139 };
31140
31141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31143 if (SWIG_arg_fail(1)) SWIG_fail;
31144 {
31145 arg2 = (int)(SWIG_As_int(obj1));
31146 if (SWIG_arg_fail(2)) SWIG_fail;
31147 }
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 result = (bool)(arg1)->ScrollPages(arg2);
31151
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 {
31156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31157 }
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 bool result;
31168 PyObject * obj0 = 0 ;
31169 char *kwnames[] = {
31170 (char *) "self", NULL
31171 };
31172
31173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31175 if (SWIG_arg_fail(1)) SWIG_fail;
31176 {
31177 PyThreadState* __tstate = wxPyBeginAllowThreads();
31178 result = (bool)(arg1)->LineUp();
31179
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 {
31184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31185 }
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj;
31194 wxWindow *arg1 = (wxWindow *) 0 ;
31195 bool result;
31196 PyObject * obj0 = 0 ;
31197 char *kwnames[] = {
31198 (char *) "self", NULL
31199 };
31200
31201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31203 if (SWIG_arg_fail(1)) SWIG_fail;
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 result = (bool)(arg1)->LineDown();
31207
31208 wxPyEndAllowThreads(__tstate);
31209 if (PyErr_Occurred()) SWIG_fail;
31210 }
31211 {
31212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31213 }
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31221 PyObject *resultobj;
31222 wxWindow *arg1 = (wxWindow *) 0 ;
31223 bool result;
31224 PyObject * obj0 = 0 ;
31225 char *kwnames[] = {
31226 (char *) "self", NULL
31227 };
31228
31229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31231 if (SWIG_arg_fail(1)) SWIG_fail;
31232 {
31233 PyThreadState* __tstate = wxPyBeginAllowThreads();
31234 result = (bool)(arg1)->PageUp();
31235
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 {
31240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31241 }
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 bool result;
31252 PyObject * obj0 = 0 ;
31253 char *kwnames[] = {
31254 (char *) "self", NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31259 if (SWIG_arg_fail(1)) SWIG_fail;
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = (bool)(arg1)->PageDown();
31263
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 {
31268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31269 }
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj;
31278 wxWindow *arg1 = (wxWindow *) 0 ;
31279 wxString *arg2 = 0 ;
31280 bool temp2 = false ;
31281 PyObject * obj0 = 0 ;
31282 PyObject * obj1 = 0 ;
31283 char *kwnames[] = {
31284 (char *) "self",(char *) "text", NULL
31285 };
31286
31287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31289 if (SWIG_arg_fail(1)) SWIG_fail;
31290 {
31291 arg2 = wxString_in_helper(obj1);
31292 if (arg2 == NULL) SWIG_fail;
31293 temp2 = true;
31294 }
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 (arg1)->SetHelpText((wxString const &)*arg2);
31298
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 Py_INCREF(Py_None); resultobj = Py_None;
31303 {
31304 if (temp2)
31305 delete arg2;
31306 }
31307 return resultobj;
31308 fail:
31309 {
31310 if (temp2)
31311 delete arg2;
31312 }
31313 return NULL;
31314 }
31315
31316
31317 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj;
31319 wxWindow *arg1 = (wxWindow *) 0 ;
31320 wxString *arg2 = 0 ;
31321 bool temp2 = false ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char *kwnames[] = {
31325 (char *) "self",(char *) "text", NULL
31326 };
31327
31328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31330 if (SWIG_arg_fail(1)) SWIG_fail;
31331 {
31332 arg2 = wxString_in_helper(obj1);
31333 if (arg2 == NULL) SWIG_fail;
31334 temp2 = true;
31335 }
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31339
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 Py_INCREF(Py_None); resultobj = Py_None;
31344 {
31345 if (temp2)
31346 delete arg2;
31347 }
31348 return resultobj;
31349 fail:
31350 {
31351 if (temp2)
31352 delete arg2;
31353 }
31354 return NULL;
31355 }
31356
31357
31358 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj;
31360 wxWindow *arg1 = (wxWindow *) 0 ;
31361 wxString result;
31362 PyObject * obj0 = 0 ;
31363 char *kwnames[] = {
31364 (char *) "self", NULL
31365 };
31366
31367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",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 = ((wxWindow const *)arg1)->GetHelpText();
31373
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 {
31378 #if wxUSE_UNICODE
31379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31380 #else
31381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31382 #endif
31383 }
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31391 PyObject *resultobj;
31392 wxWindow *arg1 = (wxWindow *) 0 ;
31393 wxString *arg2 = 0 ;
31394 bool temp2 = false ;
31395 PyObject * obj0 = 0 ;
31396 PyObject * obj1 = 0 ;
31397 char *kwnames[] = {
31398 (char *) "self",(char *) "tip", NULL
31399 };
31400
31401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31403 if (SWIG_arg_fail(1)) SWIG_fail;
31404 {
31405 arg2 = wxString_in_helper(obj1);
31406 if (arg2 == NULL) SWIG_fail;
31407 temp2 = true;
31408 }
31409 {
31410 PyThreadState* __tstate = wxPyBeginAllowThreads();
31411 (arg1)->SetToolTip((wxString const &)*arg2);
31412
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 Py_INCREF(Py_None); resultobj = Py_None;
31417 {
31418 if (temp2)
31419 delete arg2;
31420 }
31421 return resultobj;
31422 fail:
31423 {
31424 if (temp2)
31425 delete arg2;
31426 }
31427 return NULL;
31428 }
31429
31430
31431 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 wxToolTip *arg2 = (wxToolTip *) 0 ;
31435 PyObject * obj0 = 0 ;
31436 PyObject * obj1 = 0 ;
31437 char *kwnames[] = {
31438 (char *) "self",(char *) "tip", NULL
31439 };
31440
31441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31443 if (SWIG_arg_fail(1)) SWIG_fail;
31444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31445 if (SWIG_arg_fail(2)) SWIG_fail;
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 (arg1)->SetToolTip(arg2);
31449
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 Py_INCREF(Py_None); resultobj = Py_None;
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj;
31462 wxWindow *arg1 = (wxWindow *) 0 ;
31463 wxToolTip *result;
31464 PyObject * obj0 = 0 ;
31465 char *kwnames[] = {
31466 (char *) "self", NULL
31467 };
31468
31469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31471 if (SWIG_arg_fail(1)) SWIG_fail;
31472 {
31473 PyThreadState* __tstate = wxPyBeginAllowThreads();
31474 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31475
31476 wxPyEndAllowThreads(__tstate);
31477 if (PyErr_Occurred()) SWIG_fail;
31478 }
31479 {
31480 resultobj = wxPyMake_wxObject(result, 0);
31481 }
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31489 PyObject *resultobj;
31490 wxWindow *arg1 = (wxWindow *) 0 ;
31491 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31492 PyObject * obj0 = 0 ;
31493 PyObject * obj1 = 0 ;
31494 char *kwnames[] = {
31495 (char *) "self",(char *) "dropTarget", NULL
31496 };
31497
31498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31500 if (SWIG_arg_fail(1)) SWIG_fail;
31501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31502 if (SWIG_arg_fail(2)) SWIG_fail;
31503 {
31504 PyThreadState* __tstate = wxPyBeginAllowThreads();
31505 (arg1)->SetDropTarget(arg2);
31506
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 Py_INCREF(Py_None); resultobj = Py_None;
31511 return resultobj;
31512 fail:
31513 return NULL;
31514 }
31515
31516
31517 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31518 PyObject *resultobj;
31519 wxWindow *arg1 = (wxWindow *) 0 ;
31520 wxPyDropTarget *result;
31521 PyObject * obj0 = 0 ;
31522 char *kwnames[] = {
31523 (char *) "self", NULL
31524 };
31525
31526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31528 if (SWIG_arg_fail(1)) SWIG_fail;
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31532
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 bool arg2 ;
31547 PyObject * obj0 = 0 ;
31548 PyObject * obj1 = 0 ;
31549 char *kwnames[] = {
31550 (char *) "self",(char *) "accept", NULL
31551 };
31552
31553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31555 if (SWIG_arg_fail(1)) SWIG_fail;
31556 {
31557 arg2 = (bool)(SWIG_As_bool(obj1));
31558 if (SWIG_arg_fail(2)) SWIG_fail;
31559 }
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 (arg1)->DragAcceptFiles(arg2);
31563
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 Py_INCREF(Py_None); resultobj = Py_None;
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj;
31576 wxWindow *arg1 = (wxWindow *) 0 ;
31577 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31578 PyObject * obj0 = 0 ;
31579 PyObject * obj1 = 0 ;
31580 char *kwnames[] = {
31581 (char *) "self",(char *) "constraints", NULL
31582 };
31583
31584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31586 if (SWIG_arg_fail(1)) SWIG_fail;
31587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31588 if (SWIG_arg_fail(2)) SWIG_fail;
31589 {
31590 PyThreadState* __tstate = wxPyBeginAllowThreads();
31591 (arg1)->SetConstraints(arg2);
31592
31593 wxPyEndAllowThreads(__tstate);
31594 if (PyErr_Occurred()) SWIG_fail;
31595 }
31596 Py_INCREF(Py_None); resultobj = Py_None;
31597 return resultobj;
31598 fail:
31599 return NULL;
31600 }
31601
31602
31603 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31604 PyObject *resultobj;
31605 wxWindow *arg1 = (wxWindow *) 0 ;
31606 wxLayoutConstraints *result;
31607 PyObject * obj0 = 0 ;
31608 char *kwnames[] = {
31609 (char *) "self", NULL
31610 };
31611
31612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31614 if (SWIG_arg_fail(1)) SWIG_fail;
31615 {
31616 PyThreadState* __tstate = wxPyBeginAllowThreads();
31617 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31618
31619 wxPyEndAllowThreads(__tstate);
31620 if (PyErr_Occurred()) SWIG_fail;
31621 }
31622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31630 PyObject *resultobj;
31631 wxWindow *arg1 = (wxWindow *) 0 ;
31632 bool arg2 ;
31633 PyObject * obj0 = 0 ;
31634 PyObject * obj1 = 0 ;
31635 char *kwnames[] = {
31636 (char *) "self",(char *) "autoLayout", NULL
31637 };
31638
31639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31641 if (SWIG_arg_fail(1)) SWIG_fail;
31642 {
31643 arg2 = (bool)(SWIG_As_bool(obj1));
31644 if (SWIG_arg_fail(2)) SWIG_fail;
31645 }
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 (arg1)->SetAutoLayout(arg2);
31649
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 Py_INCREF(Py_None); resultobj = Py_None;
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31661 PyObject *resultobj;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 bool result;
31664 PyObject * obj0 = 0 ;
31665 char *kwnames[] = {
31666 (char *) "self", NULL
31667 };
31668
31669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31671 if (SWIG_arg_fail(1)) SWIG_fail;
31672 {
31673 PyThreadState* __tstate = wxPyBeginAllowThreads();
31674 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31675
31676 wxPyEndAllowThreads(__tstate);
31677 if (PyErr_Occurred()) SWIG_fail;
31678 }
31679 {
31680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31681 }
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31689 PyObject *resultobj;
31690 wxWindow *arg1 = (wxWindow *) 0 ;
31691 bool result;
31692 PyObject * obj0 = 0 ;
31693 char *kwnames[] = {
31694 (char *) "self", NULL
31695 };
31696
31697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31699 if (SWIG_arg_fail(1)) SWIG_fail;
31700 {
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 result = (bool)(arg1)->Layout();
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxSizer *arg2 = (wxSizer *) 0 ;
31720 bool arg3 = (bool) true ;
31721 PyObject * obj0 = 0 ;
31722 PyObject * obj1 = 0 ;
31723 PyObject * obj2 = 0 ;
31724 char *kwnames[] = {
31725 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31726 };
31727
31728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31730 if (SWIG_arg_fail(1)) SWIG_fail;
31731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31732 if (SWIG_arg_fail(2)) SWIG_fail;
31733 if (obj2) {
31734 {
31735 arg3 = (bool)(SWIG_As_bool(obj2));
31736 if (SWIG_arg_fail(3)) SWIG_fail;
31737 }
31738 }
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 (arg1)->SetSizer(arg2,arg3);
31742
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 Py_INCREF(Py_None); resultobj = Py_None;
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31754 PyObject *resultobj;
31755 wxWindow *arg1 = (wxWindow *) 0 ;
31756 wxSizer *arg2 = (wxSizer *) 0 ;
31757 bool arg3 = (bool) true ;
31758 PyObject * obj0 = 0 ;
31759 PyObject * obj1 = 0 ;
31760 PyObject * obj2 = 0 ;
31761 char *kwnames[] = {
31762 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31763 };
31764
31765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31767 if (SWIG_arg_fail(1)) SWIG_fail;
31768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31769 if (SWIG_arg_fail(2)) SWIG_fail;
31770 if (obj2) {
31771 {
31772 arg3 = (bool)(SWIG_As_bool(obj2));
31773 if (SWIG_arg_fail(3)) SWIG_fail;
31774 }
31775 }
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 (arg1)->SetSizerAndFit(arg2,arg3);
31779
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 Py_INCREF(Py_None); resultobj = Py_None;
31784 return resultobj;
31785 fail:
31786 return NULL;
31787 }
31788
31789
31790 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31791 PyObject *resultobj;
31792 wxWindow *arg1 = (wxWindow *) 0 ;
31793 wxSizer *result;
31794 PyObject * obj0 = 0 ;
31795 char *kwnames[] = {
31796 (char *) "self", NULL
31797 };
31798
31799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31801 if (SWIG_arg_fail(1)) SWIG_fail;
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31805
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 {
31810 resultobj = wxPyMake_wxSizer(result, 0);
31811 }
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31819 PyObject *resultobj;
31820 wxWindow *arg1 = (wxWindow *) 0 ;
31821 wxSizer *arg2 = (wxSizer *) 0 ;
31822 PyObject * obj0 = 0 ;
31823 PyObject * obj1 = 0 ;
31824 char *kwnames[] = {
31825 (char *) "self",(char *) "sizer", NULL
31826 };
31827
31828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31830 if (SWIG_arg_fail(1)) SWIG_fail;
31831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31832 if (SWIG_arg_fail(2)) SWIG_fail;
31833 {
31834 PyThreadState* __tstate = wxPyBeginAllowThreads();
31835 (arg1)->SetContainingSizer(arg2);
31836
31837 wxPyEndAllowThreads(__tstate);
31838 if (PyErr_Occurred()) SWIG_fail;
31839 }
31840 Py_INCREF(Py_None); resultobj = Py_None;
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj;
31849 wxWindow *arg1 = (wxWindow *) 0 ;
31850 wxSizer *result;
31851 PyObject * obj0 = 0 ;
31852 char *kwnames[] = {
31853 (char *) "self", NULL
31854 };
31855
31856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31858 if (SWIG_arg_fail(1)) SWIG_fail;
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31862
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 {
31867 resultobj = wxPyMake_wxSizer(result, 0);
31868 }
31869 return resultobj;
31870 fail:
31871 return NULL;
31872 }
31873
31874
31875 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31876 PyObject *resultobj;
31877 wxWindow *arg1 = (wxWindow *) 0 ;
31878 PyObject * obj0 = 0 ;
31879 char *kwnames[] = {
31880 (char *) "self", NULL
31881 };
31882
31883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31885 if (SWIG_arg_fail(1)) SWIG_fail;
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 (arg1)->InheritAttributes();
31889
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 Py_INCREF(Py_None); resultobj = Py_None;
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 bool result;
31904 PyObject * obj0 = 0 ;
31905 char *kwnames[] = {
31906 (char *) "self", NULL
31907 };
31908
31909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31911 if (SWIG_arg_fail(1)) SWIG_fail;
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31915
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 {
31920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31921 }
31922 return resultobj;
31923 fail:
31924 return NULL;
31925 }
31926
31927
31928 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31929 PyObject *obj;
31930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31931 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31932 Py_INCREF(obj);
31933 return Py_BuildValue((char *)"");
31934 }
31935 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31936 PyObject *resultobj;
31937 long arg1 ;
31938 wxWindow *arg2 = (wxWindow *) NULL ;
31939 wxWindow *result;
31940 PyObject * obj0 = 0 ;
31941 PyObject * obj1 = 0 ;
31942 char *kwnames[] = {
31943 (char *) "id",(char *) "parent", NULL
31944 };
31945
31946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31947 {
31948 arg1 = (long)(SWIG_As_long(obj0));
31949 if (SWIG_arg_fail(1)) SWIG_fail;
31950 }
31951 if (obj1) {
31952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31953 if (SWIG_arg_fail(2)) SWIG_fail;
31954 }
31955 {
31956 if (!wxPyCheckForApp()) SWIG_fail;
31957 PyThreadState* __tstate = wxPyBeginAllowThreads();
31958 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31959
31960 wxPyEndAllowThreads(__tstate);
31961 if (PyErr_Occurred()) SWIG_fail;
31962 }
31963 {
31964 resultobj = wxPyMake_wxObject(result, 0);
31965 }
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj;
31974 wxString *arg1 = 0 ;
31975 wxWindow *arg2 = (wxWindow *) NULL ;
31976 wxWindow *result;
31977 bool temp1 = false ;
31978 PyObject * obj0 = 0 ;
31979 PyObject * obj1 = 0 ;
31980 char *kwnames[] = {
31981 (char *) "name",(char *) "parent", NULL
31982 };
31983
31984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31985 {
31986 arg1 = wxString_in_helper(obj0);
31987 if (arg1 == NULL) SWIG_fail;
31988 temp1 = true;
31989 }
31990 if (obj1) {
31991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31992 if (SWIG_arg_fail(2)) SWIG_fail;
31993 }
31994 {
31995 if (!wxPyCheckForApp()) SWIG_fail;
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31998
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 {
32003 resultobj = wxPyMake_wxObject(result, 0);
32004 }
32005 {
32006 if (temp1)
32007 delete arg1;
32008 }
32009 return resultobj;
32010 fail:
32011 {
32012 if (temp1)
32013 delete arg1;
32014 }
32015 return NULL;
32016 }
32017
32018
32019 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32020 PyObject *resultobj;
32021 wxString *arg1 = 0 ;
32022 wxWindow *arg2 = (wxWindow *) NULL ;
32023 wxWindow *result;
32024 bool temp1 = false ;
32025 PyObject * obj0 = 0 ;
32026 PyObject * obj1 = 0 ;
32027 char *kwnames[] = {
32028 (char *) "label",(char *) "parent", NULL
32029 };
32030
32031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32032 {
32033 arg1 = wxString_in_helper(obj0);
32034 if (arg1 == NULL) SWIG_fail;
32035 temp1 = true;
32036 }
32037 if (obj1) {
32038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32039 if (SWIG_arg_fail(2)) SWIG_fail;
32040 }
32041 {
32042 if (!wxPyCheckForApp()) SWIG_fail;
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32045
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 {
32050 resultobj = wxPyMake_wxObject(result, 0);
32051 }
32052 {
32053 if (temp1)
32054 delete arg1;
32055 }
32056 return resultobj;
32057 fail:
32058 {
32059 if (temp1)
32060 delete arg1;
32061 }
32062 return NULL;
32063 }
32064
32065
32066 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32067 PyObject *resultobj;
32068 wxWindow *arg1 = (wxWindow *) 0 ;
32069 unsigned long arg2 ;
32070 wxWindow *result;
32071 PyObject * obj0 = 0 ;
32072 PyObject * obj1 = 0 ;
32073 char *kwnames[] = {
32074 (char *) "parent",(char *) "_hWnd", NULL
32075 };
32076
32077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32079 if (SWIG_arg_fail(1)) SWIG_fail;
32080 {
32081 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32082 if (SWIG_arg_fail(2)) SWIG_fail;
32083 }
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32087
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 {
32092 resultobj = wxPyMake_wxObject(result, 0);
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj;
32102 wxValidator *result;
32103 char *kwnames[] = {
32104 NULL
32105 };
32106
32107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (wxValidator *)new wxValidator();
32111
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32123 PyObject *resultobj;
32124 wxValidator *arg1 = (wxValidator *) 0 ;
32125 wxValidator *result;
32126 PyObject * obj0 = 0 ;
32127 char *kwnames[] = {
32128 (char *) "self", NULL
32129 };
32130
32131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32133 if (SWIG_arg_fail(1)) SWIG_fail;
32134 {
32135 PyThreadState* __tstate = wxPyBeginAllowThreads();
32136 result = (wxValidator *)(arg1)->Clone();
32137
32138 wxPyEndAllowThreads(__tstate);
32139 if (PyErr_Occurred()) SWIG_fail;
32140 }
32141 {
32142 resultobj = wxPyMake_wxObject(result, 0);
32143 }
32144 return resultobj;
32145 fail:
32146 return NULL;
32147 }
32148
32149
32150 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32151 PyObject *resultobj;
32152 wxValidator *arg1 = (wxValidator *) 0 ;
32153 wxWindow *arg2 = (wxWindow *) 0 ;
32154 bool result;
32155 PyObject * obj0 = 0 ;
32156 PyObject * obj1 = 0 ;
32157 char *kwnames[] = {
32158 (char *) "self",(char *) "parent", NULL
32159 };
32160
32161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32163 if (SWIG_arg_fail(1)) SWIG_fail;
32164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32165 if (SWIG_arg_fail(2)) SWIG_fail;
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)(arg1)->Validate(arg2);
32169
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 {
32174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32175 }
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32183 PyObject *resultobj;
32184 wxValidator *arg1 = (wxValidator *) 0 ;
32185 bool result;
32186 PyObject * obj0 = 0 ;
32187 char *kwnames[] = {
32188 (char *) "self", NULL
32189 };
32190
32191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32193 if (SWIG_arg_fail(1)) SWIG_fail;
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = (bool)(arg1)->TransferToWindow();
32197
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 {
32202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32203 }
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj;
32212 wxValidator *arg1 = (wxValidator *) 0 ;
32213 bool result;
32214 PyObject * obj0 = 0 ;
32215 char *kwnames[] = {
32216 (char *) "self", NULL
32217 };
32218
32219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32221 if (SWIG_arg_fail(1)) SWIG_fail;
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (bool)(arg1)->TransferFromWindow();
32225
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 {
32230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32231 }
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32239 PyObject *resultobj;
32240 wxValidator *arg1 = (wxValidator *) 0 ;
32241 wxWindow *result;
32242 PyObject * obj0 = 0 ;
32243 char *kwnames[] = {
32244 (char *) "self", NULL
32245 };
32246
32247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32249 if (SWIG_arg_fail(1)) SWIG_fail;
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = (wxWindow *)(arg1)->GetWindow();
32253
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = wxPyMake_wxObject(result, 0);
32259 }
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj;
32268 wxValidator *arg1 = (wxValidator *) 0 ;
32269 wxWindow *arg2 = (wxWindow *) 0 ;
32270 PyObject * obj0 = 0 ;
32271 PyObject * obj1 = 0 ;
32272 char *kwnames[] = {
32273 (char *) "self",(char *) "window", NULL
32274 };
32275
32276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32278 if (SWIG_arg_fail(1)) SWIG_fail;
32279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32280 if (SWIG_arg_fail(2)) SWIG_fail;
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 (arg1)->SetWindow(arg2);
32284
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 Py_INCREF(Py_None); resultobj = Py_None;
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32296 PyObject *resultobj;
32297 bool result;
32298 char *kwnames[] = {
32299 NULL
32300 };
32301
32302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)wxValidator::IsSilent();
32306
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 {
32311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32312 }
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj;
32321 int arg1 = (int) true ;
32322 PyObject * obj0 = 0 ;
32323 char *kwnames[] = {
32324 (char *) "doIt", NULL
32325 };
32326
32327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32328 if (obj0) {
32329 {
32330 arg1 = (int)(SWIG_As_int(obj0));
32331 if (SWIG_arg_fail(1)) SWIG_fail;
32332 }
32333 }
32334 {
32335 PyThreadState* __tstate = wxPyBeginAllowThreads();
32336 wxValidator::SetBellOnError(arg1);
32337
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 Py_INCREF(Py_None); resultobj = Py_None;
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32349 PyObject *obj;
32350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32351 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32352 Py_INCREF(obj);
32353 return Py_BuildValue((char *)"");
32354 }
32355 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj;
32357 wxPyValidator *result;
32358 char *kwnames[] = {
32359 NULL
32360 };
32361
32362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 result = (wxPyValidator *)new wxPyValidator();
32366
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32378 PyObject *resultobj;
32379 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32380 PyObject *arg2 = (PyObject *) 0 ;
32381 PyObject *arg3 = (PyObject *) 0 ;
32382 int arg4 = (int) true ;
32383 PyObject * obj0 = 0 ;
32384 PyObject * obj1 = 0 ;
32385 PyObject * obj2 = 0 ;
32386 PyObject * obj3 = 0 ;
32387 char *kwnames[] = {
32388 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32389 };
32390
32391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32393 if (SWIG_arg_fail(1)) SWIG_fail;
32394 arg2 = obj1;
32395 arg3 = obj2;
32396 if (obj3) {
32397 {
32398 arg4 = (int)(SWIG_As_int(obj3));
32399 if (SWIG_arg_fail(4)) SWIG_fail;
32400 }
32401 }
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32405
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 Py_INCREF(Py_None); resultobj = Py_None;
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32417 PyObject *obj;
32418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32419 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32420 Py_INCREF(obj);
32421 return Py_BuildValue((char *)"");
32422 }
32423 static int _wrap_DefaultValidator_set(PyObject *) {
32424 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32425 return 1;
32426 }
32427
32428
32429 static PyObject *_wrap_DefaultValidator_get(void) {
32430 PyObject *pyobj;
32431
32432 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32433 return pyobj;
32434 }
32435
32436
32437 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj;
32439 wxString const &arg1_defvalue = wxPyEmptyString ;
32440 wxString *arg1 = (wxString *) &arg1_defvalue ;
32441 long arg2 = (long) 0 ;
32442 wxMenu *result;
32443 bool temp1 = false ;
32444 PyObject * obj0 = 0 ;
32445 PyObject * obj1 = 0 ;
32446 char *kwnames[] = {
32447 (char *) "title",(char *) "style", NULL
32448 };
32449
32450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32451 if (obj0) {
32452 {
32453 arg1 = wxString_in_helper(obj0);
32454 if (arg1 == NULL) SWIG_fail;
32455 temp1 = true;
32456 }
32457 }
32458 if (obj1) {
32459 {
32460 arg2 = (long)(SWIG_As_long(obj1));
32461 if (SWIG_arg_fail(2)) SWIG_fail;
32462 }
32463 }
32464 {
32465 if (!wxPyCheckForApp()) SWIG_fail;
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32468
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32473 {
32474 if (temp1)
32475 delete arg1;
32476 }
32477 return resultobj;
32478 fail:
32479 {
32480 if (temp1)
32481 delete arg1;
32482 }
32483 return NULL;
32484 }
32485
32486
32487 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32488 PyObject *resultobj;
32489 wxMenu *arg1 = (wxMenu *) 0 ;
32490 int arg2 ;
32491 wxString *arg3 = 0 ;
32492 wxString const &arg4_defvalue = wxPyEmptyString ;
32493 wxString *arg4 = (wxString *) &arg4_defvalue ;
32494 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32495 wxMenuItem *result;
32496 bool temp3 = false ;
32497 bool temp4 = false ;
32498 PyObject * obj0 = 0 ;
32499 PyObject * obj1 = 0 ;
32500 PyObject * obj2 = 0 ;
32501 PyObject * obj3 = 0 ;
32502 PyObject * obj4 = 0 ;
32503 char *kwnames[] = {
32504 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32505 };
32506
32507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32509 if (SWIG_arg_fail(1)) SWIG_fail;
32510 {
32511 arg2 = (int)(SWIG_As_int(obj1));
32512 if (SWIG_arg_fail(2)) SWIG_fail;
32513 }
32514 {
32515 arg3 = wxString_in_helper(obj2);
32516 if (arg3 == NULL) SWIG_fail;
32517 temp3 = true;
32518 }
32519 if (obj3) {
32520 {
32521 arg4 = wxString_in_helper(obj3);
32522 if (arg4 == NULL) SWIG_fail;
32523 temp4 = true;
32524 }
32525 }
32526 if (obj4) {
32527 {
32528 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32529 if (SWIG_arg_fail(5)) SWIG_fail;
32530 }
32531 }
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32535
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 {
32540 resultobj = wxPyMake_wxObject(result, 0);
32541 }
32542 {
32543 if (temp3)
32544 delete arg3;
32545 }
32546 {
32547 if (temp4)
32548 delete arg4;
32549 }
32550 return resultobj;
32551 fail:
32552 {
32553 if (temp3)
32554 delete arg3;
32555 }
32556 {
32557 if (temp4)
32558 delete arg4;
32559 }
32560 return NULL;
32561 }
32562
32563
32564 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj;
32566 wxMenu *arg1 = (wxMenu *) 0 ;
32567 wxMenuItem *result;
32568 PyObject * obj0 = 0 ;
32569 char *kwnames[] = {
32570 (char *) "self", NULL
32571 };
32572
32573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32575 if (SWIG_arg_fail(1)) SWIG_fail;
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (wxMenuItem *)(arg1)->AppendSeparator();
32579
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 resultobj = wxPyMake_wxObject(result, 0);
32585 }
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32593 PyObject *resultobj;
32594 wxMenu *arg1 = (wxMenu *) 0 ;
32595 int arg2 ;
32596 wxString *arg3 = 0 ;
32597 wxString const &arg4_defvalue = wxPyEmptyString ;
32598 wxString *arg4 = (wxString *) &arg4_defvalue ;
32599 wxMenuItem *result;
32600 bool temp3 = false ;
32601 bool temp4 = false ;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 PyObject * obj2 = 0 ;
32605 PyObject * obj3 = 0 ;
32606 char *kwnames[] = {
32607 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32608 };
32609
32610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32612 if (SWIG_arg_fail(1)) SWIG_fail;
32613 {
32614 arg2 = (int)(SWIG_As_int(obj1));
32615 if (SWIG_arg_fail(2)) SWIG_fail;
32616 }
32617 {
32618 arg3 = wxString_in_helper(obj2);
32619 if (arg3 == NULL) SWIG_fail;
32620 temp3 = true;
32621 }
32622 if (obj3) {
32623 {
32624 arg4 = wxString_in_helper(obj3);
32625 if (arg4 == NULL) SWIG_fail;
32626 temp4 = true;
32627 }
32628 }
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32632
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 {
32637 resultobj = wxPyMake_wxObject(result, 0);
32638 }
32639 {
32640 if (temp3)
32641 delete arg3;
32642 }
32643 {
32644 if (temp4)
32645 delete arg4;
32646 }
32647 return resultobj;
32648 fail:
32649 {
32650 if (temp3)
32651 delete arg3;
32652 }
32653 {
32654 if (temp4)
32655 delete arg4;
32656 }
32657 return NULL;
32658 }
32659
32660
32661 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj;
32663 wxMenu *arg1 = (wxMenu *) 0 ;
32664 int arg2 ;
32665 wxString *arg3 = 0 ;
32666 wxString const &arg4_defvalue = wxPyEmptyString ;
32667 wxString *arg4 = (wxString *) &arg4_defvalue ;
32668 wxMenuItem *result;
32669 bool temp3 = false ;
32670 bool temp4 = false ;
32671 PyObject * obj0 = 0 ;
32672 PyObject * obj1 = 0 ;
32673 PyObject * obj2 = 0 ;
32674 PyObject * obj3 = 0 ;
32675 char *kwnames[] = {
32676 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32677 };
32678
32679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32681 if (SWIG_arg_fail(1)) SWIG_fail;
32682 {
32683 arg2 = (int)(SWIG_As_int(obj1));
32684 if (SWIG_arg_fail(2)) SWIG_fail;
32685 }
32686 {
32687 arg3 = wxString_in_helper(obj2);
32688 if (arg3 == NULL) SWIG_fail;
32689 temp3 = true;
32690 }
32691 if (obj3) {
32692 {
32693 arg4 = wxString_in_helper(obj3);
32694 if (arg4 == NULL) SWIG_fail;
32695 temp4 = true;
32696 }
32697 }
32698 {
32699 PyThreadState* __tstate = wxPyBeginAllowThreads();
32700 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32701
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 {
32706 resultobj = wxPyMake_wxObject(result, 0);
32707 }
32708 {
32709 if (temp3)
32710 delete arg3;
32711 }
32712 {
32713 if (temp4)
32714 delete arg4;
32715 }
32716 return resultobj;
32717 fail:
32718 {
32719 if (temp3)
32720 delete arg3;
32721 }
32722 {
32723 if (temp4)
32724 delete arg4;
32725 }
32726 return NULL;
32727 }
32728
32729
32730 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32731 PyObject *resultobj;
32732 wxMenu *arg1 = (wxMenu *) 0 ;
32733 int arg2 ;
32734 wxString *arg3 = 0 ;
32735 wxMenu *arg4 = (wxMenu *) 0 ;
32736 wxString const &arg5_defvalue = wxPyEmptyString ;
32737 wxString *arg5 = (wxString *) &arg5_defvalue ;
32738 wxMenuItem *result;
32739 bool temp3 = false ;
32740 bool temp5 = false ;
32741 PyObject * obj0 = 0 ;
32742 PyObject * obj1 = 0 ;
32743 PyObject * obj2 = 0 ;
32744 PyObject * obj3 = 0 ;
32745 PyObject * obj4 = 0 ;
32746 char *kwnames[] = {
32747 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32748 };
32749
32750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32752 if (SWIG_arg_fail(1)) SWIG_fail;
32753 {
32754 arg2 = (int)(SWIG_As_int(obj1));
32755 if (SWIG_arg_fail(2)) SWIG_fail;
32756 }
32757 {
32758 arg3 = wxString_in_helper(obj2);
32759 if (arg3 == NULL) SWIG_fail;
32760 temp3 = true;
32761 }
32762 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32763 if (SWIG_arg_fail(4)) SWIG_fail;
32764 if (obj4) {
32765 {
32766 arg5 = wxString_in_helper(obj4);
32767 if (arg5 == NULL) SWIG_fail;
32768 temp5 = true;
32769 }
32770 }
32771 {
32772 PyThreadState* __tstate = wxPyBeginAllowThreads();
32773 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32774
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 {
32779 resultobj = wxPyMake_wxObject(result, 0);
32780 }
32781 {
32782 if (temp3)
32783 delete arg3;
32784 }
32785 {
32786 if (temp5)
32787 delete arg5;
32788 }
32789 return resultobj;
32790 fail:
32791 {
32792 if (temp3)
32793 delete arg3;
32794 }
32795 {
32796 if (temp5)
32797 delete arg5;
32798 }
32799 return NULL;
32800 }
32801
32802
32803 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32804 PyObject *resultobj;
32805 wxMenu *arg1 = (wxMenu *) 0 ;
32806 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32807 wxMenuItem *result;
32808 PyObject * obj0 = 0 ;
32809 PyObject * obj1 = 0 ;
32810 char *kwnames[] = {
32811 (char *) "self",(char *) "item", NULL
32812 };
32813
32814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32818 if (SWIG_arg_fail(2)) SWIG_fail;
32819 {
32820 PyThreadState* __tstate = wxPyBeginAllowThreads();
32821 result = (wxMenuItem *)(arg1)->Append(arg2);
32822
32823 wxPyEndAllowThreads(__tstate);
32824 if (PyErr_Occurred()) SWIG_fail;
32825 }
32826 {
32827 resultobj = wxPyMake_wxObject(result, 0);
32828 }
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32836 PyObject *resultobj;
32837 wxMenu *arg1 = (wxMenu *) 0 ;
32838 PyObject * obj0 = 0 ;
32839 char *kwnames[] = {
32840 (char *) "self", NULL
32841 };
32842
32843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32845 if (SWIG_arg_fail(1)) SWIG_fail;
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 (arg1)->Break();
32849
32850 wxPyEndAllowThreads(__tstate);
32851 if (PyErr_Occurred()) SWIG_fail;
32852 }
32853 Py_INCREF(Py_None); resultobj = Py_None;
32854 return resultobj;
32855 fail:
32856 return NULL;
32857 }
32858
32859
32860 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32861 PyObject *resultobj;
32862 wxMenu *arg1 = (wxMenu *) 0 ;
32863 size_t arg2 ;
32864 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32865 wxMenuItem *result;
32866 PyObject * obj0 = 0 ;
32867 PyObject * obj1 = 0 ;
32868 PyObject * obj2 = 0 ;
32869 char *kwnames[] = {
32870 (char *) "self",(char *) "pos",(char *) "item", NULL
32871 };
32872
32873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32875 if (SWIG_arg_fail(1)) SWIG_fail;
32876 {
32877 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32878 if (SWIG_arg_fail(2)) SWIG_fail;
32879 }
32880 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32881 if (SWIG_arg_fail(3)) SWIG_fail;
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32885
32886 wxPyEndAllowThreads(__tstate);
32887 if (PyErr_Occurred()) SWIG_fail;
32888 }
32889 {
32890 resultobj = wxPyMake_wxObject(result, 0);
32891 }
32892 return resultobj;
32893 fail:
32894 return NULL;
32895 }
32896
32897
32898 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32899 PyObject *resultobj;
32900 wxMenu *arg1 = (wxMenu *) 0 ;
32901 size_t arg2 ;
32902 int arg3 ;
32903 wxString *arg4 = 0 ;
32904 wxString const &arg5_defvalue = wxPyEmptyString ;
32905 wxString *arg5 = (wxString *) &arg5_defvalue ;
32906 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32907 wxMenuItem *result;
32908 bool temp4 = false ;
32909 bool temp5 = false ;
32910 PyObject * obj0 = 0 ;
32911 PyObject * obj1 = 0 ;
32912 PyObject * obj2 = 0 ;
32913 PyObject * obj3 = 0 ;
32914 PyObject * obj4 = 0 ;
32915 PyObject * obj5 = 0 ;
32916 char *kwnames[] = {
32917 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32918 };
32919
32920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32922 if (SWIG_arg_fail(1)) SWIG_fail;
32923 {
32924 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32925 if (SWIG_arg_fail(2)) SWIG_fail;
32926 }
32927 {
32928 arg3 = (int)(SWIG_As_int(obj2));
32929 if (SWIG_arg_fail(3)) SWIG_fail;
32930 }
32931 {
32932 arg4 = wxString_in_helper(obj3);
32933 if (arg4 == NULL) SWIG_fail;
32934 temp4 = true;
32935 }
32936 if (obj4) {
32937 {
32938 arg5 = wxString_in_helper(obj4);
32939 if (arg5 == NULL) SWIG_fail;
32940 temp5 = true;
32941 }
32942 }
32943 if (obj5) {
32944 {
32945 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32946 if (SWIG_arg_fail(6)) SWIG_fail;
32947 }
32948 }
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32952
32953 wxPyEndAllowThreads(__tstate);
32954 if (PyErr_Occurred()) SWIG_fail;
32955 }
32956 {
32957 resultobj = wxPyMake_wxObject(result, 0);
32958 }
32959 {
32960 if (temp4)
32961 delete arg4;
32962 }
32963 {
32964 if (temp5)
32965 delete arg5;
32966 }
32967 return resultobj;
32968 fail:
32969 {
32970 if (temp4)
32971 delete arg4;
32972 }
32973 {
32974 if (temp5)
32975 delete arg5;
32976 }
32977 return NULL;
32978 }
32979
32980
32981 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32982 PyObject *resultobj;
32983 wxMenu *arg1 = (wxMenu *) 0 ;
32984 size_t arg2 ;
32985 wxMenuItem *result;
32986 PyObject * obj0 = 0 ;
32987 PyObject * obj1 = 0 ;
32988 char *kwnames[] = {
32989 (char *) "self",(char *) "pos", NULL
32990 };
32991
32992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32994 if (SWIG_arg_fail(1)) SWIG_fail;
32995 {
32996 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32997 if (SWIG_arg_fail(2)) SWIG_fail;
32998 }
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33002
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = wxPyMake_wxObject(result, 0);
33008 }
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj;
33017 wxMenu *arg1 = (wxMenu *) 0 ;
33018 size_t arg2 ;
33019 int arg3 ;
33020 wxString *arg4 = 0 ;
33021 wxString const &arg5_defvalue = wxPyEmptyString ;
33022 wxString *arg5 = (wxString *) &arg5_defvalue ;
33023 wxMenuItem *result;
33024 bool temp4 = false ;
33025 bool temp5 = false ;
33026 PyObject * obj0 = 0 ;
33027 PyObject * obj1 = 0 ;
33028 PyObject * obj2 = 0 ;
33029 PyObject * obj3 = 0 ;
33030 PyObject * obj4 = 0 ;
33031 char *kwnames[] = {
33032 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33033 };
33034
33035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33037 if (SWIG_arg_fail(1)) SWIG_fail;
33038 {
33039 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33040 if (SWIG_arg_fail(2)) SWIG_fail;
33041 }
33042 {
33043 arg3 = (int)(SWIG_As_int(obj2));
33044 if (SWIG_arg_fail(3)) SWIG_fail;
33045 }
33046 {
33047 arg4 = wxString_in_helper(obj3);
33048 if (arg4 == NULL) SWIG_fail;
33049 temp4 = true;
33050 }
33051 if (obj4) {
33052 {
33053 arg5 = wxString_in_helper(obj4);
33054 if (arg5 == NULL) SWIG_fail;
33055 temp5 = true;
33056 }
33057 }
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33061
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 {
33066 resultobj = wxPyMake_wxObject(result, 0);
33067 }
33068 {
33069 if (temp4)
33070 delete arg4;
33071 }
33072 {
33073 if (temp5)
33074 delete arg5;
33075 }
33076 return resultobj;
33077 fail:
33078 {
33079 if (temp4)
33080 delete arg4;
33081 }
33082 {
33083 if (temp5)
33084 delete arg5;
33085 }
33086 return NULL;
33087 }
33088
33089
33090 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj;
33092 wxMenu *arg1 = (wxMenu *) 0 ;
33093 size_t arg2 ;
33094 int arg3 ;
33095 wxString *arg4 = 0 ;
33096 wxString const &arg5_defvalue = wxPyEmptyString ;
33097 wxString *arg5 = (wxString *) &arg5_defvalue ;
33098 wxMenuItem *result;
33099 bool temp4 = false ;
33100 bool temp5 = false ;
33101 PyObject * obj0 = 0 ;
33102 PyObject * obj1 = 0 ;
33103 PyObject * obj2 = 0 ;
33104 PyObject * obj3 = 0 ;
33105 PyObject * obj4 = 0 ;
33106 char *kwnames[] = {
33107 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33108 };
33109
33110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33112 if (SWIG_arg_fail(1)) SWIG_fail;
33113 {
33114 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33115 if (SWIG_arg_fail(2)) SWIG_fail;
33116 }
33117 {
33118 arg3 = (int)(SWIG_As_int(obj2));
33119 if (SWIG_arg_fail(3)) SWIG_fail;
33120 }
33121 {
33122 arg4 = wxString_in_helper(obj3);
33123 if (arg4 == NULL) SWIG_fail;
33124 temp4 = true;
33125 }
33126 if (obj4) {
33127 {
33128 arg5 = wxString_in_helper(obj4);
33129 if (arg5 == NULL) SWIG_fail;
33130 temp5 = true;
33131 }
33132 }
33133 {
33134 PyThreadState* __tstate = wxPyBeginAllowThreads();
33135 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33136
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 {
33141 resultobj = wxPyMake_wxObject(result, 0);
33142 }
33143 {
33144 if (temp4)
33145 delete arg4;
33146 }
33147 {
33148 if (temp5)
33149 delete arg5;
33150 }
33151 return resultobj;
33152 fail:
33153 {
33154 if (temp4)
33155 delete arg4;
33156 }
33157 {
33158 if (temp5)
33159 delete arg5;
33160 }
33161 return NULL;
33162 }
33163
33164
33165 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj;
33167 wxMenu *arg1 = (wxMenu *) 0 ;
33168 size_t arg2 ;
33169 int arg3 ;
33170 wxString *arg4 = 0 ;
33171 wxMenu *arg5 = (wxMenu *) 0 ;
33172 wxString const &arg6_defvalue = wxPyEmptyString ;
33173 wxString *arg6 = (wxString *) &arg6_defvalue ;
33174 wxMenuItem *result;
33175 bool temp4 = false ;
33176 bool temp6 = false ;
33177 PyObject * obj0 = 0 ;
33178 PyObject * obj1 = 0 ;
33179 PyObject * obj2 = 0 ;
33180 PyObject * obj3 = 0 ;
33181 PyObject * obj4 = 0 ;
33182 PyObject * obj5 = 0 ;
33183 char *kwnames[] = {
33184 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33185 };
33186
33187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33189 if (SWIG_arg_fail(1)) SWIG_fail;
33190 {
33191 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33192 if (SWIG_arg_fail(2)) SWIG_fail;
33193 }
33194 {
33195 arg3 = (int)(SWIG_As_int(obj2));
33196 if (SWIG_arg_fail(3)) SWIG_fail;
33197 }
33198 {
33199 arg4 = wxString_in_helper(obj3);
33200 if (arg4 == NULL) SWIG_fail;
33201 temp4 = true;
33202 }
33203 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33204 if (SWIG_arg_fail(5)) SWIG_fail;
33205 if (obj5) {
33206 {
33207 arg6 = wxString_in_helper(obj5);
33208 if (arg6 == NULL) SWIG_fail;
33209 temp6 = true;
33210 }
33211 }
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33215
33216 wxPyEndAllowThreads(__tstate);
33217 if (PyErr_Occurred()) SWIG_fail;
33218 }
33219 {
33220 resultobj = wxPyMake_wxObject(result, 0);
33221 }
33222 {
33223 if (temp4)
33224 delete arg4;
33225 }
33226 {
33227 if (temp6)
33228 delete arg6;
33229 }
33230 return resultobj;
33231 fail:
33232 {
33233 if (temp4)
33234 delete arg4;
33235 }
33236 {
33237 if (temp6)
33238 delete arg6;
33239 }
33240 return NULL;
33241 }
33242
33243
33244 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33245 PyObject *resultobj;
33246 wxMenu *arg1 = (wxMenu *) 0 ;
33247 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33248 wxMenuItem *result;
33249 PyObject * obj0 = 0 ;
33250 PyObject * obj1 = 0 ;
33251 char *kwnames[] = {
33252 (char *) "self",(char *) "item", NULL
33253 };
33254
33255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33257 if (SWIG_arg_fail(1)) SWIG_fail;
33258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33259 if (SWIG_arg_fail(2)) SWIG_fail;
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33263
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 {
33268 resultobj = wxPyMake_wxObject(result, 0);
33269 }
33270 return resultobj;
33271 fail:
33272 return NULL;
33273 }
33274
33275
33276 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33277 PyObject *resultobj;
33278 wxMenu *arg1 = (wxMenu *) 0 ;
33279 int arg2 ;
33280 wxString *arg3 = 0 ;
33281 wxString const &arg4_defvalue = wxPyEmptyString ;
33282 wxString *arg4 = (wxString *) &arg4_defvalue ;
33283 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33284 wxMenuItem *result;
33285 bool temp3 = false ;
33286 bool temp4 = false ;
33287 PyObject * obj0 = 0 ;
33288 PyObject * obj1 = 0 ;
33289 PyObject * obj2 = 0 ;
33290 PyObject * obj3 = 0 ;
33291 PyObject * obj4 = 0 ;
33292 char *kwnames[] = {
33293 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33294 };
33295
33296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33298 if (SWIG_arg_fail(1)) SWIG_fail;
33299 {
33300 arg2 = (int)(SWIG_As_int(obj1));
33301 if (SWIG_arg_fail(2)) SWIG_fail;
33302 }
33303 {
33304 arg3 = wxString_in_helper(obj2);
33305 if (arg3 == NULL) SWIG_fail;
33306 temp3 = true;
33307 }
33308 if (obj3) {
33309 {
33310 arg4 = wxString_in_helper(obj3);
33311 if (arg4 == NULL) SWIG_fail;
33312 temp4 = true;
33313 }
33314 }
33315 if (obj4) {
33316 {
33317 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33318 if (SWIG_arg_fail(5)) SWIG_fail;
33319 }
33320 }
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33324
33325 wxPyEndAllowThreads(__tstate);
33326 if (PyErr_Occurred()) SWIG_fail;
33327 }
33328 {
33329 resultobj = wxPyMake_wxObject(result, 0);
33330 }
33331 {
33332 if (temp3)
33333 delete arg3;
33334 }
33335 {
33336 if (temp4)
33337 delete arg4;
33338 }
33339 return resultobj;
33340 fail:
33341 {
33342 if (temp3)
33343 delete arg3;
33344 }
33345 {
33346 if (temp4)
33347 delete arg4;
33348 }
33349 return NULL;
33350 }
33351
33352
33353 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33354 PyObject *resultobj;
33355 wxMenu *arg1 = (wxMenu *) 0 ;
33356 wxMenuItem *result;
33357 PyObject * obj0 = 0 ;
33358 char *kwnames[] = {
33359 (char *) "self", NULL
33360 };
33361
33362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33364 if (SWIG_arg_fail(1)) SWIG_fail;
33365 {
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 result = (wxMenuItem *)(arg1)->PrependSeparator();
33368
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 {
33373 resultobj = wxPyMake_wxObject(result, 0);
33374 }
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj;
33383 wxMenu *arg1 = (wxMenu *) 0 ;
33384 int arg2 ;
33385 wxString *arg3 = 0 ;
33386 wxString const &arg4_defvalue = wxPyEmptyString ;
33387 wxString *arg4 = (wxString *) &arg4_defvalue ;
33388 wxMenuItem *result;
33389 bool temp3 = false ;
33390 bool temp4 = false ;
33391 PyObject * obj0 = 0 ;
33392 PyObject * obj1 = 0 ;
33393 PyObject * obj2 = 0 ;
33394 PyObject * obj3 = 0 ;
33395 char *kwnames[] = {
33396 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33397 };
33398
33399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33401 if (SWIG_arg_fail(1)) SWIG_fail;
33402 {
33403 arg2 = (int)(SWIG_As_int(obj1));
33404 if (SWIG_arg_fail(2)) SWIG_fail;
33405 }
33406 {
33407 arg3 = wxString_in_helper(obj2);
33408 if (arg3 == NULL) SWIG_fail;
33409 temp3 = true;
33410 }
33411 if (obj3) {
33412 {
33413 arg4 = wxString_in_helper(obj3);
33414 if (arg4 == NULL) SWIG_fail;
33415 temp4 = true;
33416 }
33417 }
33418 {
33419 PyThreadState* __tstate = wxPyBeginAllowThreads();
33420 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33421
33422 wxPyEndAllowThreads(__tstate);
33423 if (PyErr_Occurred()) SWIG_fail;
33424 }
33425 {
33426 resultobj = wxPyMake_wxObject(result, 0);
33427 }
33428 {
33429 if (temp3)
33430 delete arg3;
33431 }
33432 {
33433 if (temp4)
33434 delete arg4;
33435 }
33436 return resultobj;
33437 fail:
33438 {
33439 if (temp3)
33440 delete arg3;
33441 }
33442 {
33443 if (temp4)
33444 delete arg4;
33445 }
33446 return NULL;
33447 }
33448
33449
33450 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj;
33452 wxMenu *arg1 = (wxMenu *) 0 ;
33453 int arg2 ;
33454 wxString *arg3 = 0 ;
33455 wxString const &arg4_defvalue = wxPyEmptyString ;
33456 wxString *arg4 = (wxString *) &arg4_defvalue ;
33457 wxMenuItem *result;
33458 bool temp3 = false ;
33459 bool temp4 = false ;
33460 PyObject * obj0 = 0 ;
33461 PyObject * obj1 = 0 ;
33462 PyObject * obj2 = 0 ;
33463 PyObject * obj3 = 0 ;
33464 char *kwnames[] = {
33465 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33466 };
33467
33468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33470 if (SWIG_arg_fail(1)) SWIG_fail;
33471 {
33472 arg2 = (int)(SWIG_As_int(obj1));
33473 if (SWIG_arg_fail(2)) SWIG_fail;
33474 }
33475 {
33476 arg3 = wxString_in_helper(obj2);
33477 if (arg3 == NULL) SWIG_fail;
33478 temp3 = true;
33479 }
33480 if (obj3) {
33481 {
33482 arg4 = wxString_in_helper(obj3);
33483 if (arg4 == NULL) SWIG_fail;
33484 temp4 = true;
33485 }
33486 }
33487 {
33488 PyThreadState* __tstate = wxPyBeginAllowThreads();
33489 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33490
33491 wxPyEndAllowThreads(__tstate);
33492 if (PyErr_Occurred()) SWIG_fail;
33493 }
33494 {
33495 resultobj = wxPyMake_wxObject(result, 0);
33496 }
33497 {
33498 if (temp3)
33499 delete arg3;
33500 }
33501 {
33502 if (temp4)
33503 delete arg4;
33504 }
33505 return resultobj;
33506 fail:
33507 {
33508 if (temp3)
33509 delete arg3;
33510 }
33511 {
33512 if (temp4)
33513 delete arg4;
33514 }
33515 return NULL;
33516 }
33517
33518
33519 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj;
33521 wxMenu *arg1 = (wxMenu *) 0 ;
33522 int arg2 ;
33523 wxString *arg3 = 0 ;
33524 wxMenu *arg4 = (wxMenu *) 0 ;
33525 wxString const &arg5_defvalue = wxPyEmptyString ;
33526 wxString *arg5 = (wxString *) &arg5_defvalue ;
33527 wxMenuItem *result;
33528 bool temp3 = false ;
33529 bool temp5 = false ;
33530 PyObject * obj0 = 0 ;
33531 PyObject * obj1 = 0 ;
33532 PyObject * obj2 = 0 ;
33533 PyObject * obj3 = 0 ;
33534 PyObject * obj4 = 0 ;
33535 char *kwnames[] = {
33536 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33537 };
33538
33539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33541 if (SWIG_arg_fail(1)) SWIG_fail;
33542 {
33543 arg2 = (int)(SWIG_As_int(obj1));
33544 if (SWIG_arg_fail(2)) SWIG_fail;
33545 }
33546 {
33547 arg3 = wxString_in_helper(obj2);
33548 if (arg3 == NULL) SWIG_fail;
33549 temp3 = true;
33550 }
33551 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33552 if (SWIG_arg_fail(4)) SWIG_fail;
33553 if (obj4) {
33554 {
33555 arg5 = wxString_in_helper(obj4);
33556 if (arg5 == NULL) SWIG_fail;
33557 temp5 = true;
33558 }
33559 }
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33563
33564 wxPyEndAllowThreads(__tstate);
33565 if (PyErr_Occurred()) SWIG_fail;
33566 }
33567 {
33568 resultobj = wxPyMake_wxObject(result, 0);
33569 }
33570 {
33571 if (temp3)
33572 delete arg3;
33573 }
33574 {
33575 if (temp5)
33576 delete arg5;
33577 }
33578 return resultobj;
33579 fail:
33580 {
33581 if (temp3)
33582 delete arg3;
33583 }
33584 {
33585 if (temp5)
33586 delete arg5;
33587 }
33588 return NULL;
33589 }
33590
33591
33592 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33593 PyObject *resultobj;
33594 wxMenu *arg1 = (wxMenu *) 0 ;
33595 int arg2 ;
33596 wxMenuItem *result;
33597 PyObject * obj0 = 0 ;
33598 PyObject * obj1 = 0 ;
33599 char *kwnames[] = {
33600 (char *) "self",(char *) "id", NULL
33601 };
33602
33603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 result = (wxMenuItem *)(arg1)->Remove(arg2);
33613
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 {
33618 resultobj = wxPyMake_wxObject(result, 0);
33619 }
33620 return resultobj;
33621 fail:
33622 return NULL;
33623 }
33624
33625
33626 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33627 PyObject *resultobj;
33628 wxMenu *arg1 = (wxMenu *) 0 ;
33629 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33630 wxMenuItem *result;
33631 PyObject * obj0 = 0 ;
33632 PyObject * obj1 = 0 ;
33633 char *kwnames[] = {
33634 (char *) "self",(char *) "item", NULL
33635 };
33636
33637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33639 if (SWIG_arg_fail(1)) SWIG_fail;
33640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33641 if (SWIG_arg_fail(2)) SWIG_fail;
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxMenuItem *)(arg1)->Remove(arg2);
33645
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = wxPyMake_wxObject(result, 0);
33651 }
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33659 PyObject *resultobj;
33660 wxMenu *arg1 = (wxMenu *) 0 ;
33661 int arg2 ;
33662 bool result;
33663 PyObject * obj0 = 0 ;
33664 PyObject * obj1 = 0 ;
33665 char *kwnames[] = {
33666 (char *) "self",(char *) "id", NULL
33667 };
33668
33669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33671 if (SWIG_arg_fail(1)) SWIG_fail;
33672 {
33673 arg2 = (int)(SWIG_As_int(obj1));
33674 if (SWIG_arg_fail(2)) SWIG_fail;
33675 }
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 result = (bool)(arg1)->Delete(arg2);
33679
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 {
33684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33685 }
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33693 PyObject *resultobj;
33694 wxMenu *arg1 = (wxMenu *) 0 ;
33695 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33696 bool result;
33697 PyObject * obj0 = 0 ;
33698 PyObject * obj1 = 0 ;
33699 char *kwnames[] = {
33700 (char *) "self",(char *) "item", NULL
33701 };
33702
33703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33705 if (SWIG_arg_fail(1)) SWIG_fail;
33706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33707 if (SWIG_arg_fail(2)) SWIG_fail;
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)(arg1)->Delete(arg2);
33711
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 {
33716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33717 }
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj;
33726 wxMenu *arg1 = (wxMenu *) 0 ;
33727 PyObject * obj0 = 0 ;
33728 char *kwnames[] = {
33729 (char *) "self", NULL
33730 };
33731
33732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33734 if (SWIG_arg_fail(1)) SWIG_fail;
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 wxMenu_Destroy(arg1);
33738
33739 wxPyEndAllowThreads(__tstate);
33740 if (PyErr_Occurred()) SWIG_fail;
33741 }
33742 Py_INCREF(Py_None); resultobj = Py_None;
33743 return resultobj;
33744 fail:
33745 return NULL;
33746 }
33747
33748
33749 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33750 PyObject *resultobj;
33751 wxMenu *arg1 = (wxMenu *) 0 ;
33752 int arg2 ;
33753 bool result;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 char *kwnames[] = {
33757 (char *) "self",(char *) "id", NULL
33758 };
33759
33760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33762 if (SWIG_arg_fail(1)) SWIG_fail;
33763 {
33764 arg2 = (int)(SWIG_As_int(obj1));
33765 if (SWIG_arg_fail(2)) SWIG_fail;
33766 }
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (bool)(arg1)->Destroy(arg2);
33770
33771 wxPyEndAllowThreads(__tstate);
33772 if (PyErr_Occurred()) SWIG_fail;
33773 }
33774 {
33775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33776 }
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj;
33785 wxMenu *arg1 = (wxMenu *) 0 ;
33786 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33787 bool result;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 char *kwnames[] = {
33791 (char *) "self",(char *) "item", NULL
33792 };
33793
33794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33796 if (SWIG_arg_fail(1)) SWIG_fail;
33797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33798 if (SWIG_arg_fail(2)) SWIG_fail;
33799 {
33800 PyThreadState* __tstate = wxPyBeginAllowThreads();
33801 result = (bool)(arg1)->Destroy(arg2);
33802
33803 wxPyEndAllowThreads(__tstate);
33804 if (PyErr_Occurred()) SWIG_fail;
33805 }
33806 {
33807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33808 }
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj;
33817 wxMenu *arg1 = (wxMenu *) 0 ;
33818 size_t result;
33819 PyObject * obj0 = 0 ;
33820 char *kwnames[] = {
33821 (char *) "self", NULL
33822 };
33823
33824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33826 if (SWIG_arg_fail(1)) SWIG_fail;
33827 {
33828 PyThreadState* __tstate = wxPyBeginAllowThreads();
33829 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33830
33831 wxPyEndAllowThreads(__tstate);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 }
33834 {
33835 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33836 }
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33844 PyObject *resultobj;
33845 wxMenu *arg1 = (wxMenu *) 0 ;
33846 PyObject *result;
33847 PyObject * obj0 = 0 ;
33848 char *kwnames[] = {
33849 (char *) "self", NULL
33850 };
33851
33852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33854 if (SWIG_arg_fail(1)) SWIG_fail;
33855 {
33856 PyThreadState* __tstate = wxPyBeginAllowThreads();
33857 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33858
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 resultobj = result;
33863 return resultobj;
33864 fail:
33865 return NULL;
33866 }
33867
33868
33869 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33870 PyObject *resultobj;
33871 wxMenu *arg1 = (wxMenu *) 0 ;
33872 wxString *arg2 = 0 ;
33873 int result;
33874 bool temp2 = false ;
33875 PyObject * obj0 = 0 ;
33876 PyObject * obj1 = 0 ;
33877 char *kwnames[] = {
33878 (char *) "self",(char *) "item", NULL
33879 };
33880
33881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33883 if (SWIG_arg_fail(1)) SWIG_fail;
33884 {
33885 arg2 = wxString_in_helper(obj1);
33886 if (arg2 == NULL) SWIG_fail;
33887 temp2 = true;
33888 }
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33892
33893 wxPyEndAllowThreads(__tstate);
33894 if (PyErr_Occurred()) SWIG_fail;
33895 }
33896 {
33897 resultobj = SWIG_From_int((int)(result));
33898 }
33899 {
33900 if (temp2)
33901 delete arg2;
33902 }
33903 return resultobj;
33904 fail:
33905 {
33906 if (temp2)
33907 delete arg2;
33908 }
33909 return NULL;
33910 }
33911
33912
33913 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj;
33915 wxMenu *arg1 = (wxMenu *) 0 ;
33916 int arg2 ;
33917 wxMenuItem *result;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 char *kwnames[] = {
33921 (char *) "self",(char *) "id", NULL
33922 };
33923
33924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33926 if (SWIG_arg_fail(1)) SWIG_fail;
33927 {
33928 arg2 = (int)(SWIG_As_int(obj1));
33929 if (SWIG_arg_fail(2)) SWIG_fail;
33930 }
33931 {
33932 PyThreadState* __tstate = wxPyBeginAllowThreads();
33933 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33934
33935 wxPyEndAllowThreads(__tstate);
33936 if (PyErr_Occurred()) SWIG_fail;
33937 }
33938 {
33939 resultobj = wxPyMake_wxObject(result, 0);
33940 }
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj;
33949 wxMenu *arg1 = (wxMenu *) 0 ;
33950 size_t arg2 ;
33951 wxMenuItem *result;
33952 PyObject * obj0 = 0 ;
33953 PyObject * obj1 = 0 ;
33954 char *kwnames[] = {
33955 (char *) "self",(char *) "position", NULL
33956 };
33957
33958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33960 if (SWIG_arg_fail(1)) SWIG_fail;
33961 {
33962 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33963 if (SWIG_arg_fail(2)) SWIG_fail;
33964 }
33965 {
33966 PyThreadState* __tstate = wxPyBeginAllowThreads();
33967 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33968
33969 wxPyEndAllowThreads(__tstate);
33970 if (PyErr_Occurred()) SWIG_fail;
33971 }
33972 {
33973 resultobj = wxPyMake_wxObject(result, 0);
33974 }
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj;
33983 wxMenu *arg1 = (wxMenu *) 0 ;
33984 int arg2 ;
33985 bool arg3 ;
33986 PyObject * obj0 = 0 ;
33987 PyObject * obj1 = 0 ;
33988 PyObject * obj2 = 0 ;
33989 char *kwnames[] = {
33990 (char *) "self",(char *) "id",(char *) "enable", NULL
33991 };
33992
33993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33995 if (SWIG_arg_fail(1)) SWIG_fail;
33996 {
33997 arg2 = (int)(SWIG_As_int(obj1));
33998 if (SWIG_arg_fail(2)) SWIG_fail;
33999 }
34000 {
34001 arg3 = (bool)(SWIG_As_bool(obj2));
34002 if (SWIG_arg_fail(3)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 (arg1)->Enable(arg2,arg3);
34007
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 Py_INCREF(Py_None); resultobj = Py_None;
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34019 PyObject *resultobj;
34020 wxMenu *arg1 = (wxMenu *) 0 ;
34021 int arg2 ;
34022 bool result;
34023 PyObject * obj0 = 0 ;
34024 PyObject * obj1 = 0 ;
34025 char *kwnames[] = {
34026 (char *) "self",(char *) "id", NULL
34027 };
34028
34029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34031 if (SWIG_arg_fail(1)) SWIG_fail;
34032 {
34033 arg2 = (int)(SWIG_As_int(obj1));
34034 if (SWIG_arg_fail(2)) SWIG_fail;
34035 }
34036 {
34037 PyThreadState* __tstate = wxPyBeginAllowThreads();
34038 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34039
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 {
34044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34045 }
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34053 PyObject *resultobj;
34054 wxMenu *arg1 = (wxMenu *) 0 ;
34055 int arg2 ;
34056 bool arg3 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 PyObject * obj2 = 0 ;
34060 char *kwnames[] = {
34061 (char *) "self",(char *) "id",(char *) "check", NULL
34062 };
34063
34064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34066 if (SWIG_arg_fail(1)) SWIG_fail;
34067 {
34068 arg2 = (int)(SWIG_As_int(obj1));
34069 if (SWIG_arg_fail(2)) SWIG_fail;
34070 }
34071 {
34072 arg3 = (bool)(SWIG_As_bool(obj2));
34073 if (SWIG_arg_fail(3)) SWIG_fail;
34074 }
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 (arg1)->Check(arg2,arg3);
34078
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 Py_INCREF(Py_None); resultobj = Py_None;
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 int arg2 ;
34093 bool result;
34094 PyObject * obj0 = 0 ;
34095 PyObject * obj1 = 0 ;
34096 char *kwnames[] = {
34097 (char *) "self",(char *) "id", NULL
34098 };
34099
34100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34102 if (SWIG_arg_fail(1)) SWIG_fail;
34103 {
34104 arg2 = (int)(SWIG_As_int(obj1));
34105 if (SWIG_arg_fail(2)) SWIG_fail;
34106 }
34107 {
34108 PyThreadState* __tstate = wxPyBeginAllowThreads();
34109 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34110
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 {
34115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34116 }
34117 return resultobj;
34118 fail:
34119 return NULL;
34120 }
34121
34122
34123 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34124 PyObject *resultobj;
34125 wxMenu *arg1 = (wxMenu *) 0 ;
34126 int arg2 ;
34127 wxString *arg3 = 0 ;
34128 bool temp3 = false ;
34129 PyObject * obj0 = 0 ;
34130 PyObject * obj1 = 0 ;
34131 PyObject * obj2 = 0 ;
34132 char *kwnames[] = {
34133 (char *) "self",(char *) "id",(char *) "label", NULL
34134 };
34135
34136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34138 if (SWIG_arg_fail(1)) SWIG_fail;
34139 {
34140 arg2 = (int)(SWIG_As_int(obj1));
34141 if (SWIG_arg_fail(2)) SWIG_fail;
34142 }
34143 {
34144 arg3 = wxString_in_helper(obj2);
34145 if (arg3 == NULL) SWIG_fail;
34146 temp3 = true;
34147 }
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34151
34152 wxPyEndAllowThreads(__tstate);
34153 if (PyErr_Occurred()) SWIG_fail;
34154 }
34155 Py_INCREF(Py_None); resultobj = Py_None;
34156 {
34157 if (temp3)
34158 delete arg3;
34159 }
34160 return resultobj;
34161 fail:
34162 {
34163 if (temp3)
34164 delete arg3;
34165 }
34166 return NULL;
34167 }
34168
34169
34170 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj;
34172 wxMenu *arg1 = (wxMenu *) 0 ;
34173 int arg2 ;
34174 wxString result;
34175 PyObject * obj0 = 0 ;
34176 PyObject * obj1 = 0 ;
34177 char *kwnames[] = {
34178 (char *) "self",(char *) "id", NULL
34179 };
34180
34181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34183 if (SWIG_arg_fail(1)) SWIG_fail;
34184 {
34185 arg2 = (int)(SWIG_As_int(obj1));
34186 if (SWIG_arg_fail(2)) SWIG_fail;
34187 }
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34191
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 {
34196 #if wxUSE_UNICODE
34197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34198 #else
34199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34200 #endif
34201 }
34202 return resultobj;
34203 fail:
34204 return NULL;
34205 }
34206
34207
34208 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34209 PyObject *resultobj;
34210 wxMenu *arg1 = (wxMenu *) 0 ;
34211 int arg2 ;
34212 wxString *arg3 = 0 ;
34213 bool temp3 = false ;
34214 PyObject * obj0 = 0 ;
34215 PyObject * obj1 = 0 ;
34216 PyObject * obj2 = 0 ;
34217 char *kwnames[] = {
34218 (char *) "self",(char *) "id",(char *) "helpString", NULL
34219 };
34220
34221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34223 if (SWIG_arg_fail(1)) SWIG_fail;
34224 {
34225 arg2 = (int)(SWIG_As_int(obj1));
34226 if (SWIG_arg_fail(2)) SWIG_fail;
34227 }
34228 {
34229 arg3 = wxString_in_helper(obj2);
34230 if (arg3 == NULL) SWIG_fail;
34231 temp3 = true;
34232 }
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34236
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 Py_INCREF(Py_None); resultobj = Py_None;
34241 {
34242 if (temp3)
34243 delete arg3;
34244 }
34245 return resultobj;
34246 fail:
34247 {
34248 if (temp3)
34249 delete arg3;
34250 }
34251 return NULL;
34252 }
34253
34254
34255 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj;
34257 wxMenu *arg1 = (wxMenu *) 0 ;
34258 int arg2 ;
34259 wxString result;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 char *kwnames[] = {
34263 (char *) "self",(char *) "id", NULL
34264 };
34265
34266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34268 if (SWIG_arg_fail(1)) SWIG_fail;
34269 {
34270 arg2 = (int)(SWIG_As_int(obj1));
34271 if (SWIG_arg_fail(2)) SWIG_fail;
34272 }
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34276
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 {
34281 #if wxUSE_UNICODE
34282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34283 #else
34284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34285 #endif
34286 }
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34294 PyObject *resultobj;
34295 wxMenu *arg1 = (wxMenu *) 0 ;
34296 wxString *arg2 = 0 ;
34297 bool temp2 = false ;
34298 PyObject * obj0 = 0 ;
34299 PyObject * obj1 = 0 ;
34300 char *kwnames[] = {
34301 (char *) "self",(char *) "title", NULL
34302 };
34303
34304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34306 if (SWIG_arg_fail(1)) SWIG_fail;
34307 {
34308 arg2 = wxString_in_helper(obj1);
34309 if (arg2 == NULL) SWIG_fail;
34310 temp2 = true;
34311 }
34312 {
34313 PyThreadState* __tstate = wxPyBeginAllowThreads();
34314 (arg1)->SetTitle((wxString const &)*arg2);
34315
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 Py_INCREF(Py_None); resultobj = Py_None;
34320 {
34321 if (temp2)
34322 delete arg2;
34323 }
34324 return resultobj;
34325 fail:
34326 {
34327 if (temp2)
34328 delete arg2;
34329 }
34330 return NULL;
34331 }
34332
34333
34334 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34335 PyObject *resultobj;
34336 wxMenu *arg1 = (wxMenu *) 0 ;
34337 wxString result;
34338 PyObject * obj0 = 0 ;
34339 char *kwnames[] = {
34340 (char *) "self", NULL
34341 };
34342
34343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34345 if (SWIG_arg_fail(1)) SWIG_fail;
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 result = ((wxMenu const *)arg1)->GetTitle();
34349
34350 wxPyEndAllowThreads(__tstate);
34351 if (PyErr_Occurred()) SWIG_fail;
34352 }
34353 {
34354 #if wxUSE_UNICODE
34355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34356 #else
34357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34358 #endif
34359 }
34360 return resultobj;
34361 fail:
34362 return NULL;
34363 }
34364
34365
34366 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34367 PyObject *resultobj;
34368 wxMenu *arg1 = (wxMenu *) 0 ;
34369 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34370 PyObject * obj0 = 0 ;
34371 PyObject * obj1 = 0 ;
34372 char *kwnames[] = {
34373 (char *) "self",(char *) "handler", NULL
34374 };
34375
34376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34378 if (SWIG_arg_fail(1)) SWIG_fail;
34379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34380 if (SWIG_arg_fail(2)) SWIG_fail;
34381 {
34382 PyThreadState* __tstate = wxPyBeginAllowThreads();
34383 (arg1)->SetEventHandler(arg2);
34384
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 Py_INCREF(Py_None); resultobj = Py_None;
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34396 PyObject *resultobj;
34397 wxMenu *arg1 = (wxMenu *) 0 ;
34398 wxEvtHandler *result;
34399 PyObject * obj0 = 0 ;
34400 char *kwnames[] = {
34401 (char *) "self", NULL
34402 };
34403
34404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34406 if (SWIG_arg_fail(1)) SWIG_fail;
34407 {
34408 PyThreadState* __tstate = wxPyBeginAllowThreads();
34409 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34410
34411 wxPyEndAllowThreads(__tstate);
34412 if (PyErr_Occurred()) SWIG_fail;
34413 }
34414 {
34415 resultobj = wxPyMake_wxObject(result, 0);
34416 }
34417 return resultobj;
34418 fail:
34419 return NULL;
34420 }
34421
34422
34423 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34424 PyObject *resultobj;
34425 wxMenu *arg1 = (wxMenu *) 0 ;
34426 wxWindow *arg2 = (wxWindow *) 0 ;
34427 PyObject * obj0 = 0 ;
34428 PyObject * obj1 = 0 ;
34429 char *kwnames[] = {
34430 (char *) "self",(char *) "win", NULL
34431 };
34432
34433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34435 if (SWIG_arg_fail(1)) SWIG_fail;
34436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34437 if (SWIG_arg_fail(2)) SWIG_fail;
34438 {
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 (arg1)->SetInvokingWindow(arg2);
34441
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 Py_INCREF(Py_None); resultobj = Py_None;
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34453 PyObject *resultobj;
34454 wxMenu *arg1 = (wxMenu *) 0 ;
34455 wxWindow *result;
34456 PyObject * obj0 = 0 ;
34457 char *kwnames[] = {
34458 (char *) "self", NULL
34459 };
34460
34461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34463 if (SWIG_arg_fail(1)) SWIG_fail;
34464 {
34465 PyThreadState* __tstate = wxPyBeginAllowThreads();
34466 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34467
34468 wxPyEndAllowThreads(__tstate);
34469 if (PyErr_Occurred()) SWIG_fail;
34470 }
34471 {
34472 resultobj = wxPyMake_wxObject(result, 0);
34473 }
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34481 PyObject *resultobj;
34482 wxMenu *arg1 = (wxMenu *) 0 ;
34483 long result;
34484 PyObject * obj0 = 0 ;
34485 char *kwnames[] = {
34486 (char *) "self", NULL
34487 };
34488
34489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34491 if (SWIG_arg_fail(1)) SWIG_fail;
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 result = (long)((wxMenu const *)arg1)->GetStyle();
34495
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 {
34500 resultobj = SWIG_From_long((long)(result));
34501 }
34502 return resultobj;
34503 fail:
34504 return NULL;
34505 }
34506
34507
34508 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34509 PyObject *resultobj;
34510 wxMenu *arg1 = (wxMenu *) 0 ;
34511 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34512 PyObject * obj0 = 0 ;
34513 PyObject * obj1 = 0 ;
34514 char *kwnames[] = {
34515 (char *) "self",(char *) "source", NULL
34516 };
34517
34518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34520 if (SWIG_arg_fail(1)) SWIG_fail;
34521 if (obj1) {
34522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34523 if (SWIG_arg_fail(2)) SWIG_fail;
34524 }
34525 {
34526 PyThreadState* __tstate = wxPyBeginAllowThreads();
34527 (arg1)->UpdateUI(arg2);
34528
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 Py_INCREF(Py_None); resultobj = Py_None;
34533 return resultobj;
34534 fail:
34535 return NULL;
34536 }
34537
34538
34539 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34540 PyObject *resultobj;
34541 wxMenu *arg1 = (wxMenu *) 0 ;
34542 wxMenuBar *result;
34543 PyObject * obj0 = 0 ;
34544 char *kwnames[] = {
34545 (char *) "self", NULL
34546 };
34547
34548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34550 if (SWIG_arg_fail(1)) SWIG_fail;
34551 {
34552 PyThreadState* __tstate = wxPyBeginAllowThreads();
34553 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34554
34555 wxPyEndAllowThreads(__tstate);
34556 if (PyErr_Occurred()) SWIG_fail;
34557 }
34558 {
34559 resultobj = wxPyMake_wxObject(result, 0);
34560 }
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34568 PyObject *resultobj;
34569 wxMenu *arg1 = (wxMenu *) 0 ;
34570 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34571 PyObject * obj0 = 0 ;
34572 PyObject * obj1 = 0 ;
34573 char *kwnames[] = {
34574 (char *) "self",(char *) "menubar", NULL
34575 };
34576
34577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34579 if (SWIG_arg_fail(1)) SWIG_fail;
34580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34581 if (SWIG_arg_fail(2)) SWIG_fail;
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 (arg1)->Attach(arg2);
34585
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 Py_INCREF(Py_None); resultobj = Py_None;
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34597 PyObject *resultobj;
34598 wxMenu *arg1 = (wxMenu *) 0 ;
34599 PyObject * obj0 = 0 ;
34600 char *kwnames[] = {
34601 (char *) "self", NULL
34602 };
34603
34604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34606 if (SWIG_arg_fail(1)) SWIG_fail;
34607 {
34608 PyThreadState* __tstate = wxPyBeginAllowThreads();
34609 (arg1)->Detach();
34610
34611 wxPyEndAllowThreads(__tstate);
34612 if (PyErr_Occurred()) SWIG_fail;
34613 }
34614 Py_INCREF(Py_None); resultobj = Py_None;
34615 return resultobj;
34616 fail:
34617 return NULL;
34618 }
34619
34620
34621 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34622 PyObject *resultobj;
34623 wxMenu *arg1 = (wxMenu *) 0 ;
34624 bool result;
34625 PyObject * obj0 = 0 ;
34626 char *kwnames[] = {
34627 (char *) "self", NULL
34628 };
34629
34630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34632 if (SWIG_arg_fail(1)) SWIG_fail;
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 result = (bool)((wxMenu const *)arg1)->IsAttached();
34636
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 {
34641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34642 }
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj;
34651 wxMenu *arg1 = (wxMenu *) 0 ;
34652 wxMenu *arg2 = (wxMenu *) 0 ;
34653 PyObject * obj0 = 0 ;
34654 PyObject * obj1 = 0 ;
34655 char *kwnames[] = {
34656 (char *) "self",(char *) "parent", NULL
34657 };
34658
34659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34661 if (SWIG_arg_fail(1)) SWIG_fail;
34662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34663 if (SWIG_arg_fail(2)) SWIG_fail;
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 (arg1)->SetParent(arg2);
34667
34668 wxPyEndAllowThreads(__tstate);
34669 if (PyErr_Occurred()) SWIG_fail;
34670 }
34671 Py_INCREF(Py_None); resultobj = Py_None;
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj;
34680 wxMenu *arg1 = (wxMenu *) 0 ;
34681 wxMenu *result;
34682 PyObject * obj0 = 0 ;
34683 char *kwnames[] = {
34684 (char *) "self", NULL
34685 };
34686
34687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34689 if (SWIG_arg_fail(1)) SWIG_fail;
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34693
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 {
34698 resultobj = wxPyMake_wxObject(result, 0);
34699 }
34700 return resultobj;
34701 fail:
34702 return NULL;
34703 }
34704
34705
34706 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34707 PyObject *obj;
34708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34709 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34710 Py_INCREF(obj);
34711 return Py_BuildValue((char *)"");
34712 }
34713 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34714 PyObject *resultobj;
34715 long arg1 = (long) 0 ;
34716 wxMenuBar *result;
34717 PyObject * obj0 = 0 ;
34718 char *kwnames[] = {
34719 (char *) "style", NULL
34720 };
34721
34722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34723 if (obj0) {
34724 {
34725 arg1 = (long)(SWIG_As_long(obj0));
34726 if (SWIG_arg_fail(1)) SWIG_fail;
34727 }
34728 }
34729 {
34730 if (!wxPyCheckForApp()) SWIG_fail;
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 result = (wxMenuBar *)new wxMenuBar(arg1);
34733
34734 wxPyEndAllowThreads(__tstate);
34735 if (PyErr_Occurred()) SWIG_fail;
34736 }
34737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34745 PyObject *resultobj;
34746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34747 wxMenu *arg2 = (wxMenu *) 0 ;
34748 wxString *arg3 = 0 ;
34749 bool result;
34750 bool temp3 = false ;
34751 PyObject * obj0 = 0 ;
34752 PyObject * obj1 = 0 ;
34753 PyObject * obj2 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "menu",(char *) "title", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34760 if (SWIG_arg_fail(1)) SWIG_fail;
34761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34762 if (SWIG_arg_fail(2)) SWIG_fail;
34763 {
34764 arg3 = wxString_in_helper(obj2);
34765 if (arg3 == NULL) SWIG_fail;
34766 temp3 = true;
34767 }
34768 {
34769 PyThreadState* __tstate = wxPyBeginAllowThreads();
34770 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34771
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 {
34779 if (temp3)
34780 delete arg3;
34781 }
34782 return resultobj;
34783 fail:
34784 {
34785 if (temp3)
34786 delete arg3;
34787 }
34788 return NULL;
34789 }
34790
34791
34792 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj;
34794 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34795 size_t arg2 ;
34796 wxMenu *arg3 = (wxMenu *) 0 ;
34797 wxString *arg4 = 0 ;
34798 bool result;
34799 bool temp4 = false ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 PyObject * obj2 = 0 ;
34803 PyObject * obj3 = 0 ;
34804 char *kwnames[] = {
34805 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34806 };
34807
34808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34810 if (SWIG_arg_fail(1)) SWIG_fail;
34811 {
34812 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34813 if (SWIG_arg_fail(2)) SWIG_fail;
34814 }
34815 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34816 if (SWIG_arg_fail(3)) SWIG_fail;
34817 {
34818 arg4 = wxString_in_helper(obj3);
34819 if (arg4 == NULL) SWIG_fail;
34820 temp4 = true;
34821 }
34822 {
34823 PyThreadState* __tstate = wxPyBeginAllowThreads();
34824 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34825
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 {
34830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34831 }
34832 {
34833 if (temp4)
34834 delete arg4;
34835 }
34836 return resultobj;
34837 fail:
34838 {
34839 if (temp4)
34840 delete arg4;
34841 }
34842 return NULL;
34843 }
34844
34845
34846 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj;
34848 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34849 size_t result;
34850 PyObject * obj0 = 0 ;
34851 char *kwnames[] = {
34852 (char *) "self", NULL
34853 };
34854
34855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34857 if (SWIG_arg_fail(1)) SWIG_fail;
34858 {
34859 PyThreadState* __tstate = wxPyBeginAllowThreads();
34860 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34861
34862 wxPyEndAllowThreads(__tstate);
34863 if (PyErr_Occurred()) SWIG_fail;
34864 }
34865 {
34866 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34867 }
34868 return resultobj;
34869 fail:
34870 return NULL;
34871 }
34872
34873
34874 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34875 PyObject *resultobj;
34876 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34877 size_t arg2 ;
34878 wxMenu *result;
34879 PyObject * obj0 = 0 ;
34880 PyObject * obj1 = 0 ;
34881 char *kwnames[] = {
34882 (char *) "self",(char *) "pos", NULL
34883 };
34884
34885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34887 if (SWIG_arg_fail(1)) SWIG_fail;
34888 {
34889 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34890 if (SWIG_arg_fail(2)) SWIG_fail;
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34895
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = wxPyMake_wxObject(result, 0);
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj;
34910 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34911 size_t arg2 ;
34912 wxMenu *arg3 = (wxMenu *) 0 ;
34913 wxString *arg4 = 0 ;
34914 wxMenu *result;
34915 bool temp4 = false ;
34916 PyObject * obj0 = 0 ;
34917 PyObject * obj1 = 0 ;
34918 PyObject * obj2 = 0 ;
34919 PyObject * obj3 = 0 ;
34920 char *kwnames[] = {
34921 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34922 };
34923
34924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34926 if (SWIG_arg_fail(1)) SWIG_fail;
34927 {
34928 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34929 if (SWIG_arg_fail(2)) SWIG_fail;
34930 }
34931 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34932 if (SWIG_arg_fail(3)) SWIG_fail;
34933 {
34934 arg4 = wxString_in_helper(obj3);
34935 if (arg4 == NULL) SWIG_fail;
34936 temp4 = true;
34937 }
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34941
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 {
34946 resultobj = wxPyMake_wxObject(result, 0);
34947 }
34948 {
34949 if (temp4)
34950 delete arg4;
34951 }
34952 return resultobj;
34953 fail:
34954 {
34955 if (temp4)
34956 delete arg4;
34957 }
34958 return NULL;
34959 }
34960
34961
34962 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34963 PyObject *resultobj;
34964 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34965 size_t arg2 ;
34966 wxMenu *result;
34967 PyObject * obj0 = 0 ;
34968 PyObject * obj1 = 0 ;
34969 char *kwnames[] = {
34970 (char *) "self",(char *) "pos", NULL
34971 };
34972
34973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34975 if (SWIG_arg_fail(1)) SWIG_fail;
34976 {
34977 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34978 if (SWIG_arg_fail(2)) SWIG_fail;
34979 }
34980 {
34981 PyThreadState* __tstate = wxPyBeginAllowThreads();
34982 result = (wxMenu *)(arg1)->Remove(arg2);
34983
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 {
34988 resultobj = wxPyMake_wxObject(result, 0);
34989 }
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34997 PyObject *resultobj;
34998 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34999 size_t arg2 ;
35000 bool arg3 ;
35001 PyObject * obj0 = 0 ;
35002 PyObject * obj1 = 0 ;
35003 PyObject * obj2 = 0 ;
35004 char *kwnames[] = {
35005 (char *) "self",(char *) "pos",(char *) "enable", NULL
35006 };
35007
35008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35010 if (SWIG_arg_fail(1)) SWIG_fail;
35011 {
35012 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35013 if (SWIG_arg_fail(2)) SWIG_fail;
35014 }
35015 {
35016 arg3 = (bool)(SWIG_As_bool(obj2));
35017 if (SWIG_arg_fail(3)) SWIG_fail;
35018 }
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 (arg1)->EnableTop(arg2,arg3);
35022
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 Py_INCREF(Py_None); resultobj = Py_None;
35027 return resultobj;
35028 fail:
35029 return NULL;
35030 }
35031
35032
35033 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35034 PyObject *resultobj;
35035 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35036 size_t arg2 ;
35037 bool result;
35038 PyObject * obj0 = 0 ;
35039 PyObject * obj1 = 0 ;
35040 char *kwnames[] = {
35041 (char *) "self",(char *) "pos", NULL
35042 };
35043
35044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35046 if (SWIG_arg_fail(1)) SWIG_fail;
35047 {
35048 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35049 if (SWIG_arg_fail(2)) SWIG_fail;
35050 }
35051 {
35052 PyThreadState* __tstate = wxPyBeginAllowThreads();
35053 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35054
35055 wxPyEndAllowThreads(__tstate);
35056 if (PyErr_Occurred()) SWIG_fail;
35057 }
35058 {
35059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35060 }
35061 return resultobj;
35062 fail:
35063 return NULL;
35064 }
35065
35066
35067 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35068 PyObject *resultobj;
35069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35070 size_t arg2 ;
35071 wxString *arg3 = 0 ;
35072 bool temp3 = false ;
35073 PyObject * obj0 = 0 ;
35074 PyObject * obj1 = 0 ;
35075 PyObject * obj2 = 0 ;
35076 char *kwnames[] = {
35077 (char *) "self",(char *) "pos",(char *) "label", NULL
35078 };
35079
35080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35082 if (SWIG_arg_fail(1)) SWIG_fail;
35083 {
35084 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35085 if (SWIG_arg_fail(2)) SWIG_fail;
35086 }
35087 {
35088 arg3 = wxString_in_helper(obj2);
35089 if (arg3 == NULL) SWIG_fail;
35090 temp3 = true;
35091 }
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35095
35096 wxPyEndAllowThreads(__tstate);
35097 if (PyErr_Occurred()) SWIG_fail;
35098 }
35099 Py_INCREF(Py_None); resultobj = Py_None;
35100 {
35101 if (temp3)
35102 delete arg3;
35103 }
35104 return resultobj;
35105 fail:
35106 {
35107 if (temp3)
35108 delete arg3;
35109 }
35110 return NULL;
35111 }
35112
35113
35114 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj;
35116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35117 size_t arg2 ;
35118 wxString result;
35119 PyObject * obj0 = 0 ;
35120 PyObject * obj1 = 0 ;
35121 char *kwnames[] = {
35122 (char *) "self",(char *) "pos", NULL
35123 };
35124
35125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35127 if (SWIG_arg_fail(1)) SWIG_fail;
35128 {
35129 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35130 if (SWIG_arg_fail(2)) SWIG_fail;
35131 }
35132 {
35133 PyThreadState* __tstate = wxPyBeginAllowThreads();
35134 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35135
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 {
35140 #if wxUSE_UNICODE
35141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35142 #else
35143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35144 #endif
35145 }
35146 return resultobj;
35147 fail:
35148 return NULL;
35149 }
35150
35151
35152 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35153 PyObject *resultobj;
35154 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35155 wxString *arg2 = 0 ;
35156 wxString *arg3 = 0 ;
35157 int result;
35158 bool temp2 = false ;
35159 bool temp3 = false ;
35160 PyObject * obj0 = 0 ;
35161 PyObject * obj1 = 0 ;
35162 PyObject * obj2 = 0 ;
35163 char *kwnames[] = {
35164 (char *) "self",(char *) "menu",(char *) "item", NULL
35165 };
35166
35167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35169 if (SWIG_arg_fail(1)) SWIG_fail;
35170 {
35171 arg2 = wxString_in_helper(obj1);
35172 if (arg2 == NULL) SWIG_fail;
35173 temp2 = true;
35174 }
35175 {
35176 arg3 = wxString_in_helper(obj2);
35177 if (arg3 == NULL) SWIG_fail;
35178 temp3 = true;
35179 }
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35183
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 resultobj = SWIG_From_int((int)(result));
35189 }
35190 {
35191 if (temp2)
35192 delete arg2;
35193 }
35194 {
35195 if (temp3)
35196 delete arg3;
35197 }
35198 return resultobj;
35199 fail:
35200 {
35201 if (temp2)
35202 delete arg2;
35203 }
35204 {
35205 if (temp3)
35206 delete arg3;
35207 }
35208 return NULL;
35209 }
35210
35211
35212 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35213 PyObject *resultobj;
35214 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35215 int arg2 ;
35216 wxMenuItem *result;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 char *kwnames[] = {
35220 (char *) "self",(char *) "id", NULL
35221 };
35222
35223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35225 if (SWIG_arg_fail(1)) SWIG_fail;
35226 {
35227 arg2 = (int)(SWIG_As_int(obj1));
35228 if (SWIG_arg_fail(2)) SWIG_fail;
35229 }
35230 {
35231 PyThreadState* __tstate = wxPyBeginAllowThreads();
35232 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35233
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 {
35238 resultobj = wxPyMake_wxObject(result, 0);
35239 }
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35247 PyObject *resultobj;
35248 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35249 wxString *arg2 = 0 ;
35250 int result;
35251 bool temp2 = false ;
35252 PyObject * obj0 = 0 ;
35253 PyObject * obj1 = 0 ;
35254 char *kwnames[] = {
35255 (char *) "self",(char *) "title", NULL
35256 };
35257
35258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35260 if (SWIG_arg_fail(1)) SWIG_fail;
35261 {
35262 arg2 = wxString_in_helper(obj1);
35263 if (arg2 == NULL) SWIG_fail;
35264 temp2 = true;
35265 }
35266 {
35267 PyThreadState* __tstate = wxPyBeginAllowThreads();
35268 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35269
35270 wxPyEndAllowThreads(__tstate);
35271 if (PyErr_Occurred()) SWIG_fail;
35272 }
35273 {
35274 resultobj = SWIG_From_int((int)(result));
35275 }
35276 {
35277 if (temp2)
35278 delete arg2;
35279 }
35280 return resultobj;
35281 fail:
35282 {
35283 if (temp2)
35284 delete arg2;
35285 }
35286 return NULL;
35287 }
35288
35289
35290 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35291 PyObject *resultobj;
35292 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35293 int arg2 ;
35294 bool arg3 ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 PyObject * obj2 = 0 ;
35298 char *kwnames[] = {
35299 (char *) "self",(char *) "id",(char *) "enable", NULL
35300 };
35301
35302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",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 = (int)(SWIG_As_int(obj1));
35307 if (SWIG_arg_fail(2)) SWIG_fail;
35308 }
35309 {
35310 arg3 = (bool)(SWIG_As_bool(obj2));
35311 if (SWIG_arg_fail(3)) SWIG_fail;
35312 }
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 (arg1)->Enable(arg2,arg3);
35316
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 Py_INCREF(Py_None); resultobj = Py_None;
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35328 PyObject *resultobj;
35329 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35330 int arg2 ;
35331 bool arg3 ;
35332 PyObject * obj0 = 0 ;
35333 PyObject * obj1 = 0 ;
35334 PyObject * obj2 = 0 ;
35335 char *kwnames[] = {
35336 (char *) "self",(char *) "id",(char *) "check", NULL
35337 };
35338
35339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35341 if (SWIG_arg_fail(1)) SWIG_fail;
35342 {
35343 arg2 = (int)(SWIG_As_int(obj1));
35344 if (SWIG_arg_fail(2)) SWIG_fail;
35345 }
35346 {
35347 arg3 = (bool)(SWIG_As_bool(obj2));
35348 if (SWIG_arg_fail(3)) SWIG_fail;
35349 }
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 (arg1)->Check(arg2,arg3);
35353
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 Py_INCREF(Py_None); resultobj = Py_None;
35358 return resultobj;
35359 fail:
35360 return NULL;
35361 }
35362
35363
35364 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35365 PyObject *resultobj;
35366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35367 int arg2 ;
35368 bool result;
35369 PyObject * obj0 = 0 ;
35370 PyObject * obj1 = 0 ;
35371 char *kwnames[] = {
35372 (char *) "self",(char *) "id", NULL
35373 };
35374
35375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35377 if (SWIG_arg_fail(1)) SWIG_fail;
35378 {
35379 arg2 = (int)(SWIG_As_int(obj1));
35380 if (SWIG_arg_fail(2)) SWIG_fail;
35381 }
35382 {
35383 PyThreadState* __tstate = wxPyBeginAllowThreads();
35384 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35385
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 {
35390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35391 }
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj;
35400 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35401 int arg2 ;
35402 bool result;
35403 PyObject * obj0 = 0 ;
35404 PyObject * obj1 = 0 ;
35405 char *kwnames[] = {
35406 (char *) "self",(char *) "id", NULL
35407 };
35408
35409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35411 if (SWIG_arg_fail(1)) SWIG_fail;
35412 {
35413 arg2 = (int)(SWIG_As_int(obj1));
35414 if (SWIG_arg_fail(2)) SWIG_fail;
35415 }
35416 {
35417 PyThreadState* __tstate = wxPyBeginAllowThreads();
35418 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35419
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 {
35424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35425 }
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35433 PyObject *resultobj;
35434 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35435 int arg2 ;
35436 wxString *arg3 = 0 ;
35437 bool temp3 = false ;
35438 PyObject * obj0 = 0 ;
35439 PyObject * obj1 = 0 ;
35440 PyObject * obj2 = 0 ;
35441 char *kwnames[] = {
35442 (char *) "self",(char *) "id",(char *) "label", NULL
35443 };
35444
35445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35447 if (SWIG_arg_fail(1)) SWIG_fail;
35448 {
35449 arg2 = (int)(SWIG_As_int(obj1));
35450 if (SWIG_arg_fail(2)) SWIG_fail;
35451 }
35452 {
35453 arg3 = wxString_in_helper(obj2);
35454 if (arg3 == NULL) SWIG_fail;
35455 temp3 = true;
35456 }
35457 {
35458 PyThreadState* __tstate = wxPyBeginAllowThreads();
35459 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35460
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 Py_INCREF(Py_None); resultobj = Py_None;
35465 {
35466 if (temp3)
35467 delete arg3;
35468 }
35469 return resultobj;
35470 fail:
35471 {
35472 if (temp3)
35473 delete arg3;
35474 }
35475 return NULL;
35476 }
35477
35478
35479 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35480 PyObject *resultobj;
35481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35482 int arg2 ;
35483 wxString result;
35484 PyObject * obj0 = 0 ;
35485 PyObject * obj1 = 0 ;
35486 char *kwnames[] = {
35487 (char *) "self",(char *) "id", NULL
35488 };
35489
35490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35492 if (SWIG_arg_fail(1)) SWIG_fail;
35493 {
35494 arg2 = (int)(SWIG_As_int(obj1));
35495 if (SWIG_arg_fail(2)) SWIG_fail;
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 #if wxUSE_UNICODE
35506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35507 #else
35508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35509 #endif
35510 }
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj;
35519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35520 int arg2 ;
35521 wxString *arg3 = 0 ;
35522 bool temp3 = false ;
35523 PyObject * obj0 = 0 ;
35524 PyObject * obj1 = 0 ;
35525 PyObject * obj2 = 0 ;
35526 char *kwnames[] = {
35527 (char *) "self",(char *) "id",(char *) "helpString", NULL
35528 };
35529
35530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35532 if (SWIG_arg_fail(1)) SWIG_fail;
35533 {
35534 arg2 = (int)(SWIG_As_int(obj1));
35535 if (SWIG_arg_fail(2)) SWIG_fail;
35536 }
35537 {
35538 arg3 = wxString_in_helper(obj2);
35539 if (arg3 == NULL) SWIG_fail;
35540 temp3 = true;
35541 }
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35545
35546 wxPyEndAllowThreads(__tstate);
35547 if (PyErr_Occurred()) SWIG_fail;
35548 }
35549 Py_INCREF(Py_None); resultobj = Py_None;
35550 {
35551 if (temp3)
35552 delete arg3;
35553 }
35554 return resultobj;
35555 fail:
35556 {
35557 if (temp3)
35558 delete arg3;
35559 }
35560 return NULL;
35561 }
35562
35563
35564 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35565 PyObject *resultobj;
35566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35567 int arg2 ;
35568 wxString result;
35569 PyObject * obj0 = 0 ;
35570 PyObject * obj1 = 0 ;
35571 char *kwnames[] = {
35572 (char *) "self",(char *) "id", NULL
35573 };
35574
35575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35577 if (SWIG_arg_fail(1)) SWIG_fail;
35578 {
35579 arg2 = (int)(SWIG_As_int(obj1));
35580 if (SWIG_arg_fail(2)) SWIG_fail;
35581 }
35582 {
35583 PyThreadState* __tstate = wxPyBeginAllowThreads();
35584 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35585
35586 wxPyEndAllowThreads(__tstate);
35587 if (PyErr_Occurred()) SWIG_fail;
35588 }
35589 {
35590 #if wxUSE_UNICODE
35591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35592 #else
35593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35594 #endif
35595 }
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj;
35604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35605 wxFrame *result;
35606 PyObject * obj0 = 0 ;
35607 char *kwnames[] = {
35608 (char *) "self", NULL
35609 };
35610
35611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35613 if (SWIG_arg_fail(1)) SWIG_fail;
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35617
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 {
35622 resultobj = wxPyMake_wxObject(result, 0);
35623 }
35624 return resultobj;
35625 fail:
35626 return NULL;
35627 }
35628
35629
35630 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35631 PyObject *resultobj;
35632 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35633 bool result;
35634 PyObject * obj0 = 0 ;
35635 char *kwnames[] = {
35636 (char *) "self", NULL
35637 };
35638
35639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35641 if (SWIG_arg_fail(1)) SWIG_fail;
35642 {
35643 PyThreadState* __tstate = wxPyBeginAllowThreads();
35644 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35645
35646 wxPyEndAllowThreads(__tstate);
35647 if (PyErr_Occurred()) SWIG_fail;
35648 }
35649 {
35650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35651 }
35652 return resultobj;
35653 fail:
35654 return NULL;
35655 }
35656
35657
35658 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35659 PyObject *resultobj;
35660 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35661 wxFrame *arg2 = (wxFrame *) 0 ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 char *kwnames[] = {
35665 (char *) "self",(char *) "frame", NULL
35666 };
35667
35668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35670 if (SWIG_arg_fail(1)) SWIG_fail;
35671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35672 if (SWIG_arg_fail(2)) SWIG_fail;
35673 {
35674 PyThreadState* __tstate = wxPyBeginAllowThreads();
35675 (arg1)->Attach(arg2);
35676
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 Py_INCREF(Py_None); resultobj = Py_None;
35681 return resultobj;
35682 fail:
35683 return NULL;
35684 }
35685
35686
35687 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35688 PyObject *resultobj;
35689 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35690 PyObject * obj0 = 0 ;
35691 char *kwnames[] = {
35692 (char *) "self", NULL
35693 };
35694
35695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35697 if (SWIG_arg_fail(1)) SWIG_fail;
35698 {
35699 PyThreadState* __tstate = wxPyBeginAllowThreads();
35700 (arg1)->Detach();
35701
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 Py_INCREF(Py_None); resultobj = Py_None;
35706 return resultobj;
35707 fail:
35708 return NULL;
35709 }
35710
35711
35712 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35713 PyObject *obj;
35714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35715 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35716 Py_INCREF(obj);
35717 return Py_BuildValue((char *)"");
35718 }
35719 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj;
35721 wxMenu *arg1 = (wxMenu *) NULL ;
35722 int arg2 = (int) wxID_ANY ;
35723 wxString const &arg3_defvalue = wxPyEmptyString ;
35724 wxString *arg3 = (wxString *) &arg3_defvalue ;
35725 wxString const &arg4_defvalue = wxPyEmptyString ;
35726 wxString *arg4 = (wxString *) &arg4_defvalue ;
35727 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35728 wxMenu *arg6 = (wxMenu *) NULL ;
35729 wxMenuItem *result;
35730 bool temp3 = false ;
35731 bool temp4 = false ;
35732 PyObject * obj0 = 0 ;
35733 PyObject * obj1 = 0 ;
35734 PyObject * obj2 = 0 ;
35735 PyObject * obj3 = 0 ;
35736 PyObject * obj4 = 0 ;
35737 PyObject * obj5 = 0 ;
35738 char *kwnames[] = {
35739 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35740 };
35741
35742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35743 if (obj0) {
35744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35745 if (SWIG_arg_fail(1)) SWIG_fail;
35746 }
35747 if (obj1) {
35748 {
35749 arg2 = (int)(SWIG_As_int(obj1));
35750 if (SWIG_arg_fail(2)) SWIG_fail;
35751 }
35752 }
35753 if (obj2) {
35754 {
35755 arg3 = wxString_in_helper(obj2);
35756 if (arg3 == NULL) SWIG_fail;
35757 temp3 = true;
35758 }
35759 }
35760 if (obj3) {
35761 {
35762 arg4 = wxString_in_helper(obj3);
35763 if (arg4 == NULL) SWIG_fail;
35764 temp4 = true;
35765 }
35766 }
35767 if (obj4) {
35768 {
35769 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35770 if (SWIG_arg_fail(5)) SWIG_fail;
35771 }
35772 }
35773 if (obj5) {
35774 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35775 if (SWIG_arg_fail(6)) SWIG_fail;
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35780
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 {
35785 resultobj = wxPyMake_wxObject(result, 1);
35786 }
35787 {
35788 if (temp3)
35789 delete arg3;
35790 }
35791 {
35792 if (temp4)
35793 delete arg4;
35794 }
35795 return resultobj;
35796 fail:
35797 {
35798 if (temp3)
35799 delete arg3;
35800 }
35801 {
35802 if (temp4)
35803 delete arg4;
35804 }
35805 return NULL;
35806 }
35807
35808
35809 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj;
35811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35812 wxMenu *result;
35813 PyObject * obj0 = 0 ;
35814 char *kwnames[] = {
35815 (char *) "self", NULL
35816 };
35817
35818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35820 if (SWIG_arg_fail(1)) SWIG_fail;
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35824
35825 wxPyEndAllowThreads(__tstate);
35826 if (PyErr_Occurred()) SWIG_fail;
35827 }
35828 {
35829 resultobj = wxPyMake_wxObject(result, 0);
35830 }
35831 return resultobj;
35832 fail:
35833 return NULL;
35834 }
35835
35836
35837 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj;
35839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35840 wxMenu *arg2 = (wxMenu *) 0 ;
35841 PyObject * obj0 = 0 ;
35842 PyObject * obj1 = 0 ;
35843 char *kwnames[] = {
35844 (char *) "self",(char *) "menu", NULL
35845 };
35846
35847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35849 if (SWIG_arg_fail(1)) SWIG_fail;
35850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(2)) SWIG_fail;
35852 {
35853 PyThreadState* __tstate = wxPyBeginAllowThreads();
35854 (arg1)->SetMenu(arg2);
35855
35856 wxPyEndAllowThreads(__tstate);
35857 if (PyErr_Occurred()) SWIG_fail;
35858 }
35859 Py_INCREF(Py_None); resultobj = Py_None;
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj;
35868 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35869 int arg2 ;
35870 PyObject * obj0 = 0 ;
35871 PyObject * obj1 = 0 ;
35872 char *kwnames[] = {
35873 (char *) "self",(char *) "id", NULL
35874 };
35875
35876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35878 if (SWIG_arg_fail(1)) SWIG_fail;
35879 {
35880 arg2 = (int)(SWIG_As_int(obj1));
35881 if (SWIG_arg_fail(2)) SWIG_fail;
35882 }
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 (arg1)->SetId(arg2);
35886
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 Py_INCREF(Py_None); resultobj = Py_None;
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35898 PyObject *resultobj;
35899 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35900 int result;
35901 PyObject * obj0 = 0 ;
35902 char *kwnames[] = {
35903 (char *) "self", NULL
35904 };
35905
35906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35908 if (SWIG_arg_fail(1)) SWIG_fail;
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = (int)((wxMenuItem const *)arg1)->GetId();
35912
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 {
35917 resultobj = SWIG_From_int((int)(result));
35918 }
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj;
35927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35928 bool result;
35929 PyObject * obj0 = 0 ;
35930 char *kwnames[] = {
35931 (char *) "self", NULL
35932 };
35933
35934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35936 if (SWIG_arg_fail(1)) SWIG_fail;
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35940
35941 wxPyEndAllowThreads(__tstate);
35942 if (PyErr_Occurred()) SWIG_fail;
35943 }
35944 {
35945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35946 }
35947 return resultobj;
35948 fail:
35949 return NULL;
35950 }
35951
35952
35953 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35954 PyObject *resultobj;
35955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35956 wxString *arg2 = 0 ;
35957 bool temp2 = false ;
35958 PyObject * obj0 = 0 ;
35959 PyObject * obj1 = 0 ;
35960 char *kwnames[] = {
35961 (char *) "self",(char *) "str", NULL
35962 };
35963
35964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35966 if (SWIG_arg_fail(1)) SWIG_fail;
35967 {
35968 arg2 = wxString_in_helper(obj1);
35969 if (arg2 == NULL) SWIG_fail;
35970 temp2 = true;
35971 }
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->SetText((wxString const &)*arg2);
35975
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 Py_INCREF(Py_None); resultobj = Py_None;
35980 {
35981 if (temp2)
35982 delete arg2;
35983 }
35984 return resultobj;
35985 fail:
35986 {
35987 if (temp2)
35988 delete arg2;
35989 }
35990 return NULL;
35991 }
35992
35993
35994 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35995 PyObject *resultobj;
35996 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35997 wxString result;
35998 PyObject * obj0 = 0 ;
35999 char *kwnames[] = {
36000 (char *) "self", NULL
36001 };
36002
36003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36005 if (SWIG_arg_fail(1)) SWIG_fail;
36006 {
36007 PyThreadState* __tstate = wxPyBeginAllowThreads();
36008 result = ((wxMenuItem const *)arg1)->GetLabel();
36009
36010 wxPyEndAllowThreads(__tstate);
36011 if (PyErr_Occurred()) SWIG_fail;
36012 }
36013 {
36014 #if wxUSE_UNICODE
36015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36016 #else
36017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36018 #endif
36019 }
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36027 PyObject *resultobj;
36028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36029 wxString *result;
36030 PyObject * obj0 = 0 ;
36031 char *kwnames[] = {
36032 (char *) "self", NULL
36033 };
36034
36035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36037 if (SWIG_arg_fail(1)) SWIG_fail;
36038 {
36039 PyThreadState* __tstate = wxPyBeginAllowThreads();
36040 {
36041 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36042 result = (wxString *) &_result_ref;
36043 }
36044
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 #if wxUSE_UNICODE
36050 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36051 #else
36052 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36053 #endif
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj;
36063 wxString *arg1 = 0 ;
36064 wxString result;
36065 bool temp1 = false ;
36066 PyObject * obj0 = 0 ;
36067 char *kwnames[] = {
36068 (char *) "text", NULL
36069 };
36070
36071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36072 {
36073 arg1 = wxString_in_helper(obj0);
36074 if (arg1 == NULL) SWIG_fail;
36075 temp1 = true;
36076 }
36077 {
36078 PyThreadState* __tstate = wxPyBeginAllowThreads();
36079 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36080
36081 wxPyEndAllowThreads(__tstate);
36082 if (PyErr_Occurred()) SWIG_fail;
36083 }
36084 {
36085 #if wxUSE_UNICODE
36086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36087 #else
36088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36089 #endif
36090 }
36091 {
36092 if (temp1)
36093 delete arg1;
36094 }
36095 return resultobj;
36096 fail:
36097 {
36098 if (temp1)
36099 delete arg1;
36100 }
36101 return NULL;
36102 }
36103
36104
36105 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj;
36107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36108 wxItemKind result;
36109 PyObject * obj0 = 0 ;
36110 char *kwnames[] = {
36111 (char *) "self", NULL
36112 };
36113
36114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36116 if (SWIG_arg_fail(1)) SWIG_fail;
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36120
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 resultobj = SWIG_From_int((result));
36125 return resultobj;
36126 fail:
36127 return NULL;
36128 }
36129
36130
36131 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36132 PyObject *resultobj;
36133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36134 wxItemKind arg2 ;
36135 PyObject * obj0 = 0 ;
36136 PyObject * obj1 = 0 ;
36137 char *kwnames[] = {
36138 (char *) "self",(char *) "kind", NULL
36139 };
36140
36141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36143 if (SWIG_arg_fail(1)) SWIG_fail;
36144 {
36145 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36146 if (SWIG_arg_fail(2)) SWIG_fail;
36147 }
36148 {
36149 PyThreadState* __tstate = wxPyBeginAllowThreads();
36150 (arg1)->SetKind((wxItemKind )arg2);
36151
36152 wxPyEndAllowThreads(__tstate);
36153 if (PyErr_Occurred()) SWIG_fail;
36154 }
36155 Py_INCREF(Py_None); resultobj = Py_None;
36156 return resultobj;
36157 fail:
36158 return NULL;
36159 }
36160
36161
36162 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36163 PyObject *resultobj;
36164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36165 bool arg2 ;
36166 PyObject * obj0 = 0 ;
36167 PyObject * obj1 = 0 ;
36168 char *kwnames[] = {
36169 (char *) "self",(char *) "checkable", NULL
36170 };
36171
36172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36174 if (SWIG_arg_fail(1)) SWIG_fail;
36175 {
36176 arg2 = (bool)(SWIG_As_bool(obj1));
36177 if (SWIG_arg_fail(2)) SWIG_fail;
36178 }
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 (arg1)->SetCheckable(arg2);
36182
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 Py_INCREF(Py_None); resultobj = Py_None;
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36194 PyObject *resultobj;
36195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36196 bool result;
36197 PyObject * obj0 = 0 ;
36198 char *kwnames[] = {
36199 (char *) "self", NULL
36200 };
36201
36202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36204 if (SWIG_arg_fail(1)) SWIG_fail;
36205 {
36206 PyThreadState* __tstate = wxPyBeginAllowThreads();
36207 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36208
36209 wxPyEndAllowThreads(__tstate);
36210 if (PyErr_Occurred()) SWIG_fail;
36211 }
36212 {
36213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36214 }
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36222 PyObject *resultobj;
36223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36224 bool result;
36225 PyObject * obj0 = 0 ;
36226 char *kwnames[] = {
36227 (char *) "self", NULL
36228 };
36229
36230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36232 if (SWIG_arg_fail(1)) SWIG_fail;
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36236
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 {
36241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36242 }
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36250 PyObject *resultobj;
36251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36252 wxMenu *arg2 = (wxMenu *) 0 ;
36253 PyObject * obj0 = 0 ;
36254 PyObject * obj1 = 0 ;
36255 char *kwnames[] = {
36256 (char *) "self",(char *) "menu", NULL
36257 };
36258
36259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(1)) SWIG_fail;
36262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36263 if (SWIG_arg_fail(2)) SWIG_fail;
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 (arg1)->SetSubMenu(arg2);
36267
36268 wxPyEndAllowThreads(__tstate);
36269 if (PyErr_Occurred()) SWIG_fail;
36270 }
36271 Py_INCREF(Py_None); resultobj = Py_None;
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj;
36280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36281 wxMenu *result;
36282 PyObject * obj0 = 0 ;
36283 char *kwnames[] = {
36284 (char *) "self", NULL
36285 };
36286
36287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36289 if (SWIG_arg_fail(1)) SWIG_fail;
36290 {
36291 PyThreadState* __tstate = wxPyBeginAllowThreads();
36292 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36293
36294 wxPyEndAllowThreads(__tstate);
36295 if (PyErr_Occurred()) SWIG_fail;
36296 }
36297 {
36298 resultobj = wxPyMake_wxObject(result, 0);
36299 }
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36307 PyObject *resultobj;
36308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36309 bool arg2 = (bool) true ;
36310 PyObject * obj0 = 0 ;
36311 PyObject * obj1 = 0 ;
36312 char *kwnames[] = {
36313 (char *) "self",(char *) "enable", NULL
36314 };
36315
36316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36318 if (SWIG_arg_fail(1)) SWIG_fail;
36319 if (obj1) {
36320 {
36321 arg2 = (bool)(SWIG_As_bool(obj1));
36322 if (SWIG_arg_fail(2)) SWIG_fail;
36323 }
36324 }
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 (arg1)->Enable(arg2);
36328
36329 wxPyEndAllowThreads(__tstate);
36330 if (PyErr_Occurred()) SWIG_fail;
36331 }
36332 Py_INCREF(Py_None); resultobj = Py_None;
36333 return resultobj;
36334 fail:
36335 return NULL;
36336 }
36337
36338
36339 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36340 PyObject *resultobj;
36341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36342 bool result;
36343 PyObject * obj0 = 0 ;
36344 char *kwnames[] = {
36345 (char *) "self", NULL
36346 };
36347
36348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36350 if (SWIG_arg_fail(1)) SWIG_fail;
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36354
36355 wxPyEndAllowThreads(__tstate);
36356 if (PyErr_Occurred()) SWIG_fail;
36357 }
36358 {
36359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36360 }
36361 return resultobj;
36362 fail:
36363 return NULL;
36364 }
36365
36366
36367 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36368 PyObject *resultobj;
36369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36370 bool arg2 = (bool) true ;
36371 PyObject * obj0 = 0 ;
36372 PyObject * obj1 = 0 ;
36373 char *kwnames[] = {
36374 (char *) "self",(char *) "check", NULL
36375 };
36376
36377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36379 if (SWIG_arg_fail(1)) SWIG_fail;
36380 if (obj1) {
36381 {
36382 arg2 = (bool)(SWIG_As_bool(obj1));
36383 if (SWIG_arg_fail(2)) SWIG_fail;
36384 }
36385 }
36386 {
36387 PyThreadState* __tstate = wxPyBeginAllowThreads();
36388 (arg1)->Check(arg2);
36389
36390 wxPyEndAllowThreads(__tstate);
36391 if (PyErr_Occurred()) SWIG_fail;
36392 }
36393 Py_INCREF(Py_None); resultobj = Py_None;
36394 return resultobj;
36395 fail:
36396 return NULL;
36397 }
36398
36399
36400 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36401 PyObject *resultobj;
36402 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36403 bool result;
36404 PyObject * obj0 = 0 ;
36405 char *kwnames[] = {
36406 (char *) "self", NULL
36407 };
36408
36409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36411 if (SWIG_arg_fail(1)) SWIG_fail;
36412 {
36413 PyThreadState* __tstate = wxPyBeginAllowThreads();
36414 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36415
36416 wxPyEndAllowThreads(__tstate);
36417 if (PyErr_Occurred()) SWIG_fail;
36418 }
36419 {
36420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36421 }
36422 return resultobj;
36423 fail:
36424 return NULL;
36425 }
36426
36427
36428 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36429 PyObject *resultobj;
36430 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36431 PyObject * obj0 = 0 ;
36432 char *kwnames[] = {
36433 (char *) "self", NULL
36434 };
36435
36436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36438 if (SWIG_arg_fail(1)) SWIG_fail;
36439 {
36440 PyThreadState* __tstate = wxPyBeginAllowThreads();
36441 (arg1)->Toggle();
36442
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 Py_INCREF(Py_None); resultobj = Py_None;
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj;
36455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36456 wxString *arg2 = 0 ;
36457 bool temp2 = false ;
36458 PyObject * obj0 = 0 ;
36459 PyObject * obj1 = 0 ;
36460 char *kwnames[] = {
36461 (char *) "self",(char *) "str", NULL
36462 };
36463
36464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36466 if (SWIG_arg_fail(1)) SWIG_fail;
36467 {
36468 arg2 = wxString_in_helper(obj1);
36469 if (arg2 == NULL) SWIG_fail;
36470 temp2 = true;
36471 }
36472 {
36473 PyThreadState* __tstate = wxPyBeginAllowThreads();
36474 (arg1)->SetHelp((wxString const &)*arg2);
36475
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 Py_INCREF(Py_None); resultobj = Py_None;
36480 {
36481 if (temp2)
36482 delete arg2;
36483 }
36484 return resultobj;
36485 fail:
36486 {
36487 if (temp2)
36488 delete arg2;
36489 }
36490 return NULL;
36491 }
36492
36493
36494 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36495 PyObject *resultobj;
36496 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36497 wxString *result;
36498 PyObject * obj0 = 0 ;
36499 char *kwnames[] = {
36500 (char *) "self", NULL
36501 };
36502
36503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36505 if (SWIG_arg_fail(1)) SWIG_fail;
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 {
36509 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36510 result = (wxString *) &_result_ref;
36511 }
36512
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 {
36517 #if wxUSE_UNICODE
36518 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36519 #else
36520 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36521 #endif
36522 }
36523 return resultobj;
36524 fail:
36525 return NULL;
36526 }
36527
36528
36529 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36530 PyObject *resultobj;
36531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36532 wxAcceleratorEntry *result;
36533 PyObject * obj0 = 0 ;
36534 char *kwnames[] = {
36535 (char *) "self", NULL
36536 };
36537
36538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36540 if (SWIG_arg_fail(1)) SWIG_fail;
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36544
36545 wxPyEndAllowThreads(__tstate);
36546 if (PyErr_Occurred()) SWIG_fail;
36547 }
36548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36549 return resultobj;
36550 fail:
36551 return NULL;
36552 }
36553
36554
36555 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36556 PyObject *resultobj;
36557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36558 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36559 PyObject * obj0 = 0 ;
36560 PyObject * obj1 = 0 ;
36561 char *kwnames[] = {
36562 (char *) "self",(char *) "accel", NULL
36563 };
36564
36565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36567 if (SWIG_arg_fail(1)) SWIG_fail;
36568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36569 if (SWIG_arg_fail(2)) SWIG_fail;
36570 {
36571 PyThreadState* __tstate = wxPyBeginAllowThreads();
36572 (arg1)->SetAccel(arg2);
36573
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 Py_INCREF(Py_None); resultobj = Py_None;
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36585 PyObject *resultobj;
36586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36587 wxFont *arg2 = 0 ;
36588 PyObject * obj0 = 0 ;
36589 PyObject * obj1 = 0 ;
36590 char *kwnames[] = {
36591 (char *) "self",(char *) "font", NULL
36592 };
36593
36594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36596 if (SWIG_arg_fail(1)) SWIG_fail;
36597 {
36598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36599 if (SWIG_arg_fail(2)) SWIG_fail;
36600 if (arg2 == NULL) {
36601 SWIG_null_ref("wxFont");
36602 }
36603 if (SWIG_arg_fail(2)) SWIG_fail;
36604 }
36605 {
36606 PyThreadState* __tstate = wxPyBeginAllowThreads();
36607 (arg1)->SetFont((wxFont const &)*arg2);
36608
36609 wxPyEndAllowThreads(__tstate);
36610 if (PyErr_Occurred()) SWIG_fail;
36611 }
36612 Py_INCREF(Py_None); resultobj = Py_None;
36613 return resultobj;
36614 fail:
36615 return NULL;
36616 }
36617
36618
36619 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36620 PyObject *resultobj;
36621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36622 wxFont result;
36623 PyObject * obj0 = 0 ;
36624 char *kwnames[] = {
36625 (char *) "self", NULL
36626 };
36627
36628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36630 if (SWIG_arg_fail(1)) SWIG_fail;
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 result = (arg1)->GetFont();
36634
36635 wxPyEndAllowThreads(__tstate);
36636 if (PyErr_Occurred()) SWIG_fail;
36637 }
36638 {
36639 wxFont * resultptr;
36640 resultptr = new wxFont((wxFont &)(result));
36641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36642 }
36643 return resultobj;
36644 fail:
36645 return NULL;
36646 }
36647
36648
36649 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36650 PyObject *resultobj;
36651 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36652 wxColour *arg2 = 0 ;
36653 wxColour temp2 ;
36654 PyObject * obj0 = 0 ;
36655 PyObject * obj1 = 0 ;
36656 char *kwnames[] = {
36657 (char *) "self",(char *) "colText", NULL
36658 };
36659
36660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36662 if (SWIG_arg_fail(1)) SWIG_fail;
36663 {
36664 arg2 = &temp2;
36665 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36666 }
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 (arg1)->SetTextColour((wxColour const &)*arg2);
36670
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 Py_INCREF(Py_None); resultobj = Py_None;
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj;
36683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36684 wxColour result;
36685 PyObject * obj0 = 0 ;
36686 char *kwnames[] = {
36687 (char *) "self", NULL
36688 };
36689
36690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36692 if (SWIG_arg_fail(1)) SWIG_fail;
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 result = (arg1)->GetTextColour();
36696
36697 wxPyEndAllowThreads(__tstate);
36698 if (PyErr_Occurred()) SWIG_fail;
36699 }
36700 {
36701 wxColour * resultptr;
36702 resultptr = new wxColour((wxColour &)(result));
36703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36704 }
36705 return resultobj;
36706 fail:
36707 return NULL;
36708 }
36709
36710
36711 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36712 PyObject *resultobj;
36713 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36714 wxColour *arg2 = 0 ;
36715 wxColour temp2 ;
36716 PyObject * obj0 = 0 ;
36717 PyObject * obj1 = 0 ;
36718 char *kwnames[] = {
36719 (char *) "self",(char *) "colBack", NULL
36720 };
36721
36722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36724 if (SWIG_arg_fail(1)) SWIG_fail;
36725 {
36726 arg2 = &temp2;
36727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36732
36733 wxPyEndAllowThreads(__tstate);
36734 if (PyErr_Occurred()) SWIG_fail;
36735 }
36736 Py_INCREF(Py_None); resultobj = Py_None;
36737 return resultobj;
36738 fail:
36739 return NULL;
36740 }
36741
36742
36743 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36744 PyObject *resultobj;
36745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36746 wxColour result;
36747 PyObject * obj0 = 0 ;
36748 char *kwnames[] = {
36749 (char *) "self", NULL
36750 };
36751
36752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36754 if (SWIG_arg_fail(1)) SWIG_fail;
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 result = (arg1)->GetBackgroundColour();
36758
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 {
36763 wxColour * resultptr;
36764 resultptr = new wxColour((wxColour &)(result));
36765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36766 }
36767 return resultobj;
36768 fail:
36769 return NULL;
36770 }
36771
36772
36773 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36774 PyObject *resultobj;
36775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36776 wxBitmap *arg2 = 0 ;
36777 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36778 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36779 PyObject * obj0 = 0 ;
36780 PyObject * obj1 = 0 ;
36781 PyObject * obj2 = 0 ;
36782 char *kwnames[] = {
36783 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36784 };
36785
36786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36788 if (SWIG_arg_fail(1)) SWIG_fail;
36789 {
36790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36791 if (SWIG_arg_fail(2)) SWIG_fail;
36792 if (arg2 == NULL) {
36793 SWIG_null_ref("wxBitmap");
36794 }
36795 if (SWIG_arg_fail(2)) SWIG_fail;
36796 }
36797 if (obj2) {
36798 {
36799 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36800 if (SWIG_arg_fail(3)) SWIG_fail;
36801 if (arg3 == NULL) {
36802 SWIG_null_ref("wxBitmap");
36803 }
36804 if (SWIG_arg_fail(3)) SWIG_fail;
36805 }
36806 }
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36810
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 Py_INCREF(Py_None); resultobj = Py_None;
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj;
36823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36824 wxBitmap *arg2 = 0 ;
36825 PyObject * obj0 = 0 ;
36826 PyObject * obj1 = 0 ;
36827 char *kwnames[] = {
36828 (char *) "self",(char *) "bmpDisabled", NULL
36829 };
36830
36831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36833 if (SWIG_arg_fail(1)) SWIG_fail;
36834 {
36835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36836 if (SWIG_arg_fail(2)) SWIG_fail;
36837 if (arg2 == NULL) {
36838 SWIG_null_ref("wxBitmap");
36839 }
36840 if (SWIG_arg_fail(2)) SWIG_fail;
36841 }
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36845
36846 wxPyEndAllowThreads(__tstate);
36847 if (PyErr_Occurred()) SWIG_fail;
36848 }
36849 Py_INCREF(Py_None); resultobj = Py_None;
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36857 PyObject *resultobj;
36858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36859 wxBitmap *result;
36860 PyObject * obj0 = 0 ;
36861 char *kwnames[] = {
36862 (char *) "self", NULL
36863 };
36864
36865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36867 if (SWIG_arg_fail(1)) SWIG_fail;
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 {
36871 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36872 result = (wxBitmap *) &_result_ref;
36873 }
36874
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 {
36879 wxBitmap* resultptr = new wxBitmap(*result);
36880 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36881 }
36882 return resultobj;
36883 fail:
36884 return NULL;
36885 }
36886
36887
36888 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36889 PyObject *resultobj;
36890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36891 int arg2 ;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char *kwnames[] = {
36895 (char *) "self",(char *) "nWidth", NULL
36896 };
36897
36898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36900 if (SWIG_arg_fail(1)) SWIG_fail;
36901 {
36902 arg2 = (int)(SWIG_As_int(obj1));
36903 if (SWIG_arg_fail(2)) SWIG_fail;
36904 }
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 (arg1)->SetMarginWidth(arg2);
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 Py_INCREF(Py_None); resultobj = Py_None;
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36920 PyObject *resultobj;
36921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36922 int result;
36923 PyObject * obj0 = 0 ;
36924 char *kwnames[] = {
36925 (char *) "self", NULL
36926 };
36927
36928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36930 if (SWIG_arg_fail(1)) SWIG_fail;
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 result = (int)(arg1)->GetMarginWidth();
36934
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 {
36939 resultobj = SWIG_From_int((int)(result));
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36948 PyObject *resultobj;
36949 int result;
36950 char *kwnames[] = {
36951 NULL
36952 };
36953
36954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 result = (int)wxMenuItem::GetDefaultMarginWidth();
36958
36959 wxPyEndAllowThreads(__tstate);
36960 if (PyErr_Occurred()) SWIG_fail;
36961 }
36962 {
36963 resultobj = SWIG_From_int((int)(result));
36964 }
36965 return resultobj;
36966 fail:
36967 return NULL;
36968 }
36969
36970
36971 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36972 PyObject *resultobj;
36973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36974 bool result;
36975 PyObject * obj0 = 0 ;
36976 char *kwnames[] = {
36977 (char *) "self", NULL
36978 };
36979
36980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36982 if (SWIG_arg_fail(1)) SWIG_fail;
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 result = (bool)(arg1)->IsOwnerDrawn();
36986
36987 wxPyEndAllowThreads(__tstate);
36988 if (PyErr_Occurred()) SWIG_fail;
36989 }
36990 {
36991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36992 }
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37000 PyObject *resultobj;
37001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37002 bool arg2 = (bool) true ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 char *kwnames[] = {
37006 (char *) "self",(char *) "ownerDrawn", NULL
37007 };
37008
37009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37011 if (SWIG_arg_fail(1)) SWIG_fail;
37012 if (obj1) {
37013 {
37014 arg2 = (bool)(SWIG_As_bool(obj1));
37015 if (SWIG_arg_fail(2)) SWIG_fail;
37016 }
37017 }
37018 {
37019 PyThreadState* __tstate = wxPyBeginAllowThreads();
37020 (arg1)->SetOwnerDrawn(arg2);
37021
37022 wxPyEndAllowThreads(__tstate);
37023 if (PyErr_Occurred()) SWIG_fail;
37024 }
37025 Py_INCREF(Py_None); resultobj = Py_None;
37026 return resultobj;
37027 fail:
37028 return NULL;
37029 }
37030
37031
37032 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37033 PyObject *resultobj;
37034 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37035 PyObject * obj0 = 0 ;
37036 char *kwnames[] = {
37037 (char *) "self", NULL
37038 };
37039
37040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37042 if (SWIG_arg_fail(1)) SWIG_fail;
37043 {
37044 PyThreadState* __tstate = wxPyBeginAllowThreads();
37045 (arg1)->ResetOwnerDrawn();
37046
37047 wxPyEndAllowThreads(__tstate);
37048 if (PyErr_Occurred()) SWIG_fail;
37049 }
37050 Py_INCREF(Py_None); resultobj = Py_None;
37051 return resultobj;
37052 fail:
37053 return NULL;
37054 }
37055
37056
37057 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37058 PyObject *resultobj;
37059 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37060 wxBitmap *arg2 = 0 ;
37061 PyObject * obj0 = 0 ;
37062 PyObject * obj1 = 0 ;
37063 char *kwnames[] = {
37064 (char *) "self",(char *) "bitmap", NULL
37065 };
37066
37067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37069 if (SWIG_arg_fail(1)) SWIG_fail;
37070 {
37071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37072 if (SWIG_arg_fail(2)) SWIG_fail;
37073 if (arg2 == NULL) {
37074 SWIG_null_ref("wxBitmap");
37075 }
37076 if (SWIG_arg_fail(2)) SWIG_fail;
37077 }
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37081
37082 wxPyEndAllowThreads(__tstate);
37083 if (PyErr_Occurred()) SWIG_fail;
37084 }
37085 Py_INCREF(Py_None); resultobj = Py_None;
37086 return resultobj;
37087 fail:
37088 return NULL;
37089 }
37090
37091
37092 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37093 PyObject *resultobj;
37094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37095 wxBitmap *result;
37096 PyObject * obj0 = 0 ;
37097 char *kwnames[] = {
37098 (char *) "self", NULL
37099 };
37100
37101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37103 if (SWIG_arg_fail(1)) SWIG_fail;
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 {
37107 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37108 result = (wxBitmap *) &_result_ref;
37109 }
37110
37111 wxPyEndAllowThreads(__tstate);
37112 if (PyErr_Occurred()) SWIG_fail;
37113 }
37114 {
37115 wxBitmap* resultptr = new wxBitmap(*result);
37116 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37117 }
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37125 PyObject *obj;
37126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37127 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37128 Py_INCREF(obj);
37129 return Py_BuildValue((char *)"");
37130 }
37131 static int _wrap_ControlNameStr_set(PyObject *) {
37132 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37133 return 1;
37134 }
37135
37136
37137 static PyObject *_wrap_ControlNameStr_get(void) {
37138 PyObject *pyobj;
37139
37140 {
37141 #if wxUSE_UNICODE
37142 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37143 #else
37144 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37145 #endif
37146 }
37147 return pyobj;
37148 }
37149
37150
37151 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37152 PyObject *resultobj;
37153 wxWindow *arg1 = (wxWindow *) 0 ;
37154 int arg2 = (int) -1 ;
37155 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37156 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37157 wxSize const &arg4_defvalue = wxDefaultSize ;
37158 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37159 long arg5 = (long) 0 ;
37160 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37161 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37162 wxString const &arg7_defvalue = wxPyControlNameStr ;
37163 wxString *arg7 = (wxString *) &arg7_defvalue ;
37164 wxControl *result;
37165 wxPoint temp3 ;
37166 wxSize temp4 ;
37167 bool temp7 = false ;
37168 PyObject * obj0 = 0 ;
37169 PyObject * obj1 = 0 ;
37170 PyObject * obj2 = 0 ;
37171 PyObject * obj3 = 0 ;
37172 PyObject * obj4 = 0 ;
37173 PyObject * obj5 = 0 ;
37174 PyObject * obj6 = 0 ;
37175 char *kwnames[] = {
37176 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37177 };
37178
37179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37181 if (SWIG_arg_fail(1)) SWIG_fail;
37182 if (obj1) {
37183 {
37184 arg2 = (int)(SWIG_As_int(obj1));
37185 if (SWIG_arg_fail(2)) SWIG_fail;
37186 }
37187 }
37188 if (obj2) {
37189 {
37190 arg3 = &temp3;
37191 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37192 }
37193 }
37194 if (obj3) {
37195 {
37196 arg4 = &temp4;
37197 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37198 }
37199 }
37200 if (obj4) {
37201 {
37202 arg5 = (long)(SWIG_As_long(obj4));
37203 if (SWIG_arg_fail(5)) SWIG_fail;
37204 }
37205 }
37206 if (obj5) {
37207 {
37208 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37209 if (SWIG_arg_fail(6)) SWIG_fail;
37210 if (arg6 == NULL) {
37211 SWIG_null_ref("wxValidator");
37212 }
37213 if (SWIG_arg_fail(6)) SWIG_fail;
37214 }
37215 }
37216 if (obj6) {
37217 {
37218 arg7 = wxString_in_helper(obj6);
37219 if (arg7 == NULL) SWIG_fail;
37220 temp7 = true;
37221 }
37222 }
37223 {
37224 if (!wxPyCheckForApp()) SWIG_fail;
37225 PyThreadState* __tstate = wxPyBeginAllowThreads();
37226 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37227
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37232 {
37233 if (temp7)
37234 delete arg7;
37235 }
37236 return resultobj;
37237 fail:
37238 {
37239 if (temp7)
37240 delete arg7;
37241 }
37242 return NULL;
37243 }
37244
37245
37246 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj;
37248 wxControl *result;
37249 char *kwnames[] = {
37250 NULL
37251 };
37252
37253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37254 {
37255 if (!wxPyCheckForApp()) SWIG_fail;
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = (wxControl *)new wxControl();
37258
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37270 PyObject *resultobj;
37271 wxControl *arg1 = (wxControl *) 0 ;
37272 wxWindow *arg2 = (wxWindow *) 0 ;
37273 int arg3 = (int) -1 ;
37274 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37275 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37276 wxSize const &arg5_defvalue = wxDefaultSize ;
37277 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37278 long arg6 = (long) 0 ;
37279 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37280 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37281 wxString const &arg8_defvalue = wxPyControlNameStr ;
37282 wxString *arg8 = (wxString *) &arg8_defvalue ;
37283 bool result;
37284 wxPoint temp4 ;
37285 wxSize temp5 ;
37286 bool temp8 = false ;
37287 PyObject * obj0 = 0 ;
37288 PyObject * obj1 = 0 ;
37289 PyObject * obj2 = 0 ;
37290 PyObject * obj3 = 0 ;
37291 PyObject * obj4 = 0 ;
37292 PyObject * obj5 = 0 ;
37293 PyObject * obj6 = 0 ;
37294 PyObject * obj7 = 0 ;
37295 char *kwnames[] = {
37296 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37297 };
37298
37299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37301 if (SWIG_arg_fail(1)) SWIG_fail;
37302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37303 if (SWIG_arg_fail(2)) SWIG_fail;
37304 if (obj2) {
37305 {
37306 arg3 = (int)(SWIG_As_int(obj2));
37307 if (SWIG_arg_fail(3)) SWIG_fail;
37308 }
37309 }
37310 if (obj3) {
37311 {
37312 arg4 = &temp4;
37313 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37314 }
37315 }
37316 if (obj4) {
37317 {
37318 arg5 = &temp5;
37319 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37320 }
37321 }
37322 if (obj5) {
37323 {
37324 arg6 = (long)(SWIG_As_long(obj5));
37325 if (SWIG_arg_fail(6)) SWIG_fail;
37326 }
37327 }
37328 if (obj6) {
37329 {
37330 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37331 if (SWIG_arg_fail(7)) SWIG_fail;
37332 if (arg7 == NULL) {
37333 SWIG_null_ref("wxValidator");
37334 }
37335 if (SWIG_arg_fail(7)) SWIG_fail;
37336 }
37337 }
37338 if (obj7) {
37339 {
37340 arg8 = wxString_in_helper(obj7);
37341 if (arg8 == NULL) SWIG_fail;
37342 temp8 = true;
37343 }
37344 }
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37348
37349 wxPyEndAllowThreads(__tstate);
37350 if (PyErr_Occurred()) SWIG_fail;
37351 }
37352 {
37353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37354 }
37355 {
37356 if (temp8)
37357 delete arg8;
37358 }
37359 return resultobj;
37360 fail:
37361 {
37362 if (temp8)
37363 delete arg8;
37364 }
37365 return NULL;
37366 }
37367
37368
37369 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj;
37371 wxControl *arg1 = (wxControl *) 0 ;
37372 wxCommandEvent *arg2 = 0 ;
37373 PyObject * obj0 = 0 ;
37374 PyObject * obj1 = 0 ;
37375 char *kwnames[] = {
37376 (char *) "self",(char *) "event", NULL
37377 };
37378
37379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37381 if (SWIG_arg_fail(1)) SWIG_fail;
37382 {
37383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37384 if (SWIG_arg_fail(2)) SWIG_fail;
37385 if (arg2 == NULL) {
37386 SWIG_null_ref("wxCommandEvent");
37387 }
37388 if (SWIG_arg_fail(2)) SWIG_fail;
37389 }
37390 {
37391 PyThreadState* __tstate = wxPyBeginAllowThreads();
37392 (arg1)->Command(*arg2);
37393
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 Py_INCREF(Py_None); resultobj = Py_None;
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37405 PyObject *resultobj;
37406 wxControl *arg1 = (wxControl *) 0 ;
37407 wxString result;
37408 PyObject * obj0 = 0 ;
37409 char *kwnames[] = {
37410 (char *) "self", NULL
37411 };
37412
37413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37415 if (SWIG_arg_fail(1)) SWIG_fail;
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 result = (arg1)->GetLabel();
37419
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 #if wxUSE_UNICODE
37425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37426 #else
37427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37428 #endif
37429 }
37430 return resultobj;
37431 fail:
37432 return NULL;
37433 }
37434
37435
37436 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37437 PyObject *resultobj;
37438 wxControl *arg1 = (wxControl *) 0 ;
37439 wxString *arg2 = 0 ;
37440 bool temp2 = false ;
37441 PyObject * obj0 = 0 ;
37442 PyObject * obj1 = 0 ;
37443 char *kwnames[] = {
37444 (char *) "self",(char *) "label", NULL
37445 };
37446
37447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37449 if (SWIG_arg_fail(1)) SWIG_fail;
37450 {
37451 arg2 = wxString_in_helper(obj1);
37452 if (arg2 == NULL) SWIG_fail;
37453 temp2 = true;
37454 }
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 (arg1)->SetLabel((wxString const &)*arg2);
37458
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 Py_INCREF(Py_None); resultobj = Py_None;
37463 {
37464 if (temp2)
37465 delete arg2;
37466 }
37467 return resultobj;
37468 fail:
37469 {
37470 if (temp2)
37471 delete arg2;
37472 }
37473 return NULL;
37474 }
37475
37476
37477 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37478 PyObject *resultobj;
37479 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37480 wxVisualAttributes result;
37481 PyObject * obj0 = 0 ;
37482 char *kwnames[] = {
37483 (char *) "variant", NULL
37484 };
37485
37486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37487 if (obj0) {
37488 {
37489 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37490 if (SWIG_arg_fail(1)) SWIG_fail;
37491 }
37492 }
37493 {
37494 if (!wxPyCheckForApp()) SWIG_fail;
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37497
37498 wxPyEndAllowThreads(__tstate);
37499 if (PyErr_Occurred()) SWIG_fail;
37500 }
37501 {
37502 wxVisualAttributes * resultptr;
37503 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37505 }
37506 return resultobj;
37507 fail:
37508 return NULL;
37509 }
37510
37511
37512 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37513 PyObject *obj;
37514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37515 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37516 Py_INCREF(obj);
37517 return Py_BuildValue((char *)"");
37518 }
37519 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37520 PyObject *resultobj;
37521 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37522 wxString *arg2 = 0 ;
37523 PyObject *arg3 = (PyObject *) NULL ;
37524 int result;
37525 bool temp2 = false ;
37526 PyObject * obj0 = 0 ;
37527 PyObject * obj1 = 0 ;
37528 PyObject * obj2 = 0 ;
37529 char *kwnames[] = {
37530 (char *) "self",(char *) "item",(char *) "clientData", NULL
37531 };
37532
37533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37535 if (SWIG_arg_fail(1)) SWIG_fail;
37536 {
37537 arg2 = wxString_in_helper(obj1);
37538 if (arg2 == NULL) SWIG_fail;
37539 temp2 = true;
37540 }
37541 if (obj2) {
37542 arg3 = obj2;
37543 }
37544 {
37545 PyThreadState* __tstate = wxPyBeginAllowThreads();
37546 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37547
37548 wxPyEndAllowThreads(__tstate);
37549 if (PyErr_Occurred()) SWIG_fail;
37550 }
37551 {
37552 resultobj = SWIG_From_int((int)(result));
37553 }
37554 {
37555 if (temp2)
37556 delete arg2;
37557 }
37558 return resultobj;
37559 fail:
37560 {
37561 if (temp2)
37562 delete arg2;
37563 }
37564 return NULL;
37565 }
37566
37567
37568 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj;
37570 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37571 wxArrayString *arg2 = 0 ;
37572 bool temp2 = false ;
37573 PyObject * obj0 = 0 ;
37574 PyObject * obj1 = 0 ;
37575 char *kwnames[] = {
37576 (char *) "self",(char *) "strings", NULL
37577 };
37578
37579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37581 if (SWIG_arg_fail(1)) SWIG_fail;
37582 {
37583 if (! PySequence_Check(obj1)) {
37584 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37585 SWIG_fail;
37586 }
37587 arg2 = new wxArrayString;
37588 temp2 = true;
37589 int i, len=PySequence_Length(obj1);
37590 for (i=0; i<len; i++) {
37591 PyObject* item = PySequence_GetItem(obj1, i);
37592 #if wxUSE_UNICODE
37593 PyObject* str = PyObject_Unicode(item);
37594 #else
37595 PyObject* str = PyObject_Str(item);
37596 #endif
37597 if (PyErr_Occurred()) SWIG_fail;
37598 arg2->Add(Py2wxString(str));
37599 Py_DECREF(item);
37600 Py_DECREF(str);
37601 }
37602 }
37603 {
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 (arg1)->Append((wxArrayString const &)*arg2);
37606
37607 wxPyEndAllowThreads(__tstate);
37608 if (PyErr_Occurred()) SWIG_fail;
37609 }
37610 Py_INCREF(Py_None); resultobj = Py_None;
37611 {
37612 if (temp2) delete arg2;
37613 }
37614 return resultobj;
37615 fail:
37616 {
37617 if (temp2) delete arg2;
37618 }
37619 return NULL;
37620 }
37621
37622
37623 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37624 PyObject *resultobj;
37625 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37626 wxString *arg2 = 0 ;
37627 int arg3 ;
37628 PyObject *arg4 = (PyObject *) NULL ;
37629 int result;
37630 bool temp2 = false ;
37631 PyObject * obj0 = 0 ;
37632 PyObject * obj1 = 0 ;
37633 PyObject * obj2 = 0 ;
37634 PyObject * obj3 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37641 if (SWIG_arg_fail(1)) SWIG_fail;
37642 {
37643 arg2 = wxString_in_helper(obj1);
37644 if (arg2 == NULL) SWIG_fail;
37645 temp2 = true;
37646 }
37647 {
37648 arg3 = (int)(SWIG_As_int(obj2));
37649 if (SWIG_arg_fail(3)) SWIG_fail;
37650 }
37651 if (obj3) {
37652 arg4 = obj3;
37653 }
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37657
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 {
37662 resultobj = SWIG_From_int((int)(result));
37663 }
37664 {
37665 if (temp2)
37666 delete arg2;
37667 }
37668 return resultobj;
37669 fail:
37670 {
37671 if (temp2)
37672 delete arg2;
37673 }
37674 return NULL;
37675 }
37676
37677
37678 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj;
37680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37681 PyObject * obj0 = 0 ;
37682 char *kwnames[] = {
37683 (char *) "self", NULL
37684 };
37685
37686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37688 if (SWIG_arg_fail(1)) SWIG_fail;
37689 {
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 (arg1)->Clear();
37692
37693 wxPyEndAllowThreads(__tstate);
37694 if (PyErr_Occurred()) SWIG_fail;
37695 }
37696 Py_INCREF(Py_None); resultobj = Py_None;
37697 return resultobj;
37698 fail:
37699 return NULL;
37700 }
37701
37702
37703 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37704 PyObject *resultobj;
37705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37706 int arg2 ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 char *kwnames[] = {
37710 (char *) "self",(char *) "n", NULL
37711 };
37712
37713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37715 if (SWIG_arg_fail(1)) SWIG_fail;
37716 {
37717 arg2 = (int)(SWIG_As_int(obj1));
37718 if (SWIG_arg_fail(2)) SWIG_fail;
37719 }
37720 {
37721 PyThreadState* __tstate = wxPyBeginAllowThreads();
37722 (arg1)->Delete(arg2);
37723
37724 wxPyEndAllowThreads(__tstate);
37725 if (PyErr_Occurred()) SWIG_fail;
37726 }
37727 Py_INCREF(Py_None); resultobj = Py_None;
37728 return resultobj;
37729 fail:
37730 return NULL;
37731 }
37732
37733
37734 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37735 PyObject *resultobj;
37736 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37737 int arg2 ;
37738 PyObject *result;
37739 PyObject * obj0 = 0 ;
37740 PyObject * obj1 = 0 ;
37741 char *kwnames[] = {
37742 (char *) "self",(char *) "n", NULL
37743 };
37744
37745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37747 if (SWIG_arg_fail(1)) SWIG_fail;
37748 {
37749 arg2 = (int)(SWIG_As_int(obj1));
37750 if (SWIG_arg_fail(2)) SWIG_fail;
37751 }
37752 {
37753 PyThreadState* __tstate = wxPyBeginAllowThreads();
37754 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37755
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 resultobj = result;
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj;
37768 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37769 int arg2 ;
37770 PyObject *arg3 = (PyObject *) 0 ;
37771 PyObject * obj0 = 0 ;
37772 PyObject * obj1 = 0 ;
37773 PyObject * obj2 = 0 ;
37774 char *kwnames[] = {
37775 (char *) "self",(char *) "n",(char *) "clientData", NULL
37776 };
37777
37778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37780 if (SWIG_arg_fail(1)) SWIG_fail;
37781 {
37782 arg2 = (int)(SWIG_As_int(obj1));
37783 if (SWIG_arg_fail(2)) SWIG_fail;
37784 }
37785 arg3 = obj2;
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 wxItemContainer_SetClientData(arg1,arg2,arg3);
37789
37790 wxPyEndAllowThreads(__tstate);
37791 if (PyErr_Occurred()) SWIG_fail;
37792 }
37793 Py_INCREF(Py_None); resultobj = Py_None;
37794 return resultobj;
37795 fail:
37796 return NULL;
37797 }
37798
37799
37800 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37801 PyObject *resultobj;
37802 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37803 int result;
37804 PyObject * obj0 = 0 ;
37805 char *kwnames[] = {
37806 (char *) "self", NULL
37807 };
37808
37809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37811 if (SWIG_arg_fail(1)) SWIG_fail;
37812 {
37813 PyThreadState* __tstate = wxPyBeginAllowThreads();
37814 result = (int)((wxItemContainer const *)arg1)->GetCount();
37815
37816 wxPyEndAllowThreads(__tstate);
37817 if (PyErr_Occurred()) SWIG_fail;
37818 }
37819 {
37820 resultobj = SWIG_From_int((int)(result));
37821 }
37822 return resultobj;
37823 fail:
37824 return NULL;
37825 }
37826
37827
37828 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37829 PyObject *resultobj;
37830 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37831 bool result;
37832 PyObject * obj0 = 0 ;
37833 char *kwnames[] = {
37834 (char *) "self", NULL
37835 };
37836
37837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37839 if (SWIG_arg_fail(1)) SWIG_fail;
37840 {
37841 PyThreadState* __tstate = wxPyBeginAllowThreads();
37842 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37843
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 {
37848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37849 }
37850 return resultobj;
37851 fail:
37852 return NULL;
37853 }
37854
37855
37856 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37857 PyObject *resultobj;
37858 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37859 int arg2 ;
37860 wxString result;
37861 PyObject * obj0 = 0 ;
37862 PyObject * obj1 = 0 ;
37863 char *kwnames[] = {
37864 (char *) "self",(char *) "n", NULL
37865 };
37866
37867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37869 if (SWIG_arg_fail(1)) SWIG_fail;
37870 {
37871 arg2 = (int)(SWIG_As_int(obj1));
37872 if (SWIG_arg_fail(2)) SWIG_fail;
37873 }
37874 {
37875 PyThreadState* __tstate = wxPyBeginAllowThreads();
37876 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37877
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 #if wxUSE_UNICODE
37883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37884 #else
37885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37886 #endif
37887 }
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37895 PyObject *resultobj;
37896 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37897 wxArrayString result;
37898 PyObject * obj0 = 0 ;
37899 char *kwnames[] = {
37900 (char *) "self", NULL
37901 };
37902
37903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37905 if (SWIG_arg_fail(1)) SWIG_fail;
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 result = ((wxItemContainer const *)arg1)->GetStrings();
37909
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 {
37914 resultobj = wxArrayString2PyList_helper(result);
37915 }
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37923 PyObject *resultobj;
37924 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37925 int arg2 ;
37926 wxString *arg3 = 0 ;
37927 bool temp3 = false ;
37928 PyObject * obj0 = 0 ;
37929 PyObject * obj1 = 0 ;
37930 PyObject * obj2 = 0 ;
37931 char *kwnames[] = {
37932 (char *) "self",(char *) "n",(char *) "s", NULL
37933 };
37934
37935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37937 if (SWIG_arg_fail(1)) SWIG_fail;
37938 {
37939 arg2 = (int)(SWIG_As_int(obj1));
37940 if (SWIG_arg_fail(2)) SWIG_fail;
37941 }
37942 {
37943 arg3 = wxString_in_helper(obj2);
37944 if (arg3 == NULL) SWIG_fail;
37945 temp3 = true;
37946 }
37947 {
37948 PyThreadState* __tstate = wxPyBeginAllowThreads();
37949 (arg1)->SetString(arg2,(wxString const &)*arg3);
37950
37951 wxPyEndAllowThreads(__tstate);
37952 if (PyErr_Occurred()) SWIG_fail;
37953 }
37954 Py_INCREF(Py_None); resultobj = Py_None;
37955 {
37956 if (temp3)
37957 delete arg3;
37958 }
37959 return resultobj;
37960 fail:
37961 {
37962 if (temp3)
37963 delete arg3;
37964 }
37965 return NULL;
37966 }
37967
37968
37969 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37970 PyObject *resultobj;
37971 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37972 wxString *arg2 = 0 ;
37973 int result;
37974 bool temp2 = false ;
37975 PyObject * obj0 = 0 ;
37976 PyObject * obj1 = 0 ;
37977 char *kwnames[] = {
37978 (char *) "self",(char *) "s", NULL
37979 };
37980
37981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37983 if (SWIG_arg_fail(1)) SWIG_fail;
37984 {
37985 arg2 = wxString_in_helper(obj1);
37986 if (arg2 == NULL) SWIG_fail;
37987 temp2 = true;
37988 }
37989 {
37990 PyThreadState* __tstate = wxPyBeginAllowThreads();
37991 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37992
37993 wxPyEndAllowThreads(__tstate);
37994 if (PyErr_Occurred()) SWIG_fail;
37995 }
37996 {
37997 resultobj = SWIG_From_int((int)(result));
37998 }
37999 {
38000 if (temp2)
38001 delete arg2;
38002 }
38003 return resultobj;
38004 fail:
38005 {
38006 if (temp2)
38007 delete arg2;
38008 }
38009 return NULL;
38010 }
38011
38012
38013 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38014 PyObject *resultobj;
38015 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38016 int arg2 ;
38017 PyObject * obj0 = 0 ;
38018 PyObject * obj1 = 0 ;
38019 char *kwnames[] = {
38020 (char *) "self",(char *) "n", NULL
38021 };
38022
38023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38025 if (SWIG_arg_fail(1)) SWIG_fail;
38026 {
38027 arg2 = (int)(SWIG_As_int(obj1));
38028 if (SWIG_arg_fail(2)) SWIG_fail;
38029 }
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 (arg1)->SetSelection(arg2);
38033
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 Py_INCREF(Py_None); resultobj = Py_None;
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38045 PyObject *resultobj;
38046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38047 int result;
38048 PyObject * obj0 = 0 ;
38049 char *kwnames[] = {
38050 (char *) "self", NULL
38051 };
38052
38053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38055 if (SWIG_arg_fail(1)) SWIG_fail;
38056 {
38057 PyThreadState* __tstate = wxPyBeginAllowThreads();
38058 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38059
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 resultobj = SWIG_From_int((int)(result));
38065 }
38066 return resultobj;
38067 fail:
38068 return NULL;
38069 }
38070
38071
38072 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38073 PyObject *resultobj;
38074 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38075 wxString *arg2 = 0 ;
38076 bool result;
38077 bool temp2 = false ;
38078 PyObject * obj0 = 0 ;
38079 PyObject * obj1 = 0 ;
38080 char *kwnames[] = {
38081 (char *) "self",(char *) "s", NULL
38082 };
38083
38084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38086 if (SWIG_arg_fail(1)) SWIG_fail;
38087 {
38088 arg2 = wxString_in_helper(obj1);
38089 if (arg2 == NULL) SWIG_fail;
38090 temp2 = true;
38091 }
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38095
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 {
38100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38101 }
38102 {
38103 if (temp2)
38104 delete arg2;
38105 }
38106 return resultobj;
38107 fail:
38108 {
38109 if (temp2)
38110 delete arg2;
38111 }
38112 return NULL;
38113 }
38114
38115
38116 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38117 PyObject *resultobj;
38118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38119 wxString result;
38120 PyObject * obj0 = 0 ;
38121 char *kwnames[] = {
38122 (char *) "self", NULL
38123 };
38124
38125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38127 if (SWIG_arg_fail(1)) SWIG_fail;
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38131
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 #if wxUSE_UNICODE
38137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38138 #else
38139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38140 #endif
38141 }
38142 return resultobj;
38143 fail:
38144 return NULL;
38145 }
38146
38147
38148 static PyObject *_wrap_ItemContainer_Select(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:ItemContainer_Select",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)->Select(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 * ItemContainer_swigregister(PyObject *, PyObject *args) {
38180 PyObject *obj;
38181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38182 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38183 Py_INCREF(obj);
38184 return Py_BuildValue((char *)"");
38185 }
38186 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38187 PyObject *obj;
38188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38189 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38190 Py_INCREF(obj);
38191 return Py_BuildValue((char *)"");
38192 }
38193 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38194 PyObject *resultobj;
38195 wxSizerItem *result;
38196 char *kwnames[] = {
38197 NULL
38198 };
38199
38200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38201 {
38202 PyThreadState* __tstate = wxPyBeginAllowThreads();
38203 result = (wxSizerItem *)new wxSizerItem();
38204
38205 wxPyEndAllowThreads(__tstate);
38206 if (PyErr_Occurred()) SWIG_fail;
38207 }
38208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj;
38217 wxWindow *arg1 = (wxWindow *) 0 ;
38218 int arg2 ;
38219 int arg3 ;
38220 int arg4 ;
38221 PyObject *arg5 = (PyObject *) NULL ;
38222 wxSizerItem *result;
38223 PyObject * obj0 = 0 ;
38224 PyObject * obj1 = 0 ;
38225 PyObject * obj2 = 0 ;
38226 PyObject * obj3 = 0 ;
38227 PyObject * obj4 = 0 ;
38228 char *kwnames[] = {
38229 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38230 };
38231
38232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38234 if (SWIG_arg_fail(1)) SWIG_fail;
38235 {
38236 arg2 = (int)(SWIG_As_int(obj1));
38237 if (SWIG_arg_fail(2)) SWIG_fail;
38238 }
38239 {
38240 arg3 = (int)(SWIG_As_int(obj2));
38241 if (SWIG_arg_fail(3)) SWIG_fail;
38242 }
38243 {
38244 arg4 = (int)(SWIG_As_int(obj3));
38245 if (SWIG_arg_fail(4)) SWIG_fail;
38246 }
38247 if (obj4) {
38248 arg5 = obj4;
38249 }
38250 {
38251 PyThreadState* __tstate = wxPyBeginAllowThreads();
38252 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38253
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38258 return resultobj;
38259 fail:
38260 return NULL;
38261 }
38262
38263
38264 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38265 PyObject *resultobj;
38266 int arg1 ;
38267 int arg2 ;
38268 int arg3 ;
38269 int arg4 ;
38270 int arg5 ;
38271 PyObject *arg6 = (PyObject *) NULL ;
38272 wxSizerItem *result;
38273 PyObject * obj0 = 0 ;
38274 PyObject * obj1 = 0 ;
38275 PyObject * obj2 = 0 ;
38276 PyObject * obj3 = 0 ;
38277 PyObject * obj4 = 0 ;
38278 PyObject * obj5 = 0 ;
38279 char *kwnames[] = {
38280 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38281 };
38282
38283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38284 {
38285 arg1 = (int)(SWIG_As_int(obj0));
38286 if (SWIG_arg_fail(1)) SWIG_fail;
38287 }
38288 {
38289 arg2 = (int)(SWIG_As_int(obj1));
38290 if (SWIG_arg_fail(2)) SWIG_fail;
38291 }
38292 {
38293 arg3 = (int)(SWIG_As_int(obj2));
38294 if (SWIG_arg_fail(3)) SWIG_fail;
38295 }
38296 {
38297 arg4 = (int)(SWIG_As_int(obj3));
38298 if (SWIG_arg_fail(4)) SWIG_fail;
38299 }
38300 {
38301 arg5 = (int)(SWIG_As_int(obj4));
38302 if (SWIG_arg_fail(5)) SWIG_fail;
38303 }
38304 if (obj5) {
38305 arg6 = obj5;
38306 }
38307 {
38308 PyThreadState* __tstate = wxPyBeginAllowThreads();
38309 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38310
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38315 return resultobj;
38316 fail:
38317 return NULL;
38318 }
38319
38320
38321 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38322 PyObject *resultobj;
38323 wxSizer *arg1 = (wxSizer *) 0 ;
38324 int arg2 ;
38325 int arg3 ;
38326 int arg4 ;
38327 PyObject *arg5 = (PyObject *) NULL ;
38328 wxSizerItem *result;
38329 PyObject * obj0 = 0 ;
38330 PyObject * obj1 = 0 ;
38331 PyObject * obj2 = 0 ;
38332 PyObject * obj3 = 0 ;
38333 PyObject * obj4 = 0 ;
38334 char *kwnames[] = {
38335 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38336 };
38337
38338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38340 if (SWIG_arg_fail(1)) SWIG_fail;
38341 {
38342 arg2 = (int)(SWIG_As_int(obj1));
38343 if (SWIG_arg_fail(2)) SWIG_fail;
38344 }
38345 {
38346 arg3 = (int)(SWIG_As_int(obj2));
38347 if (SWIG_arg_fail(3)) SWIG_fail;
38348 }
38349 {
38350 arg4 = (int)(SWIG_As_int(obj3));
38351 if (SWIG_arg_fail(4)) SWIG_fail;
38352 }
38353 if (obj4) {
38354 arg5 = obj4;
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38359
38360 wxPyEndAllowThreads(__tstate);
38361 if (PyErr_Occurred()) SWIG_fail;
38362 }
38363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38364 return resultobj;
38365 fail:
38366 return NULL;
38367 }
38368
38369
38370 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38371 PyObject *resultobj;
38372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38373 PyObject * obj0 = 0 ;
38374 char *kwnames[] = {
38375 (char *) "self", NULL
38376 };
38377
38378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38380 if (SWIG_arg_fail(1)) SWIG_fail;
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 (arg1)->DeleteWindows();
38384
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 Py_INCREF(Py_None); resultobj = Py_None;
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj;
38397 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38398 PyObject * obj0 = 0 ;
38399 char *kwnames[] = {
38400 (char *) "self", NULL
38401 };
38402
38403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38405 if (SWIG_arg_fail(1)) SWIG_fail;
38406 {
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 (arg1)->DetachSizer();
38409
38410 wxPyEndAllowThreads(__tstate);
38411 if (PyErr_Occurred()) SWIG_fail;
38412 }
38413 Py_INCREF(Py_None); resultobj = Py_None;
38414 return resultobj;
38415 fail:
38416 return NULL;
38417 }
38418
38419
38420 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38421 PyObject *resultobj;
38422 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38423 wxSize result;
38424 PyObject * obj0 = 0 ;
38425 char *kwnames[] = {
38426 (char *) "self", NULL
38427 };
38428
38429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38431 if (SWIG_arg_fail(1)) SWIG_fail;
38432 {
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (arg1)->GetSize();
38435
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 {
38440 wxSize * resultptr;
38441 resultptr = new wxSize((wxSize &)(result));
38442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38443 }
38444 return resultobj;
38445 fail:
38446 return NULL;
38447 }
38448
38449
38450 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38451 PyObject *resultobj;
38452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38453 wxSize result;
38454 PyObject * obj0 = 0 ;
38455 char *kwnames[] = {
38456 (char *) "self", NULL
38457 };
38458
38459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38461 if (SWIG_arg_fail(1)) SWIG_fail;
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 result = (arg1)->CalcMin();
38465
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 {
38470 wxSize * resultptr;
38471 resultptr = new wxSize((wxSize &)(result));
38472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38473 }
38474 return resultobj;
38475 fail:
38476 return NULL;
38477 }
38478
38479
38480 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38481 PyObject *resultobj;
38482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38483 wxPoint arg2 ;
38484 wxSize arg3 ;
38485 PyObject * obj0 = 0 ;
38486 PyObject * obj1 = 0 ;
38487 PyObject * obj2 = 0 ;
38488 char *kwnames[] = {
38489 (char *) "self",(char *) "pos",(char *) "size", NULL
38490 };
38491
38492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38494 if (SWIG_arg_fail(1)) SWIG_fail;
38495 {
38496 wxPoint * argp;
38497 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38498 if (SWIG_arg_fail(2)) SWIG_fail;
38499 if (argp == NULL) {
38500 SWIG_null_ref("wxPoint");
38501 }
38502 if (SWIG_arg_fail(2)) SWIG_fail;
38503 arg2 = *argp;
38504 }
38505 {
38506 wxSize * argp;
38507 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38508 if (SWIG_arg_fail(3)) SWIG_fail;
38509 if (argp == NULL) {
38510 SWIG_null_ref("wxSize");
38511 }
38512 if (SWIG_arg_fail(3)) SWIG_fail;
38513 arg3 = *argp;
38514 }
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 (arg1)->SetDimension(arg2,arg3);
38518
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 Py_INCREF(Py_None); resultobj = Py_None;
38523 return resultobj;
38524 fail:
38525 return NULL;
38526 }
38527
38528
38529 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38530 PyObject *resultobj;
38531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38532 wxSize result;
38533 PyObject * obj0 = 0 ;
38534 char *kwnames[] = {
38535 (char *) "self", NULL
38536 };
38537
38538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",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 result = (arg1)->GetMinSize();
38544
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 {
38549 wxSize * resultptr;
38550 resultptr = new wxSize((wxSize &)(result));
38551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38552 }
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj;
38561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38562 wxSize result;
38563 PyObject * obj0 = 0 ;
38564 char *kwnames[] = {
38565 (char *) "self", NULL
38566 };
38567
38568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38570 if (SWIG_arg_fail(1)) SWIG_fail;
38571 {
38572 PyThreadState* __tstate = wxPyBeginAllowThreads();
38573 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38574
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 {
38579 wxSize * resultptr;
38580 resultptr = new wxSize((wxSize &)(result));
38581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38582 }
38583 return resultobj;
38584 fail:
38585 return NULL;
38586 }
38587
38588
38589 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38590 PyObject *resultobj;
38591 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38592 int arg2 ;
38593 int arg3 ;
38594 PyObject * obj0 = 0 ;
38595 PyObject * obj1 = 0 ;
38596 PyObject * obj2 = 0 ;
38597 char *kwnames[] = {
38598 (char *) "self",(char *) "x",(char *) "y", NULL
38599 };
38600
38601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38603 if (SWIG_arg_fail(1)) SWIG_fail;
38604 {
38605 arg2 = (int)(SWIG_As_int(obj1));
38606 if (SWIG_arg_fail(2)) SWIG_fail;
38607 }
38608 {
38609 arg3 = (int)(SWIG_As_int(obj2));
38610 if (SWIG_arg_fail(3)) SWIG_fail;
38611 }
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 (arg1)->SetInitSize(arg2,arg3);
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 Py_INCREF(Py_None); resultobj = Py_None;
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj;
38628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38629 int arg2 ;
38630 int arg3 ;
38631 PyObject * obj0 = 0 ;
38632 PyObject * obj1 = 0 ;
38633 PyObject * obj2 = 0 ;
38634 char *kwnames[] = {
38635 (char *) "self",(char *) "width",(char *) "height", NULL
38636 };
38637
38638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38640 if (SWIG_arg_fail(1)) SWIG_fail;
38641 {
38642 arg2 = (int)(SWIG_As_int(obj1));
38643 if (SWIG_arg_fail(2)) SWIG_fail;
38644 }
38645 {
38646 arg3 = (int)(SWIG_As_int(obj2));
38647 if (SWIG_arg_fail(3)) SWIG_fail;
38648 }
38649 {
38650 PyThreadState* __tstate = wxPyBeginAllowThreads();
38651 (arg1)->SetRatio(arg2,arg3);
38652
38653 wxPyEndAllowThreads(__tstate);
38654 if (PyErr_Occurred()) SWIG_fail;
38655 }
38656 Py_INCREF(Py_None); resultobj = Py_None;
38657 return resultobj;
38658 fail:
38659 return NULL;
38660 }
38661
38662
38663 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38664 PyObject *resultobj;
38665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38666 wxSize arg2 ;
38667 PyObject * obj0 = 0 ;
38668 PyObject * obj1 = 0 ;
38669 char *kwnames[] = {
38670 (char *) "self",(char *) "size", NULL
38671 };
38672
38673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) 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 wxSize * argp;
38678 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38679 if (SWIG_arg_fail(2)) SWIG_fail;
38680 if (argp == NULL) {
38681 SWIG_null_ref("wxSize");
38682 }
38683 if (SWIG_arg_fail(2)) SWIG_fail;
38684 arg2 = *argp;
38685 }
38686 {
38687 PyThreadState* __tstate = wxPyBeginAllowThreads();
38688 (arg1)->SetRatio(arg2);
38689
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 Py_INCREF(Py_None); resultobj = Py_None;
38694 return resultobj;
38695 fail:
38696 return NULL;
38697 }
38698
38699
38700 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38701 PyObject *resultobj;
38702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38703 float arg2 ;
38704 PyObject * obj0 = 0 ;
38705 PyObject * obj1 = 0 ;
38706 char *kwnames[] = {
38707 (char *) "self",(char *) "ratio", NULL
38708 };
38709
38710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38712 if (SWIG_arg_fail(1)) SWIG_fail;
38713 {
38714 arg2 = (float)(SWIG_As_float(obj1));
38715 if (SWIG_arg_fail(2)) SWIG_fail;
38716 }
38717 {
38718 PyThreadState* __tstate = wxPyBeginAllowThreads();
38719 (arg1)->SetRatio(arg2);
38720
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 Py_INCREF(Py_None); resultobj = Py_None;
38725 return resultobj;
38726 fail:
38727 return NULL;
38728 }
38729
38730
38731 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38732 PyObject *resultobj;
38733 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38734 float result;
38735 PyObject * obj0 = 0 ;
38736 char *kwnames[] = {
38737 (char *) "self", NULL
38738 };
38739
38740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38742 if (SWIG_arg_fail(1)) SWIG_fail;
38743 {
38744 PyThreadState* __tstate = wxPyBeginAllowThreads();
38745 result = (float)(arg1)->GetRatio();
38746
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 {
38751 resultobj = SWIG_From_float((float)(result));
38752 }
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38760 PyObject *resultobj;
38761 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38762 wxRect result;
38763 PyObject * obj0 = 0 ;
38764 char *kwnames[] = {
38765 (char *) "self", NULL
38766 };
38767
38768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38770 if (SWIG_arg_fail(1)) SWIG_fail;
38771 {
38772 PyThreadState* __tstate = wxPyBeginAllowThreads();
38773 result = (arg1)->GetRect();
38774
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 {
38779 wxRect * resultptr;
38780 resultptr = new wxRect((wxRect &)(result));
38781 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38782 }
38783 return resultobj;
38784 fail:
38785 return NULL;
38786 }
38787
38788
38789 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38790 PyObject *resultobj;
38791 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38792 bool result;
38793 PyObject * obj0 = 0 ;
38794 char *kwnames[] = {
38795 (char *) "self", NULL
38796 };
38797
38798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38800 if (SWIG_arg_fail(1)) SWIG_fail;
38801 {
38802 PyThreadState* __tstate = wxPyBeginAllowThreads();
38803 result = (bool)(arg1)->IsWindow();
38804
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 {
38809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38810 }
38811 return resultobj;
38812 fail:
38813 return NULL;
38814 }
38815
38816
38817 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38818 PyObject *resultobj;
38819 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38820 bool result;
38821 PyObject * obj0 = 0 ;
38822 char *kwnames[] = {
38823 (char *) "self", NULL
38824 };
38825
38826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38828 if (SWIG_arg_fail(1)) SWIG_fail;
38829 {
38830 PyThreadState* __tstate = wxPyBeginAllowThreads();
38831 result = (bool)(arg1)->IsSizer();
38832
38833 wxPyEndAllowThreads(__tstate);
38834 if (PyErr_Occurred()) SWIG_fail;
38835 }
38836 {
38837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38838 }
38839 return resultobj;
38840 fail:
38841 return NULL;
38842 }
38843
38844
38845 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38846 PyObject *resultobj;
38847 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38848 bool result;
38849 PyObject * obj0 = 0 ;
38850 char *kwnames[] = {
38851 (char *) "self", NULL
38852 };
38853
38854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38856 if (SWIG_arg_fail(1)) SWIG_fail;
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 result = (bool)(arg1)->IsSpacer();
38860
38861 wxPyEndAllowThreads(__tstate);
38862 if (PyErr_Occurred()) SWIG_fail;
38863 }
38864 {
38865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38866 }
38867 return resultobj;
38868 fail:
38869 return NULL;
38870 }
38871
38872
38873 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38874 PyObject *resultobj;
38875 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38876 int arg2 ;
38877 PyObject * obj0 = 0 ;
38878 PyObject * obj1 = 0 ;
38879 char *kwnames[] = {
38880 (char *) "self",(char *) "proportion", NULL
38881 };
38882
38883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38885 if (SWIG_arg_fail(1)) SWIG_fail;
38886 {
38887 arg2 = (int)(SWIG_As_int(obj1));
38888 if (SWIG_arg_fail(2)) SWIG_fail;
38889 }
38890 {
38891 PyThreadState* __tstate = wxPyBeginAllowThreads();
38892 (arg1)->SetProportion(arg2);
38893
38894 wxPyEndAllowThreads(__tstate);
38895 if (PyErr_Occurred()) SWIG_fail;
38896 }
38897 Py_INCREF(Py_None); resultobj = Py_None;
38898 return resultobj;
38899 fail:
38900 return NULL;
38901 }
38902
38903
38904 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38905 PyObject *resultobj;
38906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38907 int result;
38908 PyObject * obj0 = 0 ;
38909 char *kwnames[] = {
38910 (char *) "self", NULL
38911 };
38912
38913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38915 if (SWIG_arg_fail(1)) SWIG_fail;
38916 {
38917 PyThreadState* __tstate = wxPyBeginAllowThreads();
38918 result = (int)(arg1)->GetProportion();
38919
38920 wxPyEndAllowThreads(__tstate);
38921 if (PyErr_Occurred()) SWIG_fail;
38922 }
38923 {
38924 resultobj = SWIG_From_int((int)(result));
38925 }
38926 return resultobj;
38927 fail:
38928 return NULL;
38929 }
38930
38931
38932 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38933 PyObject *resultobj;
38934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38935 int arg2 ;
38936 PyObject * obj0 = 0 ;
38937 PyObject * obj1 = 0 ;
38938 char *kwnames[] = {
38939 (char *) "self",(char *) "flag", NULL
38940 };
38941
38942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38944 if (SWIG_arg_fail(1)) SWIG_fail;
38945 {
38946 arg2 = (int)(SWIG_As_int(obj1));
38947 if (SWIG_arg_fail(2)) SWIG_fail;
38948 }
38949 {
38950 PyThreadState* __tstate = wxPyBeginAllowThreads();
38951 (arg1)->SetFlag(arg2);
38952
38953 wxPyEndAllowThreads(__tstate);
38954 if (PyErr_Occurred()) SWIG_fail;
38955 }
38956 Py_INCREF(Py_None); resultobj = Py_None;
38957 return resultobj;
38958 fail:
38959 return NULL;
38960 }
38961
38962
38963 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38964 PyObject *resultobj;
38965 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38966 int result;
38967 PyObject * obj0 = 0 ;
38968 char *kwnames[] = {
38969 (char *) "self", NULL
38970 };
38971
38972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38974 if (SWIG_arg_fail(1)) SWIG_fail;
38975 {
38976 PyThreadState* __tstate = wxPyBeginAllowThreads();
38977 result = (int)(arg1)->GetFlag();
38978
38979 wxPyEndAllowThreads(__tstate);
38980 if (PyErr_Occurred()) SWIG_fail;
38981 }
38982 {
38983 resultobj = SWIG_From_int((int)(result));
38984 }
38985 return resultobj;
38986 fail:
38987 return NULL;
38988 }
38989
38990
38991 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38992 PyObject *resultobj;
38993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38994 int arg2 ;
38995 PyObject * obj0 = 0 ;
38996 PyObject * obj1 = 0 ;
38997 char *kwnames[] = {
38998 (char *) "self",(char *) "border", NULL
38999 };
39000
39001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39003 if (SWIG_arg_fail(1)) SWIG_fail;
39004 {
39005 arg2 = (int)(SWIG_As_int(obj1));
39006 if (SWIG_arg_fail(2)) SWIG_fail;
39007 }
39008 {
39009 PyThreadState* __tstate = wxPyBeginAllowThreads();
39010 (arg1)->SetBorder(arg2);
39011
39012 wxPyEndAllowThreads(__tstate);
39013 if (PyErr_Occurred()) SWIG_fail;
39014 }
39015 Py_INCREF(Py_None); resultobj = Py_None;
39016 return resultobj;
39017 fail:
39018 return NULL;
39019 }
39020
39021
39022 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39023 PyObject *resultobj;
39024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39025 int result;
39026 PyObject * obj0 = 0 ;
39027 char *kwnames[] = {
39028 (char *) "self", NULL
39029 };
39030
39031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39033 if (SWIG_arg_fail(1)) SWIG_fail;
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 result = (int)(arg1)->GetBorder();
39037
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 {
39042 resultobj = SWIG_From_int((int)(result));
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39051 PyObject *resultobj;
39052 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39053 wxWindow *result;
39054 PyObject * obj0 = 0 ;
39055 char *kwnames[] = {
39056 (char *) "self", NULL
39057 };
39058
39059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39061 if (SWIG_arg_fail(1)) SWIG_fail;
39062 {
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 result = (wxWindow *)(arg1)->GetWindow();
39065
39066 wxPyEndAllowThreads(__tstate);
39067 if (PyErr_Occurred()) SWIG_fail;
39068 }
39069 {
39070 resultobj = wxPyMake_wxObject(result, 0);
39071 }
39072 return resultobj;
39073 fail:
39074 return NULL;
39075 }
39076
39077
39078 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj;
39080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39081 wxWindow *arg2 = (wxWindow *) 0 ;
39082 PyObject * obj0 = 0 ;
39083 PyObject * obj1 = 0 ;
39084 char *kwnames[] = {
39085 (char *) "self",(char *) "window", NULL
39086 };
39087
39088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39090 if (SWIG_arg_fail(1)) SWIG_fail;
39091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39092 if (SWIG_arg_fail(2)) SWIG_fail;
39093 {
39094 PyThreadState* __tstate = wxPyBeginAllowThreads();
39095 (arg1)->SetWindow(arg2);
39096
39097 wxPyEndAllowThreads(__tstate);
39098 if (PyErr_Occurred()) SWIG_fail;
39099 }
39100 Py_INCREF(Py_None); resultobj = Py_None;
39101 return resultobj;
39102 fail:
39103 return NULL;
39104 }
39105
39106
39107 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39108 PyObject *resultobj;
39109 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39110 wxSizer *result;
39111 PyObject * obj0 = 0 ;
39112 char *kwnames[] = {
39113 (char *) "self", NULL
39114 };
39115
39116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39118 if (SWIG_arg_fail(1)) SWIG_fail;
39119 {
39120 PyThreadState* __tstate = wxPyBeginAllowThreads();
39121 result = (wxSizer *)(arg1)->GetSizer();
39122
39123 wxPyEndAllowThreads(__tstate);
39124 if (PyErr_Occurred()) SWIG_fail;
39125 }
39126 {
39127 resultobj = wxPyMake_wxSizer(result, 0);
39128 }
39129 return resultobj;
39130 fail:
39131 return NULL;
39132 }
39133
39134
39135 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj;
39137 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39138 wxSizer *arg2 = (wxSizer *) 0 ;
39139 PyObject * obj0 = 0 ;
39140 PyObject * obj1 = 0 ;
39141 char *kwnames[] = {
39142 (char *) "self",(char *) "sizer", NULL
39143 };
39144
39145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39147 if (SWIG_arg_fail(1)) SWIG_fail;
39148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39149 if (SWIG_arg_fail(2)) SWIG_fail;
39150 {
39151 PyThreadState* __tstate = wxPyBeginAllowThreads();
39152 (arg1)->SetSizer(arg2);
39153
39154 wxPyEndAllowThreads(__tstate);
39155 if (PyErr_Occurred()) SWIG_fail;
39156 }
39157 Py_INCREF(Py_None); resultobj = Py_None;
39158 return resultobj;
39159 fail:
39160 return NULL;
39161 }
39162
39163
39164 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39165 PyObject *resultobj;
39166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39167 wxSize *result;
39168 PyObject * obj0 = 0 ;
39169 char *kwnames[] = {
39170 (char *) "self", NULL
39171 };
39172
39173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39175 if (SWIG_arg_fail(1)) SWIG_fail;
39176 {
39177 PyThreadState* __tstate = wxPyBeginAllowThreads();
39178 {
39179 wxSize const &_result_ref = (arg1)->GetSpacer();
39180 result = (wxSize *) &_result_ref;
39181 }
39182
39183 wxPyEndAllowThreads(__tstate);
39184 if (PyErr_Occurred()) SWIG_fail;
39185 }
39186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39187 return resultobj;
39188 fail:
39189 return NULL;
39190 }
39191
39192
39193 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39194 PyObject *resultobj;
39195 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39196 wxSize *arg2 = 0 ;
39197 wxSize temp2 ;
39198 PyObject * obj0 = 0 ;
39199 PyObject * obj1 = 0 ;
39200 char *kwnames[] = {
39201 (char *) "self",(char *) "size", NULL
39202 };
39203
39204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39206 if (SWIG_arg_fail(1)) SWIG_fail;
39207 {
39208 arg2 = &temp2;
39209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39210 }
39211 {
39212 PyThreadState* __tstate = wxPyBeginAllowThreads();
39213 (arg1)->SetSpacer((wxSize const &)*arg2);
39214
39215 wxPyEndAllowThreads(__tstate);
39216 if (PyErr_Occurred()) SWIG_fail;
39217 }
39218 Py_INCREF(Py_None); resultobj = Py_None;
39219 return resultobj;
39220 fail:
39221 return NULL;
39222 }
39223
39224
39225 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39226 PyObject *resultobj;
39227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39228 bool arg2 ;
39229 PyObject * obj0 = 0 ;
39230 PyObject * obj1 = 0 ;
39231 char *kwnames[] = {
39232 (char *) "self",(char *) "show", NULL
39233 };
39234
39235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39237 if (SWIG_arg_fail(1)) SWIG_fail;
39238 {
39239 arg2 = (bool)(SWIG_As_bool(obj1));
39240 if (SWIG_arg_fail(2)) SWIG_fail;
39241 }
39242 {
39243 PyThreadState* __tstate = wxPyBeginAllowThreads();
39244 (arg1)->Show(arg2);
39245
39246 wxPyEndAllowThreads(__tstate);
39247 if (PyErr_Occurred()) SWIG_fail;
39248 }
39249 Py_INCREF(Py_None); resultobj = Py_None;
39250 return resultobj;
39251 fail:
39252 return NULL;
39253 }
39254
39255
39256 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj;
39258 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39259 bool result;
39260 PyObject * obj0 = 0 ;
39261 char *kwnames[] = {
39262 (char *) "self", NULL
39263 };
39264
39265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39267 if (SWIG_arg_fail(1)) SWIG_fail;
39268 {
39269 PyThreadState* __tstate = wxPyBeginAllowThreads();
39270 result = (bool)(arg1)->IsShown();
39271
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 {
39276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39277 }
39278 return resultobj;
39279 fail:
39280 return NULL;
39281 }
39282
39283
39284 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39285 PyObject *resultobj;
39286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39287 wxPoint result;
39288 PyObject * obj0 = 0 ;
39289 char *kwnames[] = {
39290 (char *) "self", NULL
39291 };
39292
39293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39295 if (SWIG_arg_fail(1)) SWIG_fail;
39296 {
39297 PyThreadState* __tstate = wxPyBeginAllowThreads();
39298 result = (arg1)->GetPosition();
39299
39300 wxPyEndAllowThreads(__tstate);
39301 if (PyErr_Occurred()) SWIG_fail;
39302 }
39303 {
39304 wxPoint * resultptr;
39305 resultptr = new wxPoint((wxPoint &)(result));
39306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39307 }
39308 return resultobj;
39309 fail:
39310 return NULL;
39311 }
39312
39313
39314 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39315 PyObject *resultobj;
39316 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39317 PyObject *result;
39318 PyObject * obj0 = 0 ;
39319 char *kwnames[] = {
39320 (char *) "self", NULL
39321 };
39322
39323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39325 if (SWIG_arg_fail(1)) SWIG_fail;
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39329
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 resultobj = result;
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39341 PyObject *obj;
39342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39343 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39344 Py_INCREF(obj);
39345 return Py_BuildValue((char *)"");
39346 }
39347 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39348 PyObject *resultobj;
39349 wxSizer *arg1 = (wxSizer *) 0 ;
39350 PyObject *arg2 = (PyObject *) 0 ;
39351 PyObject * obj0 = 0 ;
39352 PyObject * obj1 = 0 ;
39353 char *kwnames[] = {
39354 (char *) "self",(char *) "_self", NULL
39355 };
39356
39357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39359 if (SWIG_arg_fail(1)) SWIG_fail;
39360 arg2 = obj1;
39361 {
39362 PyThreadState* __tstate = wxPyBeginAllowThreads();
39363 wxSizer__setOORInfo(arg1,arg2);
39364
39365 wxPyEndAllowThreads(__tstate);
39366 if (PyErr_Occurred()) SWIG_fail;
39367 }
39368 Py_INCREF(Py_None); resultobj = Py_None;
39369 return resultobj;
39370 fail:
39371 return NULL;
39372 }
39373
39374
39375 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39376 PyObject *resultobj;
39377 wxSizer *arg1 = (wxSizer *) 0 ;
39378 PyObject *arg2 = (PyObject *) 0 ;
39379 int arg3 = (int) 0 ;
39380 int arg4 = (int) 0 ;
39381 int arg5 = (int) 0 ;
39382 PyObject *arg6 = (PyObject *) NULL ;
39383 wxSizerItem *result;
39384 PyObject * obj0 = 0 ;
39385 PyObject * obj1 = 0 ;
39386 PyObject * obj2 = 0 ;
39387 PyObject * obj3 = 0 ;
39388 PyObject * obj4 = 0 ;
39389 PyObject * obj5 = 0 ;
39390 char *kwnames[] = {
39391 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39392 };
39393
39394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39396 if (SWIG_arg_fail(1)) SWIG_fail;
39397 arg2 = obj1;
39398 if (obj2) {
39399 {
39400 arg3 = (int)(SWIG_As_int(obj2));
39401 if (SWIG_arg_fail(3)) SWIG_fail;
39402 }
39403 }
39404 if (obj3) {
39405 {
39406 arg4 = (int)(SWIG_As_int(obj3));
39407 if (SWIG_arg_fail(4)) SWIG_fail;
39408 }
39409 }
39410 if (obj4) {
39411 {
39412 arg5 = (int)(SWIG_As_int(obj4));
39413 if (SWIG_arg_fail(5)) SWIG_fail;
39414 }
39415 }
39416 if (obj5) {
39417 arg6 = obj5;
39418 }
39419 {
39420 PyThreadState* __tstate = wxPyBeginAllowThreads();
39421 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39422
39423 wxPyEndAllowThreads(__tstate);
39424 if (PyErr_Occurred()) SWIG_fail;
39425 }
39426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39427 return resultobj;
39428 fail:
39429 return NULL;
39430 }
39431
39432
39433 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39434 PyObject *resultobj;
39435 wxSizer *arg1 = (wxSizer *) 0 ;
39436 int arg2 ;
39437 PyObject *arg3 = (PyObject *) 0 ;
39438 int arg4 = (int) 0 ;
39439 int arg5 = (int) 0 ;
39440 int arg6 = (int) 0 ;
39441 PyObject *arg7 = (PyObject *) NULL ;
39442 wxSizerItem *result;
39443 PyObject * obj0 = 0 ;
39444 PyObject * obj1 = 0 ;
39445 PyObject * obj2 = 0 ;
39446 PyObject * obj3 = 0 ;
39447 PyObject * obj4 = 0 ;
39448 PyObject * obj5 = 0 ;
39449 PyObject * obj6 = 0 ;
39450 char *kwnames[] = {
39451 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39452 };
39453
39454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39456 if (SWIG_arg_fail(1)) SWIG_fail;
39457 {
39458 arg2 = (int)(SWIG_As_int(obj1));
39459 if (SWIG_arg_fail(2)) SWIG_fail;
39460 }
39461 arg3 = obj2;
39462 if (obj3) {
39463 {
39464 arg4 = (int)(SWIG_As_int(obj3));
39465 if (SWIG_arg_fail(4)) SWIG_fail;
39466 }
39467 }
39468 if (obj4) {
39469 {
39470 arg5 = (int)(SWIG_As_int(obj4));
39471 if (SWIG_arg_fail(5)) SWIG_fail;
39472 }
39473 }
39474 if (obj5) {
39475 {
39476 arg6 = (int)(SWIG_As_int(obj5));
39477 if (SWIG_arg_fail(6)) SWIG_fail;
39478 }
39479 }
39480 if (obj6) {
39481 arg7 = obj6;
39482 }
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39486
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj;
39499 wxSizer *arg1 = (wxSizer *) 0 ;
39500 PyObject *arg2 = (PyObject *) 0 ;
39501 int arg3 = (int) 0 ;
39502 int arg4 = (int) 0 ;
39503 int arg5 = (int) 0 ;
39504 PyObject *arg6 = (PyObject *) NULL ;
39505 wxSizerItem *result;
39506 PyObject * obj0 = 0 ;
39507 PyObject * obj1 = 0 ;
39508 PyObject * obj2 = 0 ;
39509 PyObject * obj3 = 0 ;
39510 PyObject * obj4 = 0 ;
39511 PyObject * obj5 = 0 ;
39512 char *kwnames[] = {
39513 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39514 };
39515
39516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39518 if (SWIG_arg_fail(1)) SWIG_fail;
39519 arg2 = obj1;
39520 if (obj2) {
39521 {
39522 arg3 = (int)(SWIG_As_int(obj2));
39523 if (SWIG_arg_fail(3)) SWIG_fail;
39524 }
39525 }
39526 if (obj3) {
39527 {
39528 arg4 = (int)(SWIG_As_int(obj3));
39529 if (SWIG_arg_fail(4)) SWIG_fail;
39530 }
39531 }
39532 if (obj4) {
39533 {
39534 arg5 = (int)(SWIG_As_int(obj4));
39535 if (SWIG_arg_fail(5)) SWIG_fail;
39536 }
39537 }
39538 if (obj5) {
39539 arg6 = obj5;
39540 }
39541 {
39542 PyThreadState* __tstate = wxPyBeginAllowThreads();
39543 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39544
39545 wxPyEndAllowThreads(__tstate);
39546 if (PyErr_Occurred()) SWIG_fail;
39547 }
39548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39549 return resultobj;
39550 fail:
39551 return NULL;
39552 }
39553
39554
39555 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39556 PyObject *resultobj;
39557 wxSizer *arg1 = (wxSizer *) 0 ;
39558 PyObject *arg2 = (PyObject *) 0 ;
39559 bool result;
39560 PyObject * obj0 = 0 ;
39561 PyObject * obj1 = 0 ;
39562 char *kwnames[] = {
39563 (char *) "self",(char *) "item", NULL
39564 };
39565
39566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39568 if (SWIG_arg_fail(1)) SWIG_fail;
39569 arg2 = obj1;
39570 {
39571 PyThreadState* __tstate = wxPyBeginAllowThreads();
39572 result = (bool)wxSizer_Remove(arg1,arg2);
39573
39574 wxPyEndAllowThreads(__tstate);
39575 if (PyErr_Occurred()) SWIG_fail;
39576 }
39577 {
39578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39579 }
39580 return resultobj;
39581 fail:
39582 return NULL;
39583 }
39584
39585
39586 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39587 PyObject *resultobj;
39588 wxSizer *arg1 = (wxSizer *) 0 ;
39589 PyObject *arg2 = (PyObject *) 0 ;
39590 bool result;
39591 PyObject * obj0 = 0 ;
39592 PyObject * obj1 = 0 ;
39593 char *kwnames[] = {
39594 (char *) "self",(char *) "item", NULL
39595 };
39596
39597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39599 if (SWIG_arg_fail(1)) SWIG_fail;
39600 arg2 = obj1;
39601 {
39602 PyThreadState* __tstate = wxPyBeginAllowThreads();
39603 result = (bool)wxSizer_Detach(arg1,arg2);
39604
39605 wxPyEndAllowThreads(__tstate);
39606 if (PyErr_Occurred()) SWIG_fail;
39607 }
39608 {
39609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39610 }
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39618 PyObject *resultobj;
39619 wxSizer *arg1 = (wxSizer *) 0 ;
39620 PyObject *arg2 = (PyObject *) 0 ;
39621 wxSizerItem *result;
39622 PyObject * obj0 = 0 ;
39623 PyObject * obj1 = 0 ;
39624 char *kwnames[] = {
39625 (char *) "self",(char *) "item", NULL
39626 };
39627
39628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39630 if (SWIG_arg_fail(1)) SWIG_fail;
39631 arg2 = obj1;
39632 {
39633 PyThreadState* __tstate = wxPyBeginAllowThreads();
39634 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39635
39636 wxPyEndAllowThreads(__tstate);
39637 if (PyErr_Occurred()) SWIG_fail;
39638 }
39639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39647 PyObject *resultobj;
39648 wxSizer *arg1 = (wxSizer *) 0 ;
39649 PyObject *arg2 = (PyObject *) 0 ;
39650 wxSize *arg3 = 0 ;
39651 wxSize temp3 ;
39652 PyObject * obj0 = 0 ;
39653 PyObject * obj1 = 0 ;
39654 PyObject * obj2 = 0 ;
39655 char *kwnames[] = {
39656 (char *) "self",(char *) "item",(char *) "size", NULL
39657 };
39658
39659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39661 if (SWIG_arg_fail(1)) SWIG_fail;
39662 arg2 = obj1;
39663 {
39664 arg3 = &temp3;
39665 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39666 }
39667 {
39668 PyThreadState* __tstate = wxPyBeginAllowThreads();
39669 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39670
39671 wxPyEndAllowThreads(__tstate);
39672 if (PyErr_Occurred()) SWIG_fail;
39673 }
39674 Py_INCREF(Py_None); resultobj = Py_None;
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39682 PyObject *resultobj;
39683 wxSizer *arg1 = (wxSizer *) 0 ;
39684 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39685 wxSizerItem *result;
39686 PyObject * obj0 = 0 ;
39687 PyObject * obj1 = 0 ;
39688 char *kwnames[] = {
39689 (char *) "self",(char *) "item", NULL
39690 };
39691
39692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39694 if (SWIG_arg_fail(1)) SWIG_fail;
39695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39696 if (SWIG_arg_fail(2)) SWIG_fail;
39697 {
39698 PyThreadState* __tstate = wxPyBeginAllowThreads();
39699 result = (wxSizerItem *)(arg1)->Add(arg2);
39700
39701 wxPyEndAllowThreads(__tstate);
39702 if (PyErr_Occurred()) SWIG_fail;
39703 }
39704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj;
39713 wxSizer *arg1 = (wxSizer *) 0 ;
39714 size_t arg2 ;
39715 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39716 wxSizerItem *result;
39717 PyObject * obj0 = 0 ;
39718 PyObject * obj1 = 0 ;
39719 PyObject * obj2 = 0 ;
39720 char *kwnames[] = {
39721 (char *) "self",(char *) "index",(char *) "item", NULL
39722 };
39723
39724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39726 if (SWIG_arg_fail(1)) SWIG_fail;
39727 {
39728 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39729 if (SWIG_arg_fail(2)) SWIG_fail;
39730 }
39731 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39732 if (SWIG_arg_fail(3)) SWIG_fail;
39733 {
39734 PyThreadState* __tstate = wxPyBeginAllowThreads();
39735 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39736
39737 wxPyEndAllowThreads(__tstate);
39738 if (PyErr_Occurred()) SWIG_fail;
39739 }
39740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39741 return resultobj;
39742 fail:
39743 return NULL;
39744 }
39745
39746
39747 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39748 PyObject *resultobj;
39749 wxSizer *arg1 = (wxSizer *) 0 ;
39750 wxSizerItem *arg2 = (wxSizerItem *) 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:Sizer_PrependItem",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39762 if (SWIG_arg_fail(2)) SWIG_fail;
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39766
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39778 PyObject *resultobj;
39779 wxSizer *arg1 = (wxSizer *) 0 ;
39780 int arg2 ;
39781 int arg3 ;
39782 int arg4 ;
39783 int arg5 ;
39784 PyObject * obj0 = 0 ;
39785 PyObject * obj1 = 0 ;
39786 PyObject * obj2 = 0 ;
39787 PyObject * obj3 = 0 ;
39788 PyObject * obj4 = 0 ;
39789 char *kwnames[] = {
39790 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39791 };
39792
39793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39795 if (SWIG_arg_fail(1)) SWIG_fail;
39796 {
39797 arg2 = (int)(SWIG_As_int(obj1));
39798 if (SWIG_arg_fail(2)) SWIG_fail;
39799 }
39800 {
39801 arg3 = (int)(SWIG_As_int(obj2));
39802 if (SWIG_arg_fail(3)) SWIG_fail;
39803 }
39804 {
39805 arg4 = (int)(SWIG_As_int(obj3));
39806 if (SWIG_arg_fail(4)) SWIG_fail;
39807 }
39808 {
39809 arg5 = (int)(SWIG_As_int(obj4));
39810 if (SWIG_arg_fail(5)) SWIG_fail;
39811 }
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39815
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 Py_INCREF(Py_None); resultobj = Py_None;
39820 return resultobj;
39821 fail:
39822 return NULL;
39823 }
39824
39825
39826 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39827 PyObject *resultobj;
39828 wxSizer *arg1 = (wxSizer *) 0 ;
39829 wxSize *arg2 = 0 ;
39830 wxSize temp2 ;
39831 PyObject * obj0 = 0 ;
39832 PyObject * obj1 = 0 ;
39833 char *kwnames[] = {
39834 (char *) "self",(char *) "size", NULL
39835 };
39836
39837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39839 if (SWIG_arg_fail(1)) SWIG_fail;
39840 {
39841 arg2 = &temp2;
39842 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39843 }
39844 {
39845 PyThreadState* __tstate = wxPyBeginAllowThreads();
39846 (arg1)->SetMinSize((wxSize const &)*arg2);
39847
39848 wxPyEndAllowThreads(__tstate);
39849 if (PyErr_Occurred()) SWIG_fail;
39850 }
39851 Py_INCREF(Py_None); resultobj = Py_None;
39852 return resultobj;
39853 fail:
39854 return NULL;
39855 }
39856
39857
39858 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39859 PyObject *resultobj;
39860 wxSizer *arg1 = (wxSizer *) 0 ;
39861 wxSize result;
39862 PyObject * obj0 = 0 ;
39863 char *kwnames[] = {
39864 (char *) "self", NULL
39865 };
39866
39867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39869 if (SWIG_arg_fail(1)) SWIG_fail;
39870 {
39871 PyThreadState* __tstate = wxPyBeginAllowThreads();
39872 result = (arg1)->GetSize();
39873
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 {
39878 wxSize * resultptr;
39879 resultptr = new wxSize((wxSize &)(result));
39880 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39881 }
39882 return resultobj;
39883 fail:
39884 return NULL;
39885 }
39886
39887
39888 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39889 PyObject *resultobj;
39890 wxSizer *arg1 = (wxSizer *) 0 ;
39891 wxPoint result;
39892 PyObject * obj0 = 0 ;
39893 char *kwnames[] = {
39894 (char *) "self", NULL
39895 };
39896
39897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39899 if (SWIG_arg_fail(1)) SWIG_fail;
39900 {
39901 PyThreadState* __tstate = wxPyBeginAllowThreads();
39902 result = (arg1)->GetPosition();
39903
39904 wxPyEndAllowThreads(__tstate);
39905 if (PyErr_Occurred()) SWIG_fail;
39906 }
39907 {
39908 wxPoint * resultptr;
39909 resultptr = new wxPoint((wxPoint &)(result));
39910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39911 }
39912 return resultobj;
39913 fail:
39914 return NULL;
39915 }
39916
39917
39918 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39919 PyObject *resultobj;
39920 wxSizer *arg1 = (wxSizer *) 0 ;
39921 wxSize result;
39922 PyObject * obj0 = 0 ;
39923 char *kwnames[] = {
39924 (char *) "self", NULL
39925 };
39926
39927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39929 if (SWIG_arg_fail(1)) SWIG_fail;
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 result = (arg1)->GetMinSize();
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 {
39938 wxSize * resultptr;
39939 resultptr = new wxSize((wxSize &)(result));
39940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39941 }
39942 return resultobj;
39943 fail:
39944 return NULL;
39945 }
39946
39947
39948 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39949 PyObject *resultobj;
39950 wxSizer *arg1 = (wxSizer *) 0 ;
39951 PyObject * obj0 = 0 ;
39952 char *kwnames[] = {
39953 (char *) "self", NULL
39954 };
39955
39956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39958 if (SWIG_arg_fail(1)) SWIG_fail;
39959 {
39960 PyThreadState* __tstate = wxPyBeginAllowThreads();
39961 (arg1)->RecalcSizes();
39962
39963 wxPyEndAllowThreads(__tstate);
39964 if (PyErr_Occurred()) SWIG_fail;
39965 }
39966 Py_INCREF(Py_None); resultobj = Py_None;
39967 return resultobj;
39968 fail:
39969 return NULL;
39970 }
39971
39972
39973 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39974 PyObject *resultobj;
39975 wxSizer *arg1 = (wxSizer *) 0 ;
39976 wxSize result;
39977 PyObject * obj0 = 0 ;
39978 char *kwnames[] = {
39979 (char *) "self", NULL
39980 };
39981
39982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39984 if (SWIG_arg_fail(1)) SWIG_fail;
39985 {
39986 PyThreadState* __tstate = wxPyBeginAllowThreads();
39987 result = (arg1)->CalcMin();
39988
39989 wxPyEndAllowThreads(__tstate);
39990 if (PyErr_Occurred()) SWIG_fail;
39991 }
39992 {
39993 wxSize * resultptr;
39994 resultptr = new wxSize((wxSize &)(result));
39995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39996 }
39997 return resultobj;
39998 fail:
39999 return NULL;
40000 }
40001
40002
40003 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40004 PyObject *resultobj;
40005 wxSizer *arg1 = (wxSizer *) 0 ;
40006 PyObject * obj0 = 0 ;
40007 char *kwnames[] = {
40008 (char *) "self", NULL
40009 };
40010
40011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40013 if (SWIG_arg_fail(1)) SWIG_fail;
40014 {
40015 PyThreadState* __tstate = wxPyBeginAllowThreads();
40016 (arg1)->Layout();
40017
40018 wxPyEndAllowThreads(__tstate);
40019 if (PyErr_Occurred()) SWIG_fail;
40020 }
40021 Py_INCREF(Py_None); resultobj = Py_None;
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj;
40030 wxSizer *arg1 = (wxSizer *) 0 ;
40031 wxWindow *arg2 = (wxWindow *) 0 ;
40032 wxSize result;
40033 PyObject * obj0 = 0 ;
40034 PyObject * obj1 = 0 ;
40035 char *kwnames[] = {
40036 (char *) "self",(char *) "window", NULL
40037 };
40038
40039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40041 if (SWIG_arg_fail(1)) SWIG_fail;
40042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40043 if (SWIG_arg_fail(2)) SWIG_fail;
40044 {
40045 PyThreadState* __tstate = wxPyBeginAllowThreads();
40046 result = (arg1)->Fit(arg2);
40047
40048 wxPyEndAllowThreads(__tstate);
40049 if (PyErr_Occurred()) SWIG_fail;
40050 }
40051 {
40052 wxSize * resultptr;
40053 resultptr = new wxSize((wxSize &)(result));
40054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40055 }
40056 return resultobj;
40057 fail:
40058 return NULL;
40059 }
40060
40061
40062 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40063 PyObject *resultobj;
40064 wxSizer *arg1 = (wxSizer *) 0 ;
40065 wxWindow *arg2 = (wxWindow *) 0 ;
40066 PyObject * obj0 = 0 ;
40067 PyObject * obj1 = 0 ;
40068 char *kwnames[] = {
40069 (char *) "self",(char *) "window", NULL
40070 };
40071
40072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40074 if (SWIG_arg_fail(1)) SWIG_fail;
40075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40076 if (SWIG_arg_fail(2)) SWIG_fail;
40077 {
40078 PyThreadState* __tstate = wxPyBeginAllowThreads();
40079 (arg1)->FitInside(arg2);
40080
40081 wxPyEndAllowThreads(__tstate);
40082 if (PyErr_Occurred()) SWIG_fail;
40083 }
40084 Py_INCREF(Py_None); resultobj = Py_None;
40085 return resultobj;
40086 fail:
40087 return NULL;
40088 }
40089
40090
40091 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40092 PyObject *resultobj;
40093 wxSizer *arg1 = (wxSizer *) 0 ;
40094 wxWindow *arg2 = (wxWindow *) 0 ;
40095 PyObject * obj0 = 0 ;
40096 PyObject * obj1 = 0 ;
40097 char *kwnames[] = {
40098 (char *) "self",(char *) "window", NULL
40099 };
40100
40101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40103 if (SWIG_arg_fail(1)) SWIG_fail;
40104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40105 if (SWIG_arg_fail(2)) SWIG_fail;
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 (arg1)->SetSizeHints(arg2);
40109
40110 wxPyEndAllowThreads(__tstate);
40111 if (PyErr_Occurred()) SWIG_fail;
40112 }
40113 Py_INCREF(Py_None); resultobj = Py_None;
40114 return resultobj;
40115 fail:
40116 return NULL;
40117 }
40118
40119
40120 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40121 PyObject *resultobj;
40122 wxSizer *arg1 = (wxSizer *) 0 ;
40123 wxWindow *arg2 = (wxWindow *) 0 ;
40124 PyObject * obj0 = 0 ;
40125 PyObject * obj1 = 0 ;
40126 char *kwnames[] = {
40127 (char *) "self",(char *) "window", NULL
40128 };
40129
40130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40132 if (SWIG_arg_fail(1)) SWIG_fail;
40133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40134 if (SWIG_arg_fail(2)) SWIG_fail;
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 (arg1)->SetVirtualSizeHints(arg2);
40138
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 Py_INCREF(Py_None); resultobj = Py_None;
40143 return resultobj;
40144 fail:
40145 return NULL;
40146 }
40147
40148
40149 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40150 PyObject *resultobj;
40151 wxSizer *arg1 = (wxSizer *) 0 ;
40152 bool arg2 = (bool) false ;
40153 PyObject * obj0 = 0 ;
40154 PyObject * obj1 = 0 ;
40155 char *kwnames[] = {
40156 (char *) "self",(char *) "deleteWindows", NULL
40157 };
40158
40159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40161 if (SWIG_arg_fail(1)) SWIG_fail;
40162 if (obj1) {
40163 {
40164 arg2 = (bool)(SWIG_As_bool(obj1));
40165 if (SWIG_arg_fail(2)) SWIG_fail;
40166 }
40167 }
40168 {
40169 PyThreadState* __tstate = wxPyBeginAllowThreads();
40170 (arg1)->Clear(arg2);
40171
40172 wxPyEndAllowThreads(__tstate);
40173 if (PyErr_Occurred()) SWIG_fail;
40174 }
40175 Py_INCREF(Py_None); resultobj = Py_None;
40176 return resultobj;
40177 fail:
40178 return NULL;
40179 }
40180
40181
40182 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40183 PyObject *resultobj;
40184 wxSizer *arg1 = (wxSizer *) 0 ;
40185 PyObject * obj0 = 0 ;
40186 char *kwnames[] = {
40187 (char *) "self", NULL
40188 };
40189
40190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40192 if (SWIG_arg_fail(1)) SWIG_fail;
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 (arg1)->DeleteWindows();
40196
40197 wxPyEndAllowThreads(__tstate);
40198 if (PyErr_Occurred()) SWIG_fail;
40199 }
40200 Py_INCREF(Py_None); resultobj = Py_None;
40201 return resultobj;
40202 fail:
40203 return NULL;
40204 }
40205
40206
40207 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40208 PyObject *resultobj;
40209 wxSizer *arg1 = (wxSizer *) 0 ;
40210 PyObject *result;
40211 PyObject * obj0 = 0 ;
40212 char *kwnames[] = {
40213 (char *) "self", NULL
40214 };
40215
40216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40218 if (SWIG_arg_fail(1)) SWIG_fail;
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 result = (PyObject *)wxSizer_GetChildren(arg1);
40222
40223 wxPyEndAllowThreads(__tstate);
40224 if (PyErr_Occurred()) SWIG_fail;
40225 }
40226 resultobj = result;
40227 return resultobj;
40228 fail:
40229 return NULL;
40230 }
40231
40232
40233 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40234 PyObject *resultobj;
40235 wxSizer *arg1 = (wxSizer *) 0 ;
40236 PyObject *arg2 = (PyObject *) 0 ;
40237 bool arg3 = (bool) true ;
40238 bool arg4 = (bool) false ;
40239 bool result;
40240 PyObject * obj0 = 0 ;
40241 PyObject * obj1 = 0 ;
40242 PyObject * obj2 = 0 ;
40243 PyObject * obj3 = 0 ;
40244 char *kwnames[] = {
40245 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40246 };
40247
40248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40250 if (SWIG_arg_fail(1)) SWIG_fail;
40251 arg2 = obj1;
40252 if (obj2) {
40253 {
40254 arg3 = (bool)(SWIG_As_bool(obj2));
40255 if (SWIG_arg_fail(3)) SWIG_fail;
40256 }
40257 }
40258 if (obj3) {
40259 {
40260 arg4 = (bool)(SWIG_As_bool(obj3));
40261 if (SWIG_arg_fail(4)) SWIG_fail;
40262 }
40263 }
40264 {
40265 PyThreadState* __tstate = wxPyBeginAllowThreads();
40266 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40267
40268 wxPyEndAllowThreads(__tstate);
40269 if (PyErr_Occurred()) SWIG_fail;
40270 }
40271 {
40272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40273 }
40274 return resultobj;
40275 fail:
40276 return NULL;
40277 }
40278
40279
40280 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40281 PyObject *resultobj;
40282 wxSizer *arg1 = (wxSizer *) 0 ;
40283 PyObject *arg2 = (PyObject *) 0 ;
40284 bool result;
40285 PyObject * obj0 = 0 ;
40286 PyObject * obj1 = 0 ;
40287 char *kwnames[] = {
40288 (char *) "self",(char *) "item", NULL
40289 };
40290
40291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40293 if (SWIG_arg_fail(1)) SWIG_fail;
40294 arg2 = obj1;
40295 {
40296 PyThreadState* __tstate = wxPyBeginAllowThreads();
40297 result = (bool)wxSizer_IsShown(arg1,arg2);
40298
40299 wxPyEndAllowThreads(__tstate);
40300 if (PyErr_Occurred()) SWIG_fail;
40301 }
40302 {
40303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40304 }
40305 return resultobj;
40306 fail:
40307 return NULL;
40308 }
40309
40310
40311 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40312 PyObject *resultobj;
40313 wxSizer *arg1 = (wxSizer *) 0 ;
40314 bool arg2 ;
40315 PyObject * obj0 = 0 ;
40316 PyObject * obj1 = 0 ;
40317 char *kwnames[] = {
40318 (char *) "self",(char *) "show", NULL
40319 };
40320
40321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40323 if (SWIG_arg_fail(1)) SWIG_fail;
40324 {
40325 arg2 = (bool)(SWIG_As_bool(obj1));
40326 if (SWIG_arg_fail(2)) SWIG_fail;
40327 }
40328 {
40329 PyThreadState* __tstate = wxPyBeginAllowThreads();
40330 (arg1)->ShowItems(arg2);
40331
40332 wxPyEndAllowThreads(__tstate);
40333 if (PyErr_Occurred()) SWIG_fail;
40334 }
40335 Py_INCREF(Py_None); resultobj = Py_None;
40336 return resultobj;
40337 fail:
40338 return NULL;
40339 }
40340
40341
40342 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40343 PyObject *obj;
40344 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40345 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40346 Py_INCREF(obj);
40347 return Py_BuildValue((char *)"");
40348 }
40349 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40350 PyObject *resultobj;
40351 wxPySizer *result;
40352 char *kwnames[] = {
40353 NULL
40354 };
40355
40356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40357 {
40358 PyThreadState* __tstate = wxPyBeginAllowThreads();
40359 result = (wxPySizer *)new wxPySizer();
40360
40361 wxPyEndAllowThreads(__tstate);
40362 if (PyErr_Occurred()) SWIG_fail;
40363 }
40364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40365 return resultobj;
40366 fail:
40367 return NULL;
40368 }
40369
40370
40371 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40372 PyObject *resultobj;
40373 wxPySizer *arg1 = (wxPySizer *) 0 ;
40374 PyObject *arg2 = (PyObject *) 0 ;
40375 PyObject *arg3 = (PyObject *) 0 ;
40376 PyObject * obj0 = 0 ;
40377 PyObject * obj1 = 0 ;
40378 PyObject * obj2 = 0 ;
40379 char *kwnames[] = {
40380 (char *) "self",(char *) "self",(char *) "_class", NULL
40381 };
40382
40383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40385 if (SWIG_arg_fail(1)) SWIG_fail;
40386 arg2 = obj1;
40387 arg3 = obj2;
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 (arg1)->_setCallbackInfo(arg2,arg3);
40391
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 Py_INCREF(Py_None); resultobj = Py_None;
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40403 PyObject *obj;
40404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40405 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40406 Py_INCREF(obj);
40407 return Py_BuildValue((char *)"");
40408 }
40409 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj;
40411 int arg1 = (int) wxHORIZONTAL ;
40412 wxBoxSizer *result;
40413 PyObject * obj0 = 0 ;
40414 char *kwnames[] = {
40415 (char *) "orient", NULL
40416 };
40417
40418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40419 if (obj0) {
40420 {
40421 arg1 = (int)(SWIG_As_int(obj0));
40422 if (SWIG_arg_fail(1)) SWIG_fail;
40423 }
40424 }
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40428
40429 wxPyEndAllowThreads(__tstate);
40430 if (PyErr_Occurred()) SWIG_fail;
40431 }
40432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40433 return resultobj;
40434 fail:
40435 return NULL;
40436 }
40437
40438
40439 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40440 PyObject *resultobj;
40441 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40442 int result;
40443 PyObject * obj0 = 0 ;
40444 char *kwnames[] = {
40445 (char *) "self", NULL
40446 };
40447
40448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40450 if (SWIG_arg_fail(1)) SWIG_fail;
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 result = (int)(arg1)->GetOrientation();
40454
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 {
40459 resultobj = SWIG_From_int((int)(result));
40460 }
40461 return resultobj;
40462 fail:
40463 return NULL;
40464 }
40465
40466
40467 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40468 PyObject *resultobj;
40469 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40470 int arg2 ;
40471 PyObject * obj0 = 0 ;
40472 PyObject * obj1 = 0 ;
40473 char *kwnames[] = {
40474 (char *) "self",(char *) "orient", NULL
40475 };
40476
40477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40479 if (SWIG_arg_fail(1)) SWIG_fail;
40480 {
40481 arg2 = (int)(SWIG_As_int(obj1));
40482 if (SWIG_arg_fail(2)) SWIG_fail;
40483 }
40484 {
40485 PyThreadState* __tstate = wxPyBeginAllowThreads();
40486 (arg1)->SetOrientation(arg2);
40487
40488 wxPyEndAllowThreads(__tstate);
40489 if (PyErr_Occurred()) SWIG_fail;
40490 }
40491 Py_INCREF(Py_None); resultobj = Py_None;
40492 return resultobj;
40493 fail:
40494 return NULL;
40495 }
40496
40497
40498 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40499 PyObject *obj;
40500 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40501 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40502 Py_INCREF(obj);
40503 return Py_BuildValue((char *)"");
40504 }
40505 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40506 PyObject *resultobj;
40507 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40508 int arg2 = (int) wxHORIZONTAL ;
40509 wxStaticBoxSizer *result;
40510 PyObject * obj0 = 0 ;
40511 PyObject * obj1 = 0 ;
40512 char *kwnames[] = {
40513 (char *) "box",(char *) "orient", NULL
40514 };
40515
40516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40518 if (SWIG_arg_fail(1)) SWIG_fail;
40519 if (obj1) {
40520 {
40521 arg2 = (int)(SWIG_As_int(obj1));
40522 if (SWIG_arg_fail(2)) SWIG_fail;
40523 }
40524 }
40525 {
40526 PyThreadState* __tstate = wxPyBeginAllowThreads();
40527 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40528
40529 wxPyEndAllowThreads(__tstate);
40530 if (PyErr_Occurred()) SWIG_fail;
40531 }
40532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40540 PyObject *resultobj;
40541 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40542 wxStaticBox *result;
40543 PyObject * obj0 = 0 ;
40544 char *kwnames[] = {
40545 (char *) "self", NULL
40546 };
40547
40548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40550 if (SWIG_arg_fail(1)) SWIG_fail;
40551 {
40552 PyThreadState* __tstate = wxPyBeginAllowThreads();
40553 result = (wxStaticBox *)(arg1)->GetStaticBox();
40554
40555 wxPyEndAllowThreads(__tstate);
40556 if (PyErr_Occurred()) SWIG_fail;
40557 }
40558 {
40559 resultobj = wxPyMake_wxObject(result, 0);
40560 }
40561 return resultobj;
40562 fail:
40563 return NULL;
40564 }
40565
40566
40567 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40568 PyObject *obj;
40569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40570 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40571 Py_INCREF(obj);
40572 return Py_BuildValue((char *)"");
40573 }
40574 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40575 PyObject *resultobj;
40576 int arg1 = (int) 1 ;
40577 int arg2 = (int) 0 ;
40578 int arg3 = (int) 0 ;
40579 int arg4 = (int) 0 ;
40580 wxGridSizer *result;
40581 PyObject * obj0 = 0 ;
40582 PyObject * obj1 = 0 ;
40583 PyObject * obj2 = 0 ;
40584 PyObject * obj3 = 0 ;
40585 char *kwnames[] = {
40586 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40587 };
40588
40589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40590 if (obj0) {
40591 {
40592 arg1 = (int)(SWIG_As_int(obj0));
40593 if (SWIG_arg_fail(1)) SWIG_fail;
40594 }
40595 }
40596 if (obj1) {
40597 {
40598 arg2 = (int)(SWIG_As_int(obj1));
40599 if (SWIG_arg_fail(2)) SWIG_fail;
40600 }
40601 }
40602 if (obj2) {
40603 {
40604 arg3 = (int)(SWIG_As_int(obj2));
40605 if (SWIG_arg_fail(3)) SWIG_fail;
40606 }
40607 }
40608 if (obj3) {
40609 {
40610 arg4 = (int)(SWIG_As_int(obj3));
40611 if (SWIG_arg_fail(4)) SWIG_fail;
40612 }
40613 }
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40617
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40622 return resultobj;
40623 fail:
40624 return NULL;
40625 }
40626
40627
40628 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40629 PyObject *resultobj;
40630 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40631 int arg2 ;
40632 PyObject * obj0 = 0 ;
40633 PyObject * obj1 = 0 ;
40634 char *kwnames[] = {
40635 (char *) "self",(char *) "cols", NULL
40636 };
40637
40638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40640 if (SWIG_arg_fail(1)) SWIG_fail;
40641 {
40642 arg2 = (int)(SWIG_As_int(obj1));
40643 if (SWIG_arg_fail(2)) SWIG_fail;
40644 }
40645 {
40646 PyThreadState* __tstate = wxPyBeginAllowThreads();
40647 (arg1)->SetCols(arg2);
40648
40649 wxPyEndAllowThreads(__tstate);
40650 if (PyErr_Occurred()) SWIG_fail;
40651 }
40652 Py_INCREF(Py_None); resultobj = Py_None;
40653 return resultobj;
40654 fail:
40655 return NULL;
40656 }
40657
40658
40659 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40660 PyObject *resultobj;
40661 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40662 int arg2 ;
40663 PyObject * obj0 = 0 ;
40664 PyObject * obj1 = 0 ;
40665 char *kwnames[] = {
40666 (char *) "self",(char *) "rows", NULL
40667 };
40668
40669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40671 if (SWIG_arg_fail(1)) SWIG_fail;
40672 {
40673 arg2 = (int)(SWIG_As_int(obj1));
40674 if (SWIG_arg_fail(2)) SWIG_fail;
40675 }
40676 {
40677 PyThreadState* __tstate = wxPyBeginAllowThreads();
40678 (arg1)->SetRows(arg2);
40679
40680 wxPyEndAllowThreads(__tstate);
40681 if (PyErr_Occurred()) SWIG_fail;
40682 }
40683 Py_INCREF(Py_None); resultobj = Py_None;
40684 return resultobj;
40685 fail:
40686 return NULL;
40687 }
40688
40689
40690 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40691 PyObject *resultobj;
40692 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40693 int arg2 ;
40694 PyObject * obj0 = 0 ;
40695 PyObject * obj1 = 0 ;
40696 char *kwnames[] = {
40697 (char *) "self",(char *) "gap", NULL
40698 };
40699
40700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40702 if (SWIG_arg_fail(1)) SWIG_fail;
40703 {
40704 arg2 = (int)(SWIG_As_int(obj1));
40705 if (SWIG_arg_fail(2)) SWIG_fail;
40706 }
40707 {
40708 PyThreadState* __tstate = wxPyBeginAllowThreads();
40709 (arg1)->SetVGap(arg2);
40710
40711 wxPyEndAllowThreads(__tstate);
40712 if (PyErr_Occurred()) SWIG_fail;
40713 }
40714 Py_INCREF(Py_None); resultobj = Py_None;
40715 return resultobj;
40716 fail:
40717 return NULL;
40718 }
40719
40720
40721 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40722 PyObject *resultobj;
40723 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40724 int arg2 ;
40725 PyObject * obj0 = 0 ;
40726 PyObject * obj1 = 0 ;
40727 char *kwnames[] = {
40728 (char *) "self",(char *) "gap", NULL
40729 };
40730
40731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40733 if (SWIG_arg_fail(1)) SWIG_fail;
40734 {
40735 arg2 = (int)(SWIG_As_int(obj1));
40736 if (SWIG_arg_fail(2)) SWIG_fail;
40737 }
40738 {
40739 PyThreadState* __tstate = wxPyBeginAllowThreads();
40740 (arg1)->SetHGap(arg2);
40741
40742 wxPyEndAllowThreads(__tstate);
40743 if (PyErr_Occurred()) SWIG_fail;
40744 }
40745 Py_INCREF(Py_None); resultobj = Py_None;
40746 return resultobj;
40747 fail:
40748 return NULL;
40749 }
40750
40751
40752 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40753 PyObject *resultobj;
40754 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40755 int result;
40756 PyObject * obj0 = 0 ;
40757 char *kwnames[] = {
40758 (char *) "self", NULL
40759 };
40760
40761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40763 if (SWIG_arg_fail(1)) SWIG_fail;
40764 {
40765 PyThreadState* __tstate = wxPyBeginAllowThreads();
40766 result = (int)(arg1)->GetCols();
40767
40768 wxPyEndAllowThreads(__tstate);
40769 if (PyErr_Occurred()) SWIG_fail;
40770 }
40771 {
40772 resultobj = SWIG_From_int((int)(result));
40773 }
40774 return resultobj;
40775 fail:
40776 return NULL;
40777 }
40778
40779
40780 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40781 PyObject *resultobj;
40782 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40783 int result;
40784 PyObject * obj0 = 0 ;
40785 char *kwnames[] = {
40786 (char *) "self", NULL
40787 };
40788
40789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40791 if (SWIG_arg_fail(1)) SWIG_fail;
40792 {
40793 PyThreadState* __tstate = wxPyBeginAllowThreads();
40794 result = (int)(arg1)->GetRows();
40795
40796 wxPyEndAllowThreads(__tstate);
40797 if (PyErr_Occurred()) SWIG_fail;
40798 }
40799 {
40800 resultobj = SWIG_From_int((int)(result));
40801 }
40802 return resultobj;
40803 fail:
40804 return NULL;
40805 }
40806
40807
40808 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40809 PyObject *resultobj;
40810 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40811 int result;
40812 PyObject * obj0 = 0 ;
40813 char *kwnames[] = {
40814 (char *) "self", NULL
40815 };
40816
40817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40819 if (SWIG_arg_fail(1)) SWIG_fail;
40820 {
40821 PyThreadState* __tstate = wxPyBeginAllowThreads();
40822 result = (int)(arg1)->GetVGap();
40823
40824 wxPyEndAllowThreads(__tstate);
40825 if (PyErr_Occurred()) SWIG_fail;
40826 }
40827 {
40828 resultobj = SWIG_From_int((int)(result));
40829 }
40830 return resultobj;
40831 fail:
40832 return NULL;
40833 }
40834
40835
40836 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40837 PyObject *resultobj;
40838 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40839 int result;
40840 PyObject * obj0 = 0 ;
40841 char *kwnames[] = {
40842 (char *) "self", NULL
40843 };
40844
40845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40847 if (SWIG_arg_fail(1)) SWIG_fail;
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 result = (int)(arg1)->GetHGap();
40851
40852 wxPyEndAllowThreads(__tstate);
40853 if (PyErr_Occurred()) SWIG_fail;
40854 }
40855 {
40856 resultobj = SWIG_From_int((int)(result));
40857 }
40858 return resultobj;
40859 fail:
40860 return NULL;
40861 }
40862
40863
40864 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40865 PyObject *obj;
40866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40867 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40868 Py_INCREF(obj);
40869 return Py_BuildValue((char *)"");
40870 }
40871 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40872 PyObject *resultobj;
40873 int arg1 = (int) 1 ;
40874 int arg2 = (int) 0 ;
40875 int arg3 = (int) 0 ;
40876 int arg4 = (int) 0 ;
40877 wxFlexGridSizer *result;
40878 PyObject * obj0 = 0 ;
40879 PyObject * obj1 = 0 ;
40880 PyObject * obj2 = 0 ;
40881 PyObject * obj3 = 0 ;
40882 char *kwnames[] = {
40883 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40884 };
40885
40886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40887 if (obj0) {
40888 {
40889 arg1 = (int)(SWIG_As_int(obj0));
40890 if (SWIG_arg_fail(1)) SWIG_fail;
40891 }
40892 }
40893 if (obj1) {
40894 {
40895 arg2 = (int)(SWIG_As_int(obj1));
40896 if (SWIG_arg_fail(2)) SWIG_fail;
40897 }
40898 }
40899 if (obj2) {
40900 {
40901 arg3 = (int)(SWIG_As_int(obj2));
40902 if (SWIG_arg_fail(3)) SWIG_fail;
40903 }
40904 }
40905 if (obj3) {
40906 {
40907 arg4 = (int)(SWIG_As_int(obj3));
40908 if (SWIG_arg_fail(4)) SWIG_fail;
40909 }
40910 }
40911 {
40912 PyThreadState* __tstate = wxPyBeginAllowThreads();
40913 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40914
40915 wxPyEndAllowThreads(__tstate);
40916 if (PyErr_Occurred()) SWIG_fail;
40917 }
40918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40919 return resultobj;
40920 fail:
40921 return NULL;
40922 }
40923
40924
40925 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40926 PyObject *resultobj;
40927 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40928 size_t arg2 ;
40929 int arg3 = (int) 0 ;
40930 PyObject * obj0 = 0 ;
40931 PyObject * obj1 = 0 ;
40932 PyObject * obj2 = 0 ;
40933 char *kwnames[] = {
40934 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40935 };
40936
40937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40939 if (SWIG_arg_fail(1)) SWIG_fail;
40940 {
40941 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40942 if (SWIG_arg_fail(2)) SWIG_fail;
40943 }
40944 if (obj2) {
40945 {
40946 arg3 = (int)(SWIG_As_int(obj2));
40947 if (SWIG_arg_fail(3)) SWIG_fail;
40948 }
40949 }
40950 {
40951 PyThreadState* __tstate = wxPyBeginAllowThreads();
40952 (arg1)->AddGrowableRow(arg2,arg3);
40953
40954 wxPyEndAllowThreads(__tstate);
40955 if (PyErr_Occurred()) SWIG_fail;
40956 }
40957 Py_INCREF(Py_None); resultobj = Py_None;
40958 return resultobj;
40959 fail:
40960 return NULL;
40961 }
40962
40963
40964 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40965 PyObject *resultobj;
40966 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40967 size_t arg2 ;
40968 PyObject * obj0 = 0 ;
40969 PyObject * obj1 = 0 ;
40970 char *kwnames[] = {
40971 (char *) "self",(char *) "idx", NULL
40972 };
40973
40974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40976 if (SWIG_arg_fail(1)) SWIG_fail;
40977 {
40978 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40979 if (SWIG_arg_fail(2)) SWIG_fail;
40980 }
40981 {
40982 PyThreadState* __tstate = wxPyBeginAllowThreads();
40983 (arg1)->RemoveGrowableRow(arg2);
40984
40985 wxPyEndAllowThreads(__tstate);
40986 if (PyErr_Occurred()) SWIG_fail;
40987 }
40988 Py_INCREF(Py_None); resultobj = Py_None;
40989 return resultobj;
40990 fail:
40991 return NULL;
40992 }
40993
40994
40995 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40996 PyObject *resultobj;
40997 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40998 size_t arg2 ;
40999 int arg3 = (int) 0 ;
41000 PyObject * obj0 = 0 ;
41001 PyObject * obj1 = 0 ;
41002 PyObject * obj2 = 0 ;
41003 char *kwnames[] = {
41004 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41005 };
41006
41007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41009 if (SWIG_arg_fail(1)) SWIG_fail;
41010 {
41011 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41012 if (SWIG_arg_fail(2)) SWIG_fail;
41013 }
41014 if (obj2) {
41015 {
41016 arg3 = (int)(SWIG_As_int(obj2));
41017 if (SWIG_arg_fail(3)) SWIG_fail;
41018 }
41019 }
41020 {
41021 PyThreadState* __tstate = wxPyBeginAllowThreads();
41022 (arg1)->AddGrowableCol(arg2,arg3);
41023
41024 wxPyEndAllowThreads(__tstate);
41025 if (PyErr_Occurred()) SWIG_fail;
41026 }
41027 Py_INCREF(Py_None); resultobj = Py_None;
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41035 PyObject *resultobj;
41036 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41037 size_t arg2 ;
41038 PyObject * obj0 = 0 ;
41039 PyObject * obj1 = 0 ;
41040 char *kwnames[] = {
41041 (char *) "self",(char *) "idx", NULL
41042 };
41043
41044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41046 if (SWIG_arg_fail(1)) SWIG_fail;
41047 {
41048 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41049 if (SWIG_arg_fail(2)) SWIG_fail;
41050 }
41051 {
41052 PyThreadState* __tstate = wxPyBeginAllowThreads();
41053 (arg1)->RemoveGrowableCol(arg2);
41054
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 Py_INCREF(Py_None); resultobj = Py_None;
41059 return resultobj;
41060 fail:
41061 return NULL;
41062 }
41063
41064
41065 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41066 PyObject *resultobj;
41067 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41068 int arg2 ;
41069 PyObject * obj0 = 0 ;
41070 PyObject * obj1 = 0 ;
41071 char *kwnames[] = {
41072 (char *) "self",(char *) "direction", NULL
41073 };
41074
41075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41077 if (SWIG_arg_fail(1)) SWIG_fail;
41078 {
41079 arg2 = (int)(SWIG_As_int(obj1));
41080 if (SWIG_arg_fail(2)) SWIG_fail;
41081 }
41082 {
41083 PyThreadState* __tstate = wxPyBeginAllowThreads();
41084 (arg1)->SetFlexibleDirection(arg2);
41085
41086 wxPyEndAllowThreads(__tstate);
41087 if (PyErr_Occurred()) SWIG_fail;
41088 }
41089 Py_INCREF(Py_None); resultobj = Py_None;
41090 return resultobj;
41091 fail:
41092 return NULL;
41093 }
41094
41095
41096 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41097 PyObject *resultobj;
41098 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41099 int result;
41100 PyObject * obj0 = 0 ;
41101 char *kwnames[] = {
41102 (char *) "self", NULL
41103 };
41104
41105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41107 if (SWIG_arg_fail(1)) SWIG_fail;
41108 {
41109 PyThreadState* __tstate = wxPyBeginAllowThreads();
41110 result = (int)(arg1)->GetFlexibleDirection();
41111
41112 wxPyEndAllowThreads(__tstate);
41113 if (PyErr_Occurred()) SWIG_fail;
41114 }
41115 {
41116 resultobj = SWIG_From_int((int)(result));
41117 }
41118 return resultobj;
41119 fail:
41120 return NULL;
41121 }
41122
41123
41124 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41125 PyObject *resultobj;
41126 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41127 wxFlexSizerGrowMode arg2 ;
41128 PyObject * obj0 = 0 ;
41129 PyObject * obj1 = 0 ;
41130 char *kwnames[] = {
41131 (char *) "self",(char *) "mode", NULL
41132 };
41133
41134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41136 if (SWIG_arg_fail(1)) SWIG_fail;
41137 {
41138 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41139 if (SWIG_arg_fail(2)) SWIG_fail;
41140 }
41141 {
41142 PyThreadState* __tstate = wxPyBeginAllowThreads();
41143 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41144
41145 wxPyEndAllowThreads(__tstate);
41146 if (PyErr_Occurred()) SWIG_fail;
41147 }
41148 Py_INCREF(Py_None); resultobj = Py_None;
41149 return resultobj;
41150 fail:
41151 return NULL;
41152 }
41153
41154
41155 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41156 PyObject *resultobj;
41157 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41158 wxFlexSizerGrowMode result;
41159 PyObject * obj0 = 0 ;
41160 char *kwnames[] = {
41161 (char *) "self", NULL
41162 };
41163
41164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41166 if (SWIG_arg_fail(1)) SWIG_fail;
41167 {
41168 PyThreadState* __tstate = wxPyBeginAllowThreads();
41169 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41170
41171 wxPyEndAllowThreads(__tstate);
41172 if (PyErr_Occurred()) SWIG_fail;
41173 }
41174 resultobj = SWIG_From_int((result));
41175 return resultobj;
41176 fail:
41177 return NULL;
41178 }
41179
41180
41181 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41182 PyObject *resultobj;
41183 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41184 wxArrayInt *result;
41185 PyObject * obj0 = 0 ;
41186 char *kwnames[] = {
41187 (char *) "self", NULL
41188 };
41189
41190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41192 if (SWIG_arg_fail(1)) SWIG_fail;
41193 {
41194 PyThreadState* __tstate = wxPyBeginAllowThreads();
41195 {
41196 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41197 result = (wxArrayInt *) &_result_ref;
41198 }
41199
41200 wxPyEndAllowThreads(__tstate);
41201 if (PyErr_Occurred()) SWIG_fail;
41202 }
41203 {
41204 resultobj = PyList_New(0);
41205 size_t idx;
41206 for (idx = 0; idx < result->GetCount(); idx += 1) {
41207 PyObject* val = PyInt_FromLong( result->Item(idx) );
41208 PyList_Append(resultobj, val);
41209 Py_DECREF(val);
41210 }
41211 }
41212 return resultobj;
41213 fail:
41214 return NULL;
41215 }
41216
41217
41218 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41219 PyObject *resultobj;
41220 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41221 wxArrayInt *result;
41222 PyObject * obj0 = 0 ;
41223 char *kwnames[] = {
41224 (char *) "self", NULL
41225 };
41226
41227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41229 if (SWIG_arg_fail(1)) SWIG_fail;
41230 {
41231 PyThreadState* __tstate = wxPyBeginAllowThreads();
41232 {
41233 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41234 result = (wxArrayInt *) &_result_ref;
41235 }
41236
41237 wxPyEndAllowThreads(__tstate);
41238 if (PyErr_Occurred()) SWIG_fail;
41239 }
41240 {
41241 resultobj = PyList_New(0);
41242 size_t idx;
41243 for (idx = 0; idx < result->GetCount(); idx += 1) {
41244 PyObject* val = PyInt_FromLong( result->Item(idx) );
41245 PyList_Append(resultobj, val);
41246 Py_DECREF(val);
41247 }
41248 }
41249 return resultobj;
41250 fail:
41251 return NULL;
41252 }
41253
41254
41255 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41256 PyObject *obj;
41257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41258 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41259 Py_INCREF(obj);
41260 return Py_BuildValue((char *)"");
41261 }
41262 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41263 PyObject *resultobj;
41264 wxStdDialogButtonSizer *result;
41265 char *kwnames[] = {
41266 NULL
41267 };
41268
41269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41270 {
41271 PyThreadState* __tstate = wxPyBeginAllowThreads();
41272 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41273
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj;
41286 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41287 wxButton *arg2 = (wxButton *) 0 ;
41288 PyObject * obj0 = 0 ;
41289 PyObject * obj1 = 0 ;
41290 char *kwnames[] = {
41291 (char *) "self",(char *) "button", NULL
41292 };
41293
41294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41296 if (SWIG_arg_fail(1)) SWIG_fail;
41297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41298 if (SWIG_arg_fail(2)) SWIG_fail;
41299 {
41300 PyThreadState* __tstate = wxPyBeginAllowThreads();
41301 (arg1)->AddButton(arg2);
41302
41303 wxPyEndAllowThreads(__tstate);
41304 if (PyErr_Occurred()) SWIG_fail;
41305 }
41306 Py_INCREF(Py_None); resultobj = Py_None;
41307 return resultobj;
41308 fail:
41309 return NULL;
41310 }
41311
41312
41313 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41314 PyObject *resultobj;
41315 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41316 PyObject * obj0 = 0 ;
41317 char *kwnames[] = {
41318 (char *) "self", NULL
41319 };
41320
41321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41323 if (SWIG_arg_fail(1)) SWIG_fail;
41324 {
41325 PyThreadState* __tstate = wxPyBeginAllowThreads();
41326 (arg1)->Realize();
41327
41328 wxPyEndAllowThreads(__tstate);
41329 if (PyErr_Occurred()) SWIG_fail;
41330 }
41331 Py_INCREF(Py_None); resultobj = Py_None;
41332 return resultobj;
41333 fail:
41334 return NULL;
41335 }
41336
41337
41338 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41339 PyObject *resultobj;
41340 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41341 wxButton *arg2 = (wxButton *) 0 ;
41342 PyObject * obj0 = 0 ;
41343 PyObject * obj1 = 0 ;
41344 char *kwnames[] = {
41345 (char *) "self",(char *) "button", NULL
41346 };
41347
41348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41350 if (SWIG_arg_fail(1)) SWIG_fail;
41351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41352 if (SWIG_arg_fail(2)) SWIG_fail;
41353 {
41354 PyThreadState* __tstate = wxPyBeginAllowThreads();
41355 (arg1)->SetAffirmativeButton(arg2);
41356
41357 wxPyEndAllowThreads(__tstate);
41358 if (PyErr_Occurred()) SWIG_fail;
41359 }
41360 Py_INCREF(Py_None); resultobj = Py_None;
41361 return resultobj;
41362 fail:
41363 return NULL;
41364 }
41365
41366
41367 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41368 PyObject *resultobj;
41369 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41370 wxButton *arg2 = (wxButton *) 0 ;
41371 PyObject * obj0 = 0 ;
41372 PyObject * obj1 = 0 ;
41373 char *kwnames[] = {
41374 (char *) "self",(char *) "button", NULL
41375 };
41376
41377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41379 if (SWIG_arg_fail(1)) SWIG_fail;
41380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41381 if (SWIG_arg_fail(2)) SWIG_fail;
41382 {
41383 PyThreadState* __tstate = wxPyBeginAllowThreads();
41384 (arg1)->SetNegativeButton(arg2);
41385
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 Py_INCREF(Py_None); resultobj = Py_None;
41390 return resultobj;
41391 fail:
41392 return NULL;
41393 }
41394
41395
41396 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41397 PyObject *resultobj;
41398 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41399 wxButton *arg2 = (wxButton *) 0 ;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 char *kwnames[] = {
41403 (char *) "self",(char *) "button", NULL
41404 };
41405
41406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41408 if (SWIG_arg_fail(1)) SWIG_fail;
41409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41410 if (SWIG_arg_fail(2)) SWIG_fail;
41411 {
41412 PyThreadState* __tstate = wxPyBeginAllowThreads();
41413 (arg1)->SetCancelButton(arg2);
41414
41415 wxPyEndAllowThreads(__tstate);
41416 if (PyErr_Occurred()) SWIG_fail;
41417 }
41418 Py_INCREF(Py_None); resultobj = Py_None;
41419 return resultobj;
41420 fail:
41421 return NULL;
41422 }
41423
41424
41425 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41426 PyObject *resultobj;
41427 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41428 wxButton *result;
41429 PyObject * obj0 = 0 ;
41430 char *kwnames[] = {
41431 (char *) "self", NULL
41432 };
41433
41434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41436 if (SWIG_arg_fail(1)) SWIG_fail;
41437 {
41438 PyThreadState* __tstate = wxPyBeginAllowThreads();
41439 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41440
41441 wxPyEndAllowThreads(__tstate);
41442 if (PyErr_Occurred()) SWIG_fail;
41443 }
41444 {
41445 resultobj = wxPyMake_wxObject(result, 0);
41446 }
41447 return resultobj;
41448 fail:
41449 return NULL;
41450 }
41451
41452
41453 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41454 PyObject *resultobj;
41455 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41456 wxButton *result;
41457 PyObject * obj0 = 0 ;
41458 char *kwnames[] = {
41459 (char *) "self", NULL
41460 };
41461
41462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41464 if (SWIG_arg_fail(1)) SWIG_fail;
41465 {
41466 PyThreadState* __tstate = wxPyBeginAllowThreads();
41467 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41468
41469 wxPyEndAllowThreads(__tstate);
41470 if (PyErr_Occurred()) SWIG_fail;
41471 }
41472 {
41473 resultobj = wxPyMake_wxObject(result, 0);
41474 }
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj;
41483 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41484 wxButton *result;
41485 PyObject * obj0 = 0 ;
41486 char *kwnames[] = {
41487 (char *) "self", NULL
41488 };
41489
41490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41492 if (SWIG_arg_fail(1)) SWIG_fail;
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41496
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 {
41501 resultobj = wxPyMake_wxObject(result, 0);
41502 }
41503 return resultobj;
41504 fail:
41505 return NULL;
41506 }
41507
41508
41509 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41510 PyObject *resultobj;
41511 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41512 wxButton *result;
41513 PyObject * obj0 = 0 ;
41514 char *kwnames[] = {
41515 (char *) "self", NULL
41516 };
41517
41518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41520 if (SWIG_arg_fail(1)) SWIG_fail;
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41524
41525 wxPyEndAllowThreads(__tstate);
41526 if (PyErr_Occurred()) SWIG_fail;
41527 }
41528 {
41529 resultobj = wxPyMake_wxObject(result, 0);
41530 }
41531 return resultobj;
41532 fail:
41533 return NULL;
41534 }
41535
41536
41537 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41538 PyObject *resultobj;
41539 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41540 wxButton *result;
41541 PyObject * obj0 = 0 ;
41542 char *kwnames[] = {
41543 (char *) "self", NULL
41544 };
41545
41546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41548 if (SWIG_arg_fail(1)) SWIG_fail;
41549 {
41550 PyThreadState* __tstate = wxPyBeginAllowThreads();
41551 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41552
41553 wxPyEndAllowThreads(__tstate);
41554 if (PyErr_Occurred()) SWIG_fail;
41555 }
41556 {
41557 resultobj = wxPyMake_wxObject(result, 0);
41558 }
41559 return resultobj;
41560 fail:
41561 return NULL;
41562 }
41563
41564
41565 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41566 PyObject *obj;
41567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41568 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41569 Py_INCREF(obj);
41570 return Py_BuildValue((char *)"");
41571 }
41572 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41573 PyObject *resultobj;
41574 int arg1 = (int) 0 ;
41575 int arg2 = (int) 0 ;
41576 wxGBPosition *result;
41577 PyObject * obj0 = 0 ;
41578 PyObject * obj1 = 0 ;
41579 char *kwnames[] = {
41580 (char *) "row",(char *) "col", NULL
41581 };
41582
41583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41584 if (obj0) {
41585 {
41586 arg1 = (int)(SWIG_As_int(obj0));
41587 if (SWIG_arg_fail(1)) SWIG_fail;
41588 }
41589 }
41590 if (obj1) {
41591 {
41592 arg2 = (int)(SWIG_As_int(obj1));
41593 if (SWIG_arg_fail(2)) SWIG_fail;
41594 }
41595 }
41596 {
41597 PyThreadState* __tstate = wxPyBeginAllowThreads();
41598 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41599
41600 wxPyEndAllowThreads(__tstate);
41601 if (PyErr_Occurred()) SWIG_fail;
41602 }
41603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41604 return resultobj;
41605 fail:
41606 return NULL;
41607 }
41608
41609
41610 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41611 PyObject *resultobj;
41612 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41613 int result;
41614 PyObject * obj0 = 0 ;
41615 char *kwnames[] = {
41616 (char *) "self", NULL
41617 };
41618
41619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41621 if (SWIG_arg_fail(1)) SWIG_fail;
41622 {
41623 PyThreadState* __tstate = wxPyBeginAllowThreads();
41624 result = (int)((wxGBPosition const *)arg1)->GetRow();
41625
41626 wxPyEndAllowThreads(__tstate);
41627 if (PyErr_Occurred()) SWIG_fail;
41628 }
41629 {
41630 resultobj = SWIG_From_int((int)(result));
41631 }
41632 return resultobj;
41633 fail:
41634 return NULL;
41635 }
41636
41637
41638 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41639 PyObject *resultobj;
41640 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41641 int result;
41642 PyObject * obj0 = 0 ;
41643 char *kwnames[] = {
41644 (char *) "self", NULL
41645 };
41646
41647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41649 if (SWIG_arg_fail(1)) SWIG_fail;
41650 {
41651 PyThreadState* __tstate = wxPyBeginAllowThreads();
41652 result = (int)((wxGBPosition const *)arg1)->GetCol();
41653
41654 wxPyEndAllowThreads(__tstate);
41655 if (PyErr_Occurred()) SWIG_fail;
41656 }
41657 {
41658 resultobj = SWIG_From_int((int)(result));
41659 }
41660 return resultobj;
41661 fail:
41662 return NULL;
41663 }
41664
41665
41666 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41667 PyObject *resultobj;
41668 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41669 int arg2 ;
41670 PyObject * obj0 = 0 ;
41671 PyObject * obj1 = 0 ;
41672 char *kwnames[] = {
41673 (char *) "self",(char *) "row", NULL
41674 };
41675
41676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41678 if (SWIG_arg_fail(1)) SWIG_fail;
41679 {
41680 arg2 = (int)(SWIG_As_int(obj1));
41681 if (SWIG_arg_fail(2)) SWIG_fail;
41682 }
41683 {
41684 PyThreadState* __tstate = wxPyBeginAllowThreads();
41685 (arg1)->SetRow(arg2);
41686
41687 wxPyEndAllowThreads(__tstate);
41688 if (PyErr_Occurred()) SWIG_fail;
41689 }
41690 Py_INCREF(Py_None); resultobj = Py_None;
41691 return resultobj;
41692 fail:
41693 return NULL;
41694 }
41695
41696
41697 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41698 PyObject *resultobj;
41699 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41700 int arg2 ;
41701 PyObject * obj0 = 0 ;
41702 PyObject * obj1 = 0 ;
41703 char *kwnames[] = {
41704 (char *) "self",(char *) "col", NULL
41705 };
41706
41707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41709 if (SWIG_arg_fail(1)) SWIG_fail;
41710 {
41711 arg2 = (int)(SWIG_As_int(obj1));
41712 if (SWIG_arg_fail(2)) SWIG_fail;
41713 }
41714 {
41715 PyThreadState* __tstate = wxPyBeginAllowThreads();
41716 (arg1)->SetCol(arg2);
41717
41718 wxPyEndAllowThreads(__tstate);
41719 if (PyErr_Occurred()) SWIG_fail;
41720 }
41721 Py_INCREF(Py_None); resultobj = Py_None;
41722 return resultobj;
41723 fail:
41724 return NULL;
41725 }
41726
41727
41728 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41729 PyObject *resultobj;
41730 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41731 wxGBPosition *arg2 = 0 ;
41732 bool result;
41733 wxGBPosition temp2 ;
41734 PyObject * obj0 = 0 ;
41735 PyObject * obj1 = 0 ;
41736 char *kwnames[] = {
41737 (char *) "self",(char *) "other", NULL
41738 };
41739
41740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41742 if (SWIG_arg_fail(1)) SWIG_fail;
41743 {
41744 arg2 = &temp2;
41745 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41746 }
41747 {
41748 PyThreadState* __tstate = wxPyBeginAllowThreads();
41749 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41750
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 {
41755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41756 }
41757 return resultobj;
41758 fail:
41759 return NULL;
41760 }
41761
41762
41763 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41764 PyObject *resultobj;
41765 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41766 wxGBPosition *arg2 = 0 ;
41767 bool result;
41768 wxGBPosition temp2 ;
41769 PyObject * obj0 = 0 ;
41770 PyObject * obj1 = 0 ;
41771 char *kwnames[] = {
41772 (char *) "self",(char *) "other", NULL
41773 };
41774
41775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41777 if (SWIG_arg_fail(1)) SWIG_fail;
41778 {
41779 arg2 = &temp2;
41780 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41781 }
41782 {
41783 PyThreadState* __tstate = wxPyBeginAllowThreads();
41784 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41785
41786 wxPyEndAllowThreads(__tstate);
41787 if (PyErr_Occurred()) SWIG_fail;
41788 }
41789 {
41790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41791 }
41792 return resultobj;
41793 fail:
41794 return NULL;
41795 }
41796
41797
41798 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41799 PyObject *resultobj;
41800 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41801 int arg2 = (int) 0 ;
41802 int arg3 = (int) 0 ;
41803 PyObject * obj0 = 0 ;
41804 PyObject * obj1 = 0 ;
41805 PyObject * obj2 = 0 ;
41806 char *kwnames[] = {
41807 (char *) "self",(char *) "row",(char *) "col", NULL
41808 };
41809
41810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41812 if (SWIG_arg_fail(1)) SWIG_fail;
41813 if (obj1) {
41814 {
41815 arg2 = (int)(SWIG_As_int(obj1));
41816 if (SWIG_arg_fail(2)) SWIG_fail;
41817 }
41818 }
41819 if (obj2) {
41820 {
41821 arg3 = (int)(SWIG_As_int(obj2));
41822 if (SWIG_arg_fail(3)) SWIG_fail;
41823 }
41824 }
41825 {
41826 PyThreadState* __tstate = wxPyBeginAllowThreads();
41827 wxGBPosition_Set(arg1,arg2,arg3);
41828
41829 wxPyEndAllowThreads(__tstate);
41830 if (PyErr_Occurred()) SWIG_fail;
41831 }
41832 Py_INCREF(Py_None); resultobj = Py_None;
41833 return resultobj;
41834 fail:
41835 return NULL;
41836 }
41837
41838
41839 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41840 PyObject *resultobj;
41841 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41842 PyObject *result;
41843 PyObject * obj0 = 0 ;
41844 char *kwnames[] = {
41845 (char *) "self", NULL
41846 };
41847
41848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41850 if (SWIG_arg_fail(1)) SWIG_fail;
41851 {
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 result = (PyObject *)wxGBPosition_Get(arg1);
41854
41855 wxPyEndAllowThreads(__tstate);
41856 if (PyErr_Occurred()) SWIG_fail;
41857 }
41858 resultobj = result;
41859 return resultobj;
41860 fail:
41861 return NULL;
41862 }
41863
41864
41865 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41866 PyObject *obj;
41867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41868 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41869 Py_INCREF(obj);
41870 return Py_BuildValue((char *)"");
41871 }
41872 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj;
41874 int arg1 = (int) 1 ;
41875 int arg2 = (int) 1 ;
41876 wxGBSpan *result;
41877 PyObject * obj0 = 0 ;
41878 PyObject * obj1 = 0 ;
41879 char *kwnames[] = {
41880 (char *) "rowspan",(char *) "colspan", NULL
41881 };
41882
41883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41884 if (obj0) {
41885 {
41886 arg1 = (int)(SWIG_As_int(obj0));
41887 if (SWIG_arg_fail(1)) SWIG_fail;
41888 }
41889 }
41890 if (obj1) {
41891 {
41892 arg2 = (int)(SWIG_As_int(obj1));
41893 if (SWIG_arg_fail(2)) SWIG_fail;
41894 }
41895 }
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj;
41912 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41913 int result;
41914 PyObject * obj0 = 0 ;
41915 char *kwnames[] = {
41916 (char *) "self", NULL
41917 };
41918
41919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41921 if (SWIG_arg_fail(1)) SWIG_fail;
41922 {
41923 PyThreadState* __tstate = wxPyBeginAllowThreads();
41924 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41925
41926 wxPyEndAllowThreads(__tstate);
41927 if (PyErr_Occurred()) SWIG_fail;
41928 }
41929 {
41930 resultobj = SWIG_From_int((int)(result));
41931 }
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj;
41940 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41941 int result;
41942 PyObject * obj0 = 0 ;
41943 char *kwnames[] = {
41944 (char *) "self", NULL
41945 };
41946
41947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41949 if (SWIG_arg_fail(1)) SWIG_fail;
41950 {
41951 PyThreadState* __tstate = wxPyBeginAllowThreads();
41952 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41953
41954 wxPyEndAllowThreads(__tstate);
41955 if (PyErr_Occurred()) SWIG_fail;
41956 }
41957 {
41958 resultobj = SWIG_From_int((int)(result));
41959 }
41960 return resultobj;
41961 fail:
41962 return NULL;
41963 }
41964
41965
41966 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41967 PyObject *resultobj;
41968 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41969 int arg2 ;
41970 PyObject * obj0 = 0 ;
41971 PyObject * obj1 = 0 ;
41972 char *kwnames[] = {
41973 (char *) "self",(char *) "rowspan", NULL
41974 };
41975
41976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41978 if (SWIG_arg_fail(1)) SWIG_fail;
41979 {
41980 arg2 = (int)(SWIG_As_int(obj1));
41981 if (SWIG_arg_fail(2)) SWIG_fail;
41982 }
41983 {
41984 PyThreadState* __tstate = wxPyBeginAllowThreads();
41985 (arg1)->SetRowspan(arg2);
41986
41987 wxPyEndAllowThreads(__tstate);
41988 if (PyErr_Occurred()) SWIG_fail;
41989 }
41990 Py_INCREF(Py_None); resultobj = Py_None;
41991 return resultobj;
41992 fail:
41993 return NULL;
41994 }
41995
41996
41997 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41998 PyObject *resultobj;
41999 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42000 int arg2 ;
42001 PyObject * obj0 = 0 ;
42002 PyObject * obj1 = 0 ;
42003 char *kwnames[] = {
42004 (char *) "self",(char *) "colspan", NULL
42005 };
42006
42007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42009 if (SWIG_arg_fail(1)) SWIG_fail;
42010 {
42011 arg2 = (int)(SWIG_As_int(obj1));
42012 if (SWIG_arg_fail(2)) SWIG_fail;
42013 }
42014 {
42015 PyThreadState* __tstate = wxPyBeginAllowThreads();
42016 (arg1)->SetColspan(arg2);
42017
42018 wxPyEndAllowThreads(__tstate);
42019 if (PyErr_Occurred()) SWIG_fail;
42020 }
42021 Py_INCREF(Py_None); resultobj = Py_None;
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj;
42030 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42031 wxGBSpan *arg2 = 0 ;
42032 bool result;
42033 wxGBSpan temp2 ;
42034 PyObject * obj0 = 0 ;
42035 PyObject * obj1 = 0 ;
42036 char *kwnames[] = {
42037 (char *) "self",(char *) "other", NULL
42038 };
42039
42040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42042 if (SWIG_arg_fail(1)) SWIG_fail;
42043 {
42044 arg2 = &temp2;
42045 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42046 }
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42050
42051 wxPyEndAllowThreads(__tstate);
42052 if (PyErr_Occurred()) SWIG_fail;
42053 }
42054 {
42055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42056 }
42057 return resultobj;
42058 fail:
42059 return NULL;
42060 }
42061
42062
42063 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42064 PyObject *resultobj;
42065 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42066 wxGBSpan *arg2 = 0 ;
42067 bool result;
42068 wxGBSpan temp2 ;
42069 PyObject * obj0 = 0 ;
42070 PyObject * obj1 = 0 ;
42071 char *kwnames[] = {
42072 (char *) "self",(char *) "other", NULL
42073 };
42074
42075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42077 if (SWIG_arg_fail(1)) SWIG_fail;
42078 {
42079 arg2 = &temp2;
42080 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42081 }
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42085
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42091 }
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj;
42100 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42101 int arg2 = (int) 1 ;
42102 int arg3 = (int) 1 ;
42103 PyObject * obj0 = 0 ;
42104 PyObject * obj1 = 0 ;
42105 PyObject * obj2 = 0 ;
42106 char *kwnames[] = {
42107 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42108 };
42109
42110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42112 if (SWIG_arg_fail(1)) SWIG_fail;
42113 if (obj1) {
42114 {
42115 arg2 = (int)(SWIG_As_int(obj1));
42116 if (SWIG_arg_fail(2)) SWIG_fail;
42117 }
42118 }
42119 if (obj2) {
42120 {
42121 arg3 = (int)(SWIG_As_int(obj2));
42122 if (SWIG_arg_fail(3)) SWIG_fail;
42123 }
42124 }
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 wxGBSpan_Set(arg1,arg2,arg3);
42128
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 Py_INCREF(Py_None); resultobj = Py_None;
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj;
42141 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42142 PyObject *result;
42143 PyObject * obj0 = 0 ;
42144 char *kwnames[] = {
42145 (char *) "self", NULL
42146 };
42147
42148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42150 if (SWIG_arg_fail(1)) SWIG_fail;
42151 {
42152 PyThreadState* __tstate = wxPyBeginAllowThreads();
42153 result = (PyObject *)wxGBSpan_Get(arg1);
42154
42155 wxPyEndAllowThreads(__tstate);
42156 if (PyErr_Occurred()) SWIG_fail;
42157 }
42158 resultobj = result;
42159 return resultobj;
42160 fail:
42161 return NULL;
42162 }
42163
42164
42165 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42166 PyObject *obj;
42167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42168 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42169 Py_INCREF(obj);
42170 return Py_BuildValue((char *)"");
42171 }
42172 static int _wrap_DefaultSpan_set(PyObject *) {
42173 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42174 return 1;
42175 }
42176
42177
42178 static PyObject *_wrap_DefaultSpan_get(void) {
42179 PyObject *pyobj;
42180
42181 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42182 return pyobj;
42183 }
42184
42185
42186 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42187 PyObject *resultobj;
42188 wxGBSizerItem *result;
42189 char *kwnames[] = {
42190 NULL
42191 };
42192
42193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42194 {
42195 PyThreadState* __tstate = wxPyBeginAllowThreads();
42196 result = (wxGBSizerItem *)new wxGBSizerItem();
42197
42198 wxPyEndAllowThreads(__tstate);
42199 if (PyErr_Occurred()) SWIG_fail;
42200 }
42201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42202 return resultobj;
42203 fail:
42204 return NULL;
42205 }
42206
42207
42208 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42209 PyObject *resultobj;
42210 wxWindow *arg1 = (wxWindow *) 0 ;
42211 wxGBPosition *arg2 = 0 ;
42212 wxGBSpan *arg3 = 0 ;
42213 int arg4 ;
42214 int arg5 ;
42215 PyObject *arg6 = (PyObject *) NULL ;
42216 wxGBSizerItem *result;
42217 wxGBPosition temp2 ;
42218 wxGBSpan temp3 ;
42219 PyObject * obj0 = 0 ;
42220 PyObject * obj1 = 0 ;
42221 PyObject * obj2 = 0 ;
42222 PyObject * obj3 = 0 ;
42223 PyObject * obj4 = 0 ;
42224 PyObject * obj5 = 0 ;
42225 char *kwnames[] = {
42226 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42227 };
42228
42229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42231 if (SWIG_arg_fail(1)) SWIG_fail;
42232 {
42233 arg2 = &temp2;
42234 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42235 }
42236 {
42237 arg3 = &temp3;
42238 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42239 }
42240 {
42241 arg4 = (int)(SWIG_As_int(obj3));
42242 if (SWIG_arg_fail(4)) SWIG_fail;
42243 }
42244 {
42245 arg5 = (int)(SWIG_As_int(obj4));
42246 if (SWIG_arg_fail(5)) SWIG_fail;
42247 }
42248 if (obj5) {
42249 arg6 = obj5;
42250 }
42251 {
42252 PyThreadState* __tstate = wxPyBeginAllowThreads();
42253 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42254
42255 wxPyEndAllowThreads(__tstate);
42256 if (PyErr_Occurred()) SWIG_fail;
42257 }
42258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42266 PyObject *resultobj;
42267 wxSizer *arg1 = (wxSizer *) 0 ;
42268 wxGBPosition *arg2 = 0 ;
42269 wxGBSpan *arg3 = 0 ;
42270 int arg4 ;
42271 int arg5 ;
42272 PyObject *arg6 = (PyObject *) NULL ;
42273 wxGBSizerItem *result;
42274 wxGBPosition temp2 ;
42275 wxGBSpan temp3 ;
42276 PyObject * obj0 = 0 ;
42277 PyObject * obj1 = 0 ;
42278 PyObject * obj2 = 0 ;
42279 PyObject * obj3 = 0 ;
42280 PyObject * obj4 = 0 ;
42281 PyObject * obj5 = 0 ;
42282 char *kwnames[] = {
42283 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42284 };
42285
42286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42288 if (SWIG_arg_fail(1)) SWIG_fail;
42289 {
42290 arg2 = &temp2;
42291 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42292 }
42293 {
42294 arg3 = &temp3;
42295 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42296 }
42297 {
42298 arg4 = (int)(SWIG_As_int(obj3));
42299 if (SWIG_arg_fail(4)) SWIG_fail;
42300 }
42301 {
42302 arg5 = (int)(SWIG_As_int(obj4));
42303 if (SWIG_arg_fail(5)) SWIG_fail;
42304 }
42305 if (obj5) {
42306 arg6 = obj5;
42307 }
42308 {
42309 PyThreadState* __tstate = wxPyBeginAllowThreads();
42310 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42311
42312 wxPyEndAllowThreads(__tstate);
42313 if (PyErr_Occurred()) SWIG_fail;
42314 }
42315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42316 return resultobj;
42317 fail:
42318 return NULL;
42319 }
42320
42321
42322 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42323 PyObject *resultobj;
42324 int arg1 ;
42325 int arg2 ;
42326 wxGBPosition *arg3 = 0 ;
42327 wxGBSpan *arg4 = 0 ;
42328 int arg5 ;
42329 int arg6 ;
42330 PyObject *arg7 = (PyObject *) NULL ;
42331 wxGBSizerItem *result;
42332 wxGBPosition temp3 ;
42333 wxGBSpan temp4 ;
42334 PyObject * obj0 = 0 ;
42335 PyObject * obj1 = 0 ;
42336 PyObject * obj2 = 0 ;
42337 PyObject * obj3 = 0 ;
42338 PyObject * obj4 = 0 ;
42339 PyObject * obj5 = 0 ;
42340 PyObject * obj6 = 0 ;
42341 char *kwnames[] = {
42342 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42343 };
42344
42345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42346 {
42347 arg1 = (int)(SWIG_As_int(obj0));
42348 if (SWIG_arg_fail(1)) SWIG_fail;
42349 }
42350 {
42351 arg2 = (int)(SWIG_As_int(obj1));
42352 if (SWIG_arg_fail(2)) SWIG_fail;
42353 }
42354 {
42355 arg3 = &temp3;
42356 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42357 }
42358 {
42359 arg4 = &temp4;
42360 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42361 }
42362 {
42363 arg5 = (int)(SWIG_As_int(obj4));
42364 if (SWIG_arg_fail(5)) SWIG_fail;
42365 }
42366 {
42367 arg6 = (int)(SWIG_As_int(obj5));
42368 if (SWIG_arg_fail(6)) SWIG_fail;
42369 }
42370 if (obj6) {
42371 arg7 = obj6;
42372 }
42373 {
42374 PyThreadState* __tstate = wxPyBeginAllowThreads();
42375 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42376
42377 wxPyEndAllowThreads(__tstate);
42378 if (PyErr_Occurred()) SWIG_fail;
42379 }
42380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42381 return resultobj;
42382 fail:
42383 return NULL;
42384 }
42385
42386
42387 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42388 PyObject *resultobj;
42389 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42390 wxGBPosition result;
42391 PyObject * obj0 = 0 ;
42392 char *kwnames[] = {
42393 (char *) "self", NULL
42394 };
42395
42396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42398 if (SWIG_arg_fail(1)) SWIG_fail;
42399 {
42400 PyThreadState* __tstate = wxPyBeginAllowThreads();
42401 result = ((wxGBSizerItem const *)arg1)->GetPos();
42402
42403 wxPyEndAllowThreads(__tstate);
42404 if (PyErr_Occurred()) SWIG_fail;
42405 }
42406 {
42407 wxGBPosition * resultptr;
42408 resultptr = new wxGBPosition((wxGBPosition &)(result));
42409 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42410 }
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj;
42419 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42420 wxGBSpan result;
42421 PyObject * obj0 = 0 ;
42422 char *kwnames[] = {
42423 (char *) "self", NULL
42424 };
42425
42426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42428 if (SWIG_arg_fail(1)) SWIG_fail;
42429 {
42430 PyThreadState* __tstate = wxPyBeginAllowThreads();
42431 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42432
42433 wxPyEndAllowThreads(__tstate);
42434 if (PyErr_Occurred()) SWIG_fail;
42435 }
42436 {
42437 wxGBSpan * resultptr;
42438 resultptr = new wxGBSpan((wxGBSpan &)(result));
42439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42440 }
42441 return resultobj;
42442 fail:
42443 return NULL;
42444 }
42445
42446
42447 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42448 PyObject *resultobj;
42449 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42450 wxGBPosition *arg2 = 0 ;
42451 bool result;
42452 wxGBPosition temp2 ;
42453 PyObject * obj0 = 0 ;
42454 PyObject * obj1 = 0 ;
42455 char *kwnames[] = {
42456 (char *) "self",(char *) "pos", NULL
42457 };
42458
42459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42461 if (SWIG_arg_fail(1)) SWIG_fail;
42462 {
42463 arg2 = &temp2;
42464 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42465 }
42466 {
42467 PyThreadState* __tstate = wxPyBeginAllowThreads();
42468 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42469
42470 wxPyEndAllowThreads(__tstate);
42471 if (PyErr_Occurred()) SWIG_fail;
42472 }
42473 {
42474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42475 }
42476 return resultobj;
42477 fail:
42478 return NULL;
42479 }
42480
42481
42482 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42483 PyObject *resultobj;
42484 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42485 wxGBSpan *arg2 = 0 ;
42486 bool result;
42487 wxGBSpan temp2 ;
42488 PyObject * obj0 = 0 ;
42489 PyObject * obj1 = 0 ;
42490 char *kwnames[] = {
42491 (char *) "self",(char *) "span", NULL
42492 };
42493
42494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42496 if (SWIG_arg_fail(1)) SWIG_fail;
42497 {
42498 arg2 = &temp2;
42499 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42500 }
42501 {
42502 PyThreadState* __tstate = wxPyBeginAllowThreads();
42503 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42504
42505 wxPyEndAllowThreads(__tstate);
42506 if (PyErr_Occurred()) SWIG_fail;
42507 }
42508 {
42509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42510 }
42511 return resultobj;
42512 fail:
42513 return NULL;
42514 }
42515
42516
42517 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42518 PyObject *resultobj;
42519 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42520 wxGBSizerItem *arg2 = 0 ;
42521 bool result;
42522 PyObject * obj0 = 0 ;
42523 PyObject * obj1 = 0 ;
42524 char *kwnames[] = {
42525 (char *) "self",(char *) "other", NULL
42526 };
42527
42528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42530 if (SWIG_arg_fail(1)) SWIG_fail;
42531 {
42532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42533 if (SWIG_arg_fail(2)) SWIG_fail;
42534 if (arg2 == NULL) {
42535 SWIG_null_ref("wxGBSizerItem");
42536 }
42537 if (SWIG_arg_fail(2)) SWIG_fail;
42538 }
42539 {
42540 PyThreadState* __tstate = wxPyBeginAllowThreads();
42541 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42542
42543 wxPyEndAllowThreads(__tstate);
42544 if (PyErr_Occurred()) SWIG_fail;
42545 }
42546 {
42547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42548 }
42549 return resultobj;
42550 fail:
42551 return NULL;
42552 }
42553
42554
42555 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42556 PyObject *resultobj;
42557 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42558 wxGBPosition *arg2 = 0 ;
42559 wxGBSpan *arg3 = 0 ;
42560 bool result;
42561 wxGBPosition temp2 ;
42562 wxGBSpan temp3 ;
42563 PyObject * obj0 = 0 ;
42564 PyObject * obj1 = 0 ;
42565 PyObject * obj2 = 0 ;
42566 char *kwnames[] = {
42567 (char *) "self",(char *) "pos",(char *) "span", NULL
42568 };
42569
42570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42572 if (SWIG_arg_fail(1)) SWIG_fail;
42573 {
42574 arg2 = &temp2;
42575 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42576 }
42577 {
42578 arg3 = &temp3;
42579 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42580 }
42581 {
42582 PyThreadState* __tstate = wxPyBeginAllowThreads();
42583 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42584
42585 wxPyEndAllowThreads(__tstate);
42586 if (PyErr_Occurred()) SWIG_fail;
42587 }
42588 {
42589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42590 }
42591 return resultobj;
42592 fail:
42593 return NULL;
42594 }
42595
42596
42597 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42598 PyObject *resultobj;
42599 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42600 wxGBPosition result;
42601 PyObject * obj0 = 0 ;
42602 char *kwnames[] = {
42603 (char *) "self", NULL
42604 };
42605
42606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42608 if (SWIG_arg_fail(1)) SWIG_fail;
42609 {
42610 PyThreadState* __tstate = wxPyBeginAllowThreads();
42611 result = wxGBSizerItem_GetEndPos(arg1);
42612
42613 wxPyEndAllowThreads(__tstate);
42614 if (PyErr_Occurred()) SWIG_fail;
42615 }
42616 {
42617 wxGBPosition * resultptr;
42618 resultptr = new wxGBPosition((wxGBPosition &)(result));
42619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42620 }
42621 return resultobj;
42622 fail:
42623 return NULL;
42624 }
42625
42626
42627 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42628 PyObject *resultobj;
42629 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42630 wxGridBagSizer *result;
42631 PyObject * obj0 = 0 ;
42632 char *kwnames[] = {
42633 (char *) "self", NULL
42634 };
42635
42636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42638 if (SWIG_arg_fail(1)) SWIG_fail;
42639 {
42640 PyThreadState* __tstate = wxPyBeginAllowThreads();
42641 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42642
42643 wxPyEndAllowThreads(__tstate);
42644 if (PyErr_Occurred()) SWIG_fail;
42645 }
42646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42647 return resultobj;
42648 fail:
42649 return NULL;
42650 }
42651
42652
42653 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42654 PyObject *resultobj;
42655 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42656 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42657 PyObject * obj0 = 0 ;
42658 PyObject * obj1 = 0 ;
42659 char *kwnames[] = {
42660 (char *) "self",(char *) "sizer", NULL
42661 };
42662
42663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42665 if (SWIG_arg_fail(1)) SWIG_fail;
42666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42667 if (SWIG_arg_fail(2)) SWIG_fail;
42668 {
42669 PyThreadState* __tstate = wxPyBeginAllowThreads();
42670 (arg1)->SetGBSizer(arg2);
42671
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 Py_INCREF(Py_None); resultobj = Py_None;
42676 return resultobj;
42677 fail:
42678 return NULL;
42679 }
42680
42681
42682 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42683 PyObject *obj;
42684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42685 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42686 Py_INCREF(obj);
42687 return Py_BuildValue((char *)"");
42688 }
42689 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42690 PyObject *resultobj;
42691 int arg1 = (int) 0 ;
42692 int arg2 = (int) 0 ;
42693 wxGridBagSizer *result;
42694 PyObject * obj0 = 0 ;
42695 PyObject * obj1 = 0 ;
42696 char *kwnames[] = {
42697 (char *) "vgap",(char *) "hgap", NULL
42698 };
42699
42700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42701 if (obj0) {
42702 {
42703 arg1 = (int)(SWIG_As_int(obj0));
42704 if (SWIG_arg_fail(1)) SWIG_fail;
42705 }
42706 }
42707 if (obj1) {
42708 {
42709 arg2 = (int)(SWIG_As_int(obj1));
42710 if (SWIG_arg_fail(2)) SWIG_fail;
42711 }
42712 }
42713 {
42714 PyThreadState* __tstate = wxPyBeginAllowThreads();
42715 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42716
42717 wxPyEndAllowThreads(__tstate);
42718 if (PyErr_Occurred()) SWIG_fail;
42719 }
42720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42721 return resultobj;
42722 fail:
42723 return NULL;
42724 }
42725
42726
42727 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42728 PyObject *resultobj;
42729 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42730 PyObject *arg2 = (PyObject *) 0 ;
42731 wxGBPosition *arg3 = 0 ;
42732 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42733 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42734 int arg5 = (int) 0 ;
42735 int arg6 = (int) 0 ;
42736 PyObject *arg7 = (PyObject *) NULL ;
42737 wxGBSizerItem *result;
42738 wxGBPosition temp3 ;
42739 wxGBSpan temp4 ;
42740 PyObject * obj0 = 0 ;
42741 PyObject * obj1 = 0 ;
42742 PyObject * obj2 = 0 ;
42743 PyObject * obj3 = 0 ;
42744 PyObject * obj4 = 0 ;
42745 PyObject * obj5 = 0 ;
42746 PyObject * obj6 = 0 ;
42747 char *kwnames[] = {
42748 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42749 };
42750
42751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42753 if (SWIG_arg_fail(1)) SWIG_fail;
42754 arg2 = obj1;
42755 {
42756 arg3 = &temp3;
42757 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42758 }
42759 if (obj3) {
42760 {
42761 arg4 = &temp4;
42762 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42763 }
42764 }
42765 if (obj4) {
42766 {
42767 arg5 = (int)(SWIG_As_int(obj4));
42768 if (SWIG_arg_fail(5)) SWIG_fail;
42769 }
42770 }
42771 if (obj5) {
42772 {
42773 arg6 = (int)(SWIG_As_int(obj5));
42774 if (SWIG_arg_fail(6)) SWIG_fail;
42775 }
42776 }
42777 if (obj6) {
42778 arg7 = obj6;
42779 }
42780 {
42781 PyThreadState* __tstate = wxPyBeginAllowThreads();
42782 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42783
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42788 return resultobj;
42789 fail:
42790 return NULL;
42791 }
42792
42793
42794 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42795 PyObject *resultobj;
42796 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42797 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42798 wxGBSizerItem *result;
42799 PyObject * obj0 = 0 ;
42800 PyObject * obj1 = 0 ;
42801 char *kwnames[] = {
42802 (char *) "self",(char *) "item", NULL
42803 };
42804
42805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42807 if (SWIG_arg_fail(1)) SWIG_fail;
42808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42809 if (SWIG_arg_fail(2)) SWIG_fail;
42810 {
42811 PyThreadState* __tstate = wxPyBeginAllowThreads();
42812 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42813
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42818 return resultobj;
42819 fail:
42820 return NULL;
42821 }
42822
42823
42824 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42825 PyObject *resultobj;
42826 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42827 int arg2 ;
42828 int arg3 ;
42829 wxSize result;
42830 PyObject * obj0 = 0 ;
42831 PyObject * obj1 = 0 ;
42832 PyObject * obj2 = 0 ;
42833 char *kwnames[] = {
42834 (char *) "self",(char *) "row",(char *) "col", NULL
42835 };
42836
42837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42839 if (SWIG_arg_fail(1)) SWIG_fail;
42840 {
42841 arg2 = (int)(SWIG_As_int(obj1));
42842 if (SWIG_arg_fail(2)) SWIG_fail;
42843 }
42844 {
42845 arg3 = (int)(SWIG_As_int(obj2));
42846 if (SWIG_arg_fail(3)) SWIG_fail;
42847 }
42848 {
42849 PyThreadState* __tstate = wxPyBeginAllowThreads();
42850 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42851
42852 wxPyEndAllowThreads(__tstate);
42853 if (PyErr_Occurred()) SWIG_fail;
42854 }
42855 {
42856 wxSize * resultptr;
42857 resultptr = new wxSize((wxSize &)(result));
42858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42859 }
42860 return resultobj;
42861 fail:
42862 return NULL;
42863 }
42864
42865
42866 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42867 PyObject *resultobj;
42868 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42869 wxSize result;
42870 PyObject * obj0 = 0 ;
42871 char *kwnames[] = {
42872 (char *) "self", NULL
42873 };
42874
42875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42877 if (SWIG_arg_fail(1)) SWIG_fail;
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42881
42882 wxPyEndAllowThreads(__tstate);
42883 if (PyErr_Occurred()) SWIG_fail;
42884 }
42885 {
42886 wxSize * resultptr;
42887 resultptr = new wxSize((wxSize &)(result));
42888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42889 }
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42897 PyObject *resultobj;
42898 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42899 wxSize *arg2 = 0 ;
42900 wxSize temp2 ;
42901 PyObject * obj0 = 0 ;
42902 PyObject * obj1 = 0 ;
42903 char *kwnames[] = {
42904 (char *) "self",(char *) "sz", NULL
42905 };
42906
42907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42909 if (SWIG_arg_fail(1)) SWIG_fail;
42910 {
42911 arg2 = &temp2;
42912 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42913 }
42914 {
42915 PyThreadState* __tstate = wxPyBeginAllowThreads();
42916 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42917
42918 wxPyEndAllowThreads(__tstate);
42919 if (PyErr_Occurred()) SWIG_fail;
42920 }
42921 Py_INCREF(Py_None); resultobj = Py_None;
42922 return resultobj;
42923 fail:
42924 return NULL;
42925 }
42926
42927
42928 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42929 PyObject *resultobj;
42930 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42931 wxWindow *arg2 = (wxWindow *) 0 ;
42932 wxGBPosition result;
42933 PyObject * obj0 = 0 ;
42934 PyObject * obj1 = 0 ;
42935
42936 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42938 if (SWIG_arg_fail(1)) SWIG_fail;
42939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42940 if (SWIG_arg_fail(2)) SWIG_fail;
42941 {
42942 PyThreadState* __tstate = wxPyBeginAllowThreads();
42943 result = (arg1)->GetItemPosition(arg2);
42944
42945 wxPyEndAllowThreads(__tstate);
42946 if (PyErr_Occurred()) SWIG_fail;
42947 }
42948 {
42949 wxGBPosition * resultptr;
42950 resultptr = new wxGBPosition((wxGBPosition &)(result));
42951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42952 }
42953 return resultobj;
42954 fail:
42955 return NULL;
42956 }
42957
42958
42959 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42960 PyObject *resultobj;
42961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42962 wxSizer *arg2 = (wxSizer *) 0 ;
42963 wxGBPosition result;
42964 PyObject * obj0 = 0 ;
42965 PyObject * obj1 = 0 ;
42966
42967 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42971 if (SWIG_arg_fail(2)) SWIG_fail;
42972 {
42973 PyThreadState* __tstate = wxPyBeginAllowThreads();
42974 result = (arg1)->GetItemPosition(arg2);
42975
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 {
42980 wxGBPosition * resultptr;
42981 resultptr = new wxGBPosition((wxGBPosition &)(result));
42982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42983 }
42984 return resultobj;
42985 fail:
42986 return NULL;
42987 }
42988
42989
42990 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42991 PyObject *resultobj;
42992 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42993 size_t arg2 ;
42994 wxGBPosition result;
42995 PyObject * obj0 = 0 ;
42996 PyObject * obj1 = 0 ;
42997
42998 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43000 if (SWIG_arg_fail(1)) SWIG_fail;
43001 {
43002 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43003 if (SWIG_arg_fail(2)) SWIG_fail;
43004 }
43005 {
43006 PyThreadState* __tstate = wxPyBeginAllowThreads();
43007 result = (arg1)->GetItemPosition(arg2);
43008
43009 wxPyEndAllowThreads(__tstate);
43010 if (PyErr_Occurred()) SWIG_fail;
43011 }
43012 {
43013 wxGBPosition * resultptr;
43014 resultptr = new wxGBPosition((wxGBPosition &)(result));
43015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43016 }
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43024 int argc;
43025 PyObject *argv[3];
43026 int ii;
43027
43028 argc = PyObject_Length(args);
43029 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43030 argv[ii] = PyTuple_GetItem(args,ii);
43031 }
43032 if (argc == 2) {
43033 int _v;
43034 {
43035 void *ptr;
43036 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43037 _v = 0;
43038 PyErr_Clear();
43039 } else {
43040 _v = 1;
43041 }
43042 }
43043 if (_v) {
43044 {
43045 void *ptr;
43046 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43047 _v = 0;
43048 PyErr_Clear();
43049 } else {
43050 _v = 1;
43051 }
43052 }
43053 if (_v) {
43054 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43055 }
43056 }
43057 }
43058 if (argc == 2) {
43059 int _v;
43060 {
43061 void *ptr;
43062 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43063 _v = 0;
43064 PyErr_Clear();
43065 } else {
43066 _v = 1;
43067 }
43068 }
43069 if (_v) {
43070 {
43071 void *ptr;
43072 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43073 _v = 0;
43074 PyErr_Clear();
43075 } else {
43076 _v = 1;
43077 }
43078 }
43079 if (_v) {
43080 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43081 }
43082 }
43083 }
43084 if (argc == 2) {
43085 int _v;
43086 {
43087 void *ptr;
43088 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43089 _v = 0;
43090 PyErr_Clear();
43091 } else {
43092 _v = 1;
43093 }
43094 }
43095 if (_v) {
43096 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43097 if (_v) {
43098 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43099 }
43100 }
43101 }
43102
43103 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43104 return NULL;
43105 }
43106
43107
43108 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43109 PyObject *resultobj;
43110 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43111 wxWindow *arg2 = (wxWindow *) 0 ;
43112 wxGBPosition *arg3 = 0 ;
43113 bool result;
43114 wxGBPosition temp3 ;
43115 PyObject * obj0 = 0 ;
43116 PyObject * obj1 = 0 ;
43117 PyObject * obj2 = 0 ;
43118
43119 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43121 if (SWIG_arg_fail(1)) SWIG_fail;
43122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43123 if (SWIG_arg_fail(2)) SWIG_fail;
43124 {
43125 arg3 = &temp3;
43126 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43127 }
43128 {
43129 PyThreadState* __tstate = wxPyBeginAllowThreads();
43130 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43131
43132 wxPyEndAllowThreads(__tstate);
43133 if (PyErr_Occurred()) SWIG_fail;
43134 }
43135 {
43136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43137 }
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43145 PyObject *resultobj;
43146 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43147 wxSizer *arg2 = (wxSizer *) 0 ;
43148 wxGBPosition *arg3 = 0 ;
43149 bool result;
43150 wxGBPosition temp3 ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 PyObject * obj2 = 0 ;
43154
43155 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43157 if (SWIG_arg_fail(1)) SWIG_fail;
43158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43159 if (SWIG_arg_fail(2)) SWIG_fail;
43160 {
43161 arg3 = &temp3;
43162 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43163 }
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43167
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 {
43172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43173 }
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43181 PyObject *resultobj;
43182 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43183 size_t arg2 ;
43184 wxGBPosition *arg3 = 0 ;
43185 bool result;
43186 wxGBPosition temp3 ;
43187 PyObject * obj0 = 0 ;
43188 PyObject * obj1 = 0 ;
43189 PyObject * obj2 = 0 ;
43190
43191 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43193 if (SWIG_arg_fail(1)) SWIG_fail;
43194 {
43195 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43196 if (SWIG_arg_fail(2)) SWIG_fail;
43197 }
43198 {
43199 arg3 = &temp3;
43200 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43201 }
43202 {
43203 PyThreadState* __tstate = wxPyBeginAllowThreads();
43204 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43205
43206 wxPyEndAllowThreads(__tstate);
43207 if (PyErr_Occurred()) SWIG_fail;
43208 }
43209 {
43210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43211 }
43212 return resultobj;
43213 fail:
43214 return NULL;
43215 }
43216
43217
43218 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43219 int argc;
43220 PyObject *argv[4];
43221 int ii;
43222
43223 argc = PyObject_Length(args);
43224 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43225 argv[ii] = PyTuple_GetItem(args,ii);
43226 }
43227 if (argc == 3) {
43228 int _v;
43229 {
43230 void *ptr;
43231 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43232 _v = 0;
43233 PyErr_Clear();
43234 } else {
43235 _v = 1;
43236 }
43237 }
43238 if (_v) {
43239 {
43240 void *ptr;
43241 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43242 _v = 0;
43243 PyErr_Clear();
43244 } else {
43245 _v = 1;
43246 }
43247 }
43248 if (_v) {
43249 {
43250 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43251 }
43252 if (_v) {
43253 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43254 }
43255 }
43256 }
43257 }
43258 if (argc == 3) {
43259 int _v;
43260 {
43261 void *ptr;
43262 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43263 _v = 0;
43264 PyErr_Clear();
43265 } else {
43266 _v = 1;
43267 }
43268 }
43269 if (_v) {
43270 {
43271 void *ptr;
43272 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43273 _v = 0;
43274 PyErr_Clear();
43275 } else {
43276 _v = 1;
43277 }
43278 }
43279 if (_v) {
43280 {
43281 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43282 }
43283 if (_v) {
43284 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43285 }
43286 }
43287 }
43288 }
43289 if (argc == 3) {
43290 int _v;
43291 {
43292 void *ptr;
43293 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43294 _v = 0;
43295 PyErr_Clear();
43296 } else {
43297 _v = 1;
43298 }
43299 }
43300 if (_v) {
43301 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43302 if (_v) {
43303 {
43304 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43305 }
43306 if (_v) {
43307 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43308 }
43309 }
43310 }
43311 }
43312
43313 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43314 return NULL;
43315 }
43316
43317
43318 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43319 PyObject *resultobj;
43320 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43321 wxWindow *arg2 = (wxWindow *) 0 ;
43322 wxGBSpan result;
43323 PyObject * obj0 = 0 ;
43324 PyObject * obj1 = 0 ;
43325
43326 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43328 if (SWIG_arg_fail(1)) SWIG_fail;
43329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43330 if (SWIG_arg_fail(2)) SWIG_fail;
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 result = (arg1)->GetItemSpan(arg2);
43334
43335 wxPyEndAllowThreads(__tstate);
43336 if (PyErr_Occurred()) SWIG_fail;
43337 }
43338 {
43339 wxGBSpan * resultptr;
43340 resultptr = new wxGBSpan((wxGBSpan &)(result));
43341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43342 }
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43350 PyObject *resultobj;
43351 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43352 wxSizer *arg2 = (wxSizer *) 0 ;
43353 wxGBSpan result;
43354 PyObject * obj0 = 0 ;
43355 PyObject * obj1 = 0 ;
43356
43357 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43359 if (SWIG_arg_fail(1)) SWIG_fail;
43360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43361 if (SWIG_arg_fail(2)) SWIG_fail;
43362 {
43363 PyThreadState* __tstate = wxPyBeginAllowThreads();
43364 result = (arg1)->GetItemSpan(arg2);
43365
43366 wxPyEndAllowThreads(__tstate);
43367 if (PyErr_Occurred()) SWIG_fail;
43368 }
43369 {
43370 wxGBSpan * resultptr;
43371 resultptr = new wxGBSpan((wxGBSpan &)(result));
43372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43373 }
43374 return resultobj;
43375 fail:
43376 return NULL;
43377 }
43378
43379
43380 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43381 PyObject *resultobj;
43382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43383 size_t arg2 ;
43384 wxGBSpan result;
43385 PyObject * obj0 = 0 ;
43386 PyObject * obj1 = 0 ;
43387
43388 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43390 if (SWIG_arg_fail(1)) SWIG_fail;
43391 {
43392 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43393 if (SWIG_arg_fail(2)) SWIG_fail;
43394 }
43395 {
43396 PyThreadState* __tstate = wxPyBeginAllowThreads();
43397 result = (arg1)->GetItemSpan(arg2);
43398
43399 wxPyEndAllowThreads(__tstate);
43400 if (PyErr_Occurred()) SWIG_fail;
43401 }
43402 {
43403 wxGBSpan * resultptr;
43404 resultptr = new wxGBSpan((wxGBSpan &)(result));
43405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43406 }
43407 return resultobj;
43408 fail:
43409 return NULL;
43410 }
43411
43412
43413 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43414 int argc;
43415 PyObject *argv[3];
43416 int ii;
43417
43418 argc = PyObject_Length(args);
43419 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43420 argv[ii] = PyTuple_GetItem(args,ii);
43421 }
43422 if (argc == 2) {
43423 int _v;
43424 {
43425 void *ptr;
43426 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43427 _v = 0;
43428 PyErr_Clear();
43429 } else {
43430 _v = 1;
43431 }
43432 }
43433 if (_v) {
43434 {
43435 void *ptr;
43436 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43437 _v = 0;
43438 PyErr_Clear();
43439 } else {
43440 _v = 1;
43441 }
43442 }
43443 if (_v) {
43444 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43445 }
43446 }
43447 }
43448 if (argc == 2) {
43449 int _v;
43450 {
43451 void *ptr;
43452 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43453 _v = 0;
43454 PyErr_Clear();
43455 } else {
43456 _v = 1;
43457 }
43458 }
43459 if (_v) {
43460 {
43461 void *ptr;
43462 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43463 _v = 0;
43464 PyErr_Clear();
43465 } else {
43466 _v = 1;
43467 }
43468 }
43469 if (_v) {
43470 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43471 }
43472 }
43473 }
43474 if (argc == 2) {
43475 int _v;
43476 {
43477 void *ptr;
43478 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43479 _v = 0;
43480 PyErr_Clear();
43481 } else {
43482 _v = 1;
43483 }
43484 }
43485 if (_v) {
43486 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43487 if (_v) {
43488 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43489 }
43490 }
43491 }
43492
43493 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43494 return NULL;
43495 }
43496
43497
43498 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43499 PyObject *resultobj;
43500 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43501 wxWindow *arg2 = (wxWindow *) 0 ;
43502 wxGBSpan *arg3 = 0 ;
43503 bool result;
43504 wxGBSpan temp3 ;
43505 PyObject * obj0 = 0 ;
43506 PyObject * obj1 = 0 ;
43507 PyObject * obj2 = 0 ;
43508
43509 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43511 if (SWIG_arg_fail(1)) SWIG_fail;
43512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43513 if (SWIG_arg_fail(2)) SWIG_fail;
43514 {
43515 arg3 = &temp3;
43516 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43517 }
43518 {
43519 PyThreadState* __tstate = wxPyBeginAllowThreads();
43520 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43521
43522 wxPyEndAllowThreads(__tstate);
43523 if (PyErr_Occurred()) SWIG_fail;
43524 }
43525 {
43526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43527 }
43528 return resultobj;
43529 fail:
43530 return NULL;
43531 }
43532
43533
43534 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43535 PyObject *resultobj;
43536 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43537 wxSizer *arg2 = (wxSizer *) 0 ;
43538 wxGBSpan *arg3 = 0 ;
43539 bool result;
43540 wxGBSpan temp3 ;
43541 PyObject * obj0 = 0 ;
43542 PyObject * obj1 = 0 ;
43543 PyObject * obj2 = 0 ;
43544
43545 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43547 if (SWIG_arg_fail(1)) SWIG_fail;
43548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43549 if (SWIG_arg_fail(2)) SWIG_fail;
43550 {
43551 arg3 = &temp3;
43552 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43553 }
43554 {
43555 PyThreadState* __tstate = wxPyBeginAllowThreads();
43556 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43557
43558 wxPyEndAllowThreads(__tstate);
43559 if (PyErr_Occurred()) SWIG_fail;
43560 }
43561 {
43562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43563 }
43564 return resultobj;
43565 fail:
43566 return NULL;
43567 }
43568
43569
43570 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43571 PyObject *resultobj;
43572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43573 size_t arg2 ;
43574 wxGBSpan *arg3 = 0 ;
43575 bool result;
43576 wxGBSpan temp3 ;
43577 PyObject * obj0 = 0 ;
43578 PyObject * obj1 = 0 ;
43579 PyObject * obj2 = 0 ;
43580
43581 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43583 if (SWIG_arg_fail(1)) SWIG_fail;
43584 {
43585 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43586 if (SWIG_arg_fail(2)) SWIG_fail;
43587 }
43588 {
43589 arg3 = &temp3;
43590 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43591 }
43592 {
43593 PyThreadState* __tstate = wxPyBeginAllowThreads();
43594 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43595
43596 wxPyEndAllowThreads(__tstate);
43597 if (PyErr_Occurred()) SWIG_fail;
43598 }
43599 {
43600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43601 }
43602 return resultobj;
43603 fail:
43604 return NULL;
43605 }
43606
43607
43608 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43609 int argc;
43610 PyObject *argv[4];
43611 int ii;
43612
43613 argc = PyObject_Length(args);
43614 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43615 argv[ii] = PyTuple_GetItem(args,ii);
43616 }
43617 if (argc == 3) {
43618 int _v;
43619 {
43620 void *ptr;
43621 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43622 _v = 0;
43623 PyErr_Clear();
43624 } else {
43625 _v = 1;
43626 }
43627 }
43628 if (_v) {
43629 {
43630 void *ptr;
43631 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43632 _v = 0;
43633 PyErr_Clear();
43634 } else {
43635 _v = 1;
43636 }
43637 }
43638 if (_v) {
43639 {
43640 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43641 }
43642 if (_v) {
43643 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43644 }
43645 }
43646 }
43647 }
43648 if (argc == 3) {
43649 int _v;
43650 {
43651 void *ptr;
43652 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43653 _v = 0;
43654 PyErr_Clear();
43655 } else {
43656 _v = 1;
43657 }
43658 }
43659 if (_v) {
43660 {
43661 void *ptr;
43662 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43663 _v = 0;
43664 PyErr_Clear();
43665 } else {
43666 _v = 1;
43667 }
43668 }
43669 if (_v) {
43670 {
43671 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43672 }
43673 if (_v) {
43674 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43675 }
43676 }
43677 }
43678 }
43679 if (argc == 3) {
43680 int _v;
43681 {
43682 void *ptr;
43683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43684 _v = 0;
43685 PyErr_Clear();
43686 } else {
43687 _v = 1;
43688 }
43689 }
43690 if (_v) {
43691 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43692 if (_v) {
43693 {
43694 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43695 }
43696 if (_v) {
43697 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43698 }
43699 }
43700 }
43701 }
43702
43703 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43704 return NULL;
43705 }
43706
43707
43708 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43709 PyObject *resultobj;
43710 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43711 wxWindow *arg2 = (wxWindow *) 0 ;
43712 wxGBSizerItem *result;
43713 PyObject * obj0 = 0 ;
43714 PyObject * obj1 = 0 ;
43715
43716 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43718 if (SWIG_arg_fail(1)) SWIG_fail;
43719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43720 if (SWIG_arg_fail(2)) SWIG_fail;
43721 {
43722 PyThreadState* __tstate = wxPyBeginAllowThreads();
43723 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43724
43725 wxPyEndAllowThreads(__tstate);
43726 if (PyErr_Occurred()) SWIG_fail;
43727 }
43728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43729 return resultobj;
43730 fail:
43731 return NULL;
43732 }
43733
43734
43735 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43736 PyObject *resultobj;
43737 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43738 wxSizer *arg2 = (wxSizer *) 0 ;
43739 wxGBSizerItem *result;
43740 PyObject * obj0 = 0 ;
43741 PyObject * obj1 = 0 ;
43742
43743 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43745 if (SWIG_arg_fail(1)) SWIG_fail;
43746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43747 if (SWIG_arg_fail(2)) SWIG_fail;
43748 {
43749 PyThreadState* __tstate = wxPyBeginAllowThreads();
43750 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43751
43752 wxPyEndAllowThreads(__tstate);
43753 if (PyErr_Occurred()) SWIG_fail;
43754 }
43755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43756 return resultobj;
43757 fail:
43758 return NULL;
43759 }
43760
43761
43762 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43763 int argc;
43764 PyObject *argv[3];
43765 int ii;
43766
43767 argc = PyObject_Length(args);
43768 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43769 argv[ii] = PyTuple_GetItem(args,ii);
43770 }
43771 if (argc == 2) {
43772 int _v;
43773 {
43774 void *ptr;
43775 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43776 _v = 0;
43777 PyErr_Clear();
43778 } else {
43779 _v = 1;
43780 }
43781 }
43782 if (_v) {
43783 {
43784 void *ptr;
43785 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43786 _v = 0;
43787 PyErr_Clear();
43788 } else {
43789 _v = 1;
43790 }
43791 }
43792 if (_v) {
43793 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43794 }
43795 }
43796 }
43797 if (argc == 2) {
43798 int _v;
43799 {
43800 void *ptr;
43801 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43802 _v = 0;
43803 PyErr_Clear();
43804 } else {
43805 _v = 1;
43806 }
43807 }
43808 if (_v) {
43809 {
43810 void *ptr;
43811 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43812 _v = 0;
43813 PyErr_Clear();
43814 } else {
43815 _v = 1;
43816 }
43817 }
43818 if (_v) {
43819 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43820 }
43821 }
43822 }
43823
43824 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43825 return NULL;
43826 }
43827
43828
43829 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43830 PyObject *resultobj;
43831 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43832 wxGBPosition *arg2 = 0 ;
43833 wxGBSizerItem *result;
43834 wxGBPosition temp2 ;
43835 PyObject * obj0 = 0 ;
43836 PyObject * obj1 = 0 ;
43837 char *kwnames[] = {
43838 (char *) "self",(char *) "pos", NULL
43839 };
43840
43841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43843 if (SWIG_arg_fail(1)) SWIG_fail;
43844 {
43845 arg2 = &temp2;
43846 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43847 }
43848 {
43849 PyThreadState* __tstate = wxPyBeginAllowThreads();
43850 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43851
43852 wxPyEndAllowThreads(__tstate);
43853 if (PyErr_Occurred()) SWIG_fail;
43854 }
43855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43856 return resultobj;
43857 fail:
43858 return NULL;
43859 }
43860
43861
43862 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43863 PyObject *resultobj;
43864 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43865 wxPoint *arg2 = 0 ;
43866 wxGBSizerItem *result;
43867 wxPoint temp2 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 char *kwnames[] = {
43871 (char *) "self",(char *) "pt", NULL
43872 };
43873
43874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43876 if (SWIG_arg_fail(1)) SWIG_fail;
43877 {
43878 arg2 = &temp2;
43879 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43880 }
43881 {
43882 PyThreadState* __tstate = wxPyBeginAllowThreads();
43883 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43884
43885 wxPyEndAllowThreads(__tstate);
43886 if (PyErr_Occurred()) SWIG_fail;
43887 }
43888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43889 return resultobj;
43890 fail:
43891 return NULL;
43892 }
43893
43894
43895 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43896 PyObject *resultobj;
43897 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43898 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43899 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43900 bool result;
43901 PyObject * obj0 = 0 ;
43902 PyObject * obj1 = 0 ;
43903 PyObject * obj2 = 0 ;
43904 char *kwnames[] = {
43905 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43906 };
43907
43908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43910 if (SWIG_arg_fail(1)) SWIG_fail;
43911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43912 if (SWIG_arg_fail(2)) SWIG_fail;
43913 if (obj2) {
43914 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43915 if (SWIG_arg_fail(3)) SWIG_fail;
43916 }
43917 {
43918 PyThreadState* __tstate = wxPyBeginAllowThreads();
43919 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43920
43921 wxPyEndAllowThreads(__tstate);
43922 if (PyErr_Occurred()) SWIG_fail;
43923 }
43924 {
43925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43926 }
43927 return resultobj;
43928 fail:
43929 return NULL;
43930 }
43931
43932
43933 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43934 PyObject *resultobj;
43935 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43936 wxGBPosition *arg2 = 0 ;
43937 wxGBSpan *arg3 = 0 ;
43938 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43939 bool result;
43940 wxGBPosition temp2 ;
43941 wxGBSpan temp3 ;
43942 PyObject * obj0 = 0 ;
43943 PyObject * obj1 = 0 ;
43944 PyObject * obj2 = 0 ;
43945 PyObject * obj3 = 0 ;
43946 char *kwnames[] = {
43947 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43948 };
43949
43950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43952 if (SWIG_arg_fail(1)) SWIG_fail;
43953 {
43954 arg2 = &temp2;
43955 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43956 }
43957 {
43958 arg3 = &temp3;
43959 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43960 }
43961 if (obj3) {
43962 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43963 if (SWIG_arg_fail(4)) SWIG_fail;
43964 }
43965 {
43966 PyThreadState* __tstate = wxPyBeginAllowThreads();
43967 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43968
43969 wxPyEndAllowThreads(__tstate);
43970 if (PyErr_Occurred()) SWIG_fail;
43971 }
43972 {
43973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43974 }
43975 return resultobj;
43976 fail:
43977 return NULL;
43978 }
43979
43980
43981 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43982 PyObject *obj;
43983 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43984 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43985 Py_INCREF(obj);
43986 return Py_BuildValue((char *)"");
43987 }
43988 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43989 PyObject *resultobj;
43990 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43991 wxRelationship arg2 ;
43992 wxWindow *arg3 = (wxWindow *) 0 ;
43993 wxEdge arg4 ;
43994 int arg5 = (int) 0 ;
43995 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43996 PyObject * obj0 = 0 ;
43997 PyObject * obj1 = 0 ;
43998 PyObject * obj2 = 0 ;
43999 PyObject * obj3 = 0 ;
44000 PyObject * obj4 = 0 ;
44001 PyObject * obj5 = 0 ;
44002 char *kwnames[] = {
44003 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44004 };
44005
44006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44008 if (SWIG_arg_fail(1)) SWIG_fail;
44009 {
44010 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44011 if (SWIG_arg_fail(2)) SWIG_fail;
44012 }
44013 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44014 if (SWIG_arg_fail(3)) SWIG_fail;
44015 {
44016 arg4 = (wxEdge)(SWIG_As_int(obj3));
44017 if (SWIG_arg_fail(4)) SWIG_fail;
44018 }
44019 if (obj4) {
44020 {
44021 arg5 = (int)(SWIG_As_int(obj4));
44022 if (SWIG_arg_fail(5)) SWIG_fail;
44023 }
44024 }
44025 if (obj5) {
44026 {
44027 arg6 = (int)(SWIG_As_int(obj5));
44028 if (SWIG_arg_fail(6)) SWIG_fail;
44029 }
44030 }
44031 {
44032 PyThreadState* __tstate = wxPyBeginAllowThreads();
44033 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44034
44035 wxPyEndAllowThreads(__tstate);
44036 if (PyErr_Occurred()) SWIG_fail;
44037 }
44038 Py_INCREF(Py_None); resultobj = Py_None;
44039 return resultobj;
44040 fail:
44041 return NULL;
44042 }
44043
44044
44045 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44046 PyObject *resultobj;
44047 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44048 wxWindow *arg2 = (wxWindow *) 0 ;
44049 int arg3 = (int) 0 ;
44050 PyObject * obj0 = 0 ;
44051 PyObject * obj1 = 0 ;
44052 PyObject * obj2 = 0 ;
44053 char *kwnames[] = {
44054 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44055 };
44056
44057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44059 if (SWIG_arg_fail(1)) SWIG_fail;
44060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44061 if (SWIG_arg_fail(2)) SWIG_fail;
44062 if (obj2) {
44063 {
44064 arg3 = (int)(SWIG_As_int(obj2));
44065 if (SWIG_arg_fail(3)) SWIG_fail;
44066 }
44067 }
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 (arg1)->LeftOf(arg2,arg3);
44071
44072 wxPyEndAllowThreads(__tstate);
44073 if (PyErr_Occurred()) SWIG_fail;
44074 }
44075 Py_INCREF(Py_None); resultobj = Py_None;
44076 return resultobj;
44077 fail:
44078 return NULL;
44079 }
44080
44081
44082 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44083 PyObject *resultobj;
44084 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44085 wxWindow *arg2 = (wxWindow *) 0 ;
44086 int arg3 = (int) 0 ;
44087 PyObject * obj0 = 0 ;
44088 PyObject * obj1 = 0 ;
44089 PyObject * obj2 = 0 ;
44090 char *kwnames[] = {
44091 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44092 };
44093
44094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44096 if (SWIG_arg_fail(1)) SWIG_fail;
44097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44098 if (SWIG_arg_fail(2)) SWIG_fail;
44099 if (obj2) {
44100 {
44101 arg3 = (int)(SWIG_As_int(obj2));
44102 if (SWIG_arg_fail(3)) SWIG_fail;
44103 }
44104 }
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 (arg1)->RightOf(arg2,arg3);
44108
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 Py_INCREF(Py_None); resultobj = Py_None;
44113 return resultobj;
44114 fail:
44115 return NULL;
44116 }
44117
44118
44119 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44120 PyObject *resultobj;
44121 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44122 wxWindow *arg2 = (wxWindow *) 0 ;
44123 int arg3 = (int) 0 ;
44124 PyObject * obj0 = 0 ;
44125 PyObject * obj1 = 0 ;
44126 PyObject * obj2 = 0 ;
44127 char *kwnames[] = {
44128 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44129 };
44130
44131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44133 if (SWIG_arg_fail(1)) SWIG_fail;
44134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44135 if (SWIG_arg_fail(2)) SWIG_fail;
44136 if (obj2) {
44137 {
44138 arg3 = (int)(SWIG_As_int(obj2));
44139 if (SWIG_arg_fail(3)) SWIG_fail;
44140 }
44141 }
44142 {
44143 PyThreadState* __tstate = wxPyBeginAllowThreads();
44144 (arg1)->Above(arg2,arg3);
44145
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 Py_INCREF(Py_None); resultobj = Py_None;
44150 return resultobj;
44151 fail:
44152 return NULL;
44153 }
44154
44155
44156 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44157 PyObject *resultobj;
44158 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44159 wxWindow *arg2 = (wxWindow *) 0 ;
44160 int arg3 = (int) 0 ;
44161 PyObject * obj0 = 0 ;
44162 PyObject * obj1 = 0 ;
44163 PyObject * obj2 = 0 ;
44164 char *kwnames[] = {
44165 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44166 };
44167
44168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44170 if (SWIG_arg_fail(1)) SWIG_fail;
44171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44172 if (SWIG_arg_fail(2)) SWIG_fail;
44173 if (obj2) {
44174 {
44175 arg3 = (int)(SWIG_As_int(obj2));
44176 if (SWIG_arg_fail(3)) SWIG_fail;
44177 }
44178 }
44179 {
44180 PyThreadState* __tstate = wxPyBeginAllowThreads();
44181 (arg1)->Below(arg2,arg3);
44182
44183 wxPyEndAllowThreads(__tstate);
44184 if (PyErr_Occurred()) SWIG_fail;
44185 }
44186 Py_INCREF(Py_None); resultobj = Py_None;
44187 return resultobj;
44188 fail:
44189 return NULL;
44190 }
44191
44192
44193 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44194 PyObject *resultobj;
44195 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44196 wxWindow *arg2 = (wxWindow *) 0 ;
44197 wxEdge arg3 ;
44198 int arg4 = (int) 0 ;
44199 PyObject * obj0 = 0 ;
44200 PyObject * obj1 = 0 ;
44201 PyObject * obj2 = 0 ;
44202 PyObject * obj3 = 0 ;
44203 char *kwnames[] = {
44204 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44205 };
44206
44207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44209 if (SWIG_arg_fail(1)) SWIG_fail;
44210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44211 if (SWIG_arg_fail(2)) SWIG_fail;
44212 {
44213 arg3 = (wxEdge)(SWIG_As_int(obj2));
44214 if (SWIG_arg_fail(3)) SWIG_fail;
44215 }
44216 if (obj3) {
44217 {
44218 arg4 = (int)(SWIG_As_int(obj3));
44219 if (SWIG_arg_fail(4)) SWIG_fail;
44220 }
44221 }
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44225
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 Py_INCREF(Py_None); resultobj = Py_None;
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44237 PyObject *resultobj;
44238 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44239 wxWindow *arg2 = (wxWindow *) 0 ;
44240 wxEdge arg3 ;
44241 int arg4 ;
44242 PyObject * obj0 = 0 ;
44243 PyObject * obj1 = 0 ;
44244 PyObject * obj2 = 0 ;
44245 PyObject * obj3 = 0 ;
44246 char *kwnames[] = {
44247 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44248 };
44249
44250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44252 if (SWIG_arg_fail(1)) SWIG_fail;
44253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44254 if (SWIG_arg_fail(2)) SWIG_fail;
44255 {
44256 arg3 = (wxEdge)(SWIG_As_int(obj2));
44257 if (SWIG_arg_fail(3)) SWIG_fail;
44258 }
44259 {
44260 arg4 = (int)(SWIG_As_int(obj3));
44261 if (SWIG_arg_fail(4)) SWIG_fail;
44262 }
44263 {
44264 PyThreadState* __tstate = wxPyBeginAllowThreads();
44265 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44266
44267 wxPyEndAllowThreads(__tstate);
44268 if (PyErr_Occurred()) SWIG_fail;
44269 }
44270 Py_INCREF(Py_None); resultobj = Py_None;
44271 return resultobj;
44272 fail:
44273 return NULL;
44274 }
44275
44276
44277 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44278 PyObject *resultobj;
44279 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44280 int arg2 ;
44281 PyObject * obj0 = 0 ;
44282 PyObject * obj1 = 0 ;
44283 char *kwnames[] = {
44284 (char *) "self",(char *) "val", NULL
44285 };
44286
44287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44289 if (SWIG_arg_fail(1)) SWIG_fail;
44290 {
44291 arg2 = (int)(SWIG_As_int(obj1));
44292 if (SWIG_arg_fail(2)) SWIG_fail;
44293 }
44294 {
44295 PyThreadState* __tstate = wxPyBeginAllowThreads();
44296 (arg1)->Absolute(arg2);
44297
44298 wxPyEndAllowThreads(__tstate);
44299 if (PyErr_Occurred()) SWIG_fail;
44300 }
44301 Py_INCREF(Py_None); resultobj = Py_None;
44302 return resultobj;
44303 fail:
44304 return NULL;
44305 }
44306
44307
44308 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44309 PyObject *resultobj;
44310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44311 PyObject * obj0 = 0 ;
44312 char *kwnames[] = {
44313 (char *) "self", NULL
44314 };
44315
44316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44318 if (SWIG_arg_fail(1)) SWIG_fail;
44319 {
44320 PyThreadState* __tstate = wxPyBeginAllowThreads();
44321 (arg1)->Unconstrained();
44322
44323 wxPyEndAllowThreads(__tstate);
44324 if (PyErr_Occurred()) SWIG_fail;
44325 }
44326 Py_INCREF(Py_None); resultobj = Py_None;
44327 return resultobj;
44328 fail:
44329 return NULL;
44330 }
44331
44332
44333 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44334 PyObject *resultobj;
44335 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44336 PyObject * obj0 = 0 ;
44337 char *kwnames[] = {
44338 (char *) "self", NULL
44339 };
44340
44341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44343 if (SWIG_arg_fail(1)) SWIG_fail;
44344 {
44345 PyThreadState* __tstate = wxPyBeginAllowThreads();
44346 (arg1)->AsIs();
44347
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 Py_INCREF(Py_None); resultobj = Py_None;
44352 return resultobj;
44353 fail:
44354 return NULL;
44355 }
44356
44357
44358 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44359 PyObject *resultobj;
44360 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44361 wxWindow *result;
44362 PyObject * obj0 = 0 ;
44363 char *kwnames[] = {
44364 (char *) "self", NULL
44365 };
44366
44367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44369 if (SWIG_arg_fail(1)) SWIG_fail;
44370 {
44371 PyThreadState* __tstate = wxPyBeginAllowThreads();
44372 result = (wxWindow *)(arg1)->GetOtherWindow();
44373
44374 wxPyEndAllowThreads(__tstate);
44375 if (PyErr_Occurred()) SWIG_fail;
44376 }
44377 {
44378 resultobj = wxPyMake_wxObject(result, 0);
44379 }
44380 return resultobj;
44381 fail:
44382 return NULL;
44383 }
44384
44385
44386 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44387 PyObject *resultobj;
44388 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44389 wxEdge result;
44390 PyObject * obj0 = 0 ;
44391 char *kwnames[] = {
44392 (char *) "self", NULL
44393 };
44394
44395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44397 if (SWIG_arg_fail(1)) SWIG_fail;
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44401
44402 wxPyEndAllowThreads(__tstate);
44403 if (PyErr_Occurred()) SWIG_fail;
44404 }
44405 resultobj = SWIG_From_int((result));
44406 return resultobj;
44407 fail:
44408 return NULL;
44409 }
44410
44411
44412 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44413 PyObject *resultobj;
44414 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44415 wxEdge arg2 ;
44416 PyObject * obj0 = 0 ;
44417 PyObject * obj1 = 0 ;
44418 char *kwnames[] = {
44419 (char *) "self",(char *) "which", NULL
44420 };
44421
44422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44424 if (SWIG_arg_fail(1)) SWIG_fail;
44425 {
44426 arg2 = (wxEdge)(SWIG_As_int(obj1));
44427 if (SWIG_arg_fail(2)) SWIG_fail;
44428 }
44429 {
44430 PyThreadState* __tstate = wxPyBeginAllowThreads();
44431 (arg1)->SetEdge((wxEdge )arg2);
44432
44433 wxPyEndAllowThreads(__tstate);
44434 if (PyErr_Occurred()) SWIG_fail;
44435 }
44436 Py_INCREF(Py_None); resultobj = Py_None;
44437 return resultobj;
44438 fail:
44439 return NULL;
44440 }
44441
44442
44443 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44444 PyObject *resultobj;
44445 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44446 int arg2 ;
44447 PyObject * obj0 = 0 ;
44448 PyObject * obj1 = 0 ;
44449 char *kwnames[] = {
44450 (char *) "self",(char *) "v", NULL
44451 };
44452
44453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44455 if (SWIG_arg_fail(1)) SWIG_fail;
44456 {
44457 arg2 = (int)(SWIG_As_int(obj1));
44458 if (SWIG_arg_fail(2)) SWIG_fail;
44459 }
44460 {
44461 PyThreadState* __tstate = wxPyBeginAllowThreads();
44462 (arg1)->SetValue(arg2);
44463
44464 wxPyEndAllowThreads(__tstate);
44465 if (PyErr_Occurred()) SWIG_fail;
44466 }
44467 Py_INCREF(Py_None); resultobj = Py_None;
44468 return resultobj;
44469 fail:
44470 return NULL;
44471 }
44472
44473
44474 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44475 PyObject *resultobj;
44476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44477 int result;
44478 PyObject * obj0 = 0 ;
44479 char *kwnames[] = {
44480 (char *) "self", NULL
44481 };
44482
44483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44485 if (SWIG_arg_fail(1)) SWIG_fail;
44486 {
44487 PyThreadState* __tstate = wxPyBeginAllowThreads();
44488 result = (int)(arg1)->GetMargin();
44489
44490 wxPyEndAllowThreads(__tstate);
44491 if (PyErr_Occurred()) SWIG_fail;
44492 }
44493 {
44494 resultobj = SWIG_From_int((int)(result));
44495 }
44496 return resultobj;
44497 fail:
44498 return NULL;
44499 }
44500
44501
44502 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44503 PyObject *resultobj;
44504 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44505 int arg2 ;
44506 PyObject * obj0 = 0 ;
44507 PyObject * obj1 = 0 ;
44508 char *kwnames[] = {
44509 (char *) "self",(char *) "m", NULL
44510 };
44511
44512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44514 if (SWIG_arg_fail(1)) SWIG_fail;
44515 {
44516 arg2 = (int)(SWIG_As_int(obj1));
44517 if (SWIG_arg_fail(2)) SWIG_fail;
44518 }
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 (arg1)->SetMargin(arg2);
44522
44523 wxPyEndAllowThreads(__tstate);
44524 if (PyErr_Occurred()) SWIG_fail;
44525 }
44526 Py_INCREF(Py_None); resultobj = Py_None;
44527 return resultobj;
44528 fail:
44529 return NULL;
44530 }
44531
44532
44533 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44534 PyObject *resultobj;
44535 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44536 int result;
44537 PyObject * obj0 = 0 ;
44538 char *kwnames[] = {
44539 (char *) "self", NULL
44540 };
44541
44542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44544 if (SWIG_arg_fail(1)) SWIG_fail;
44545 {
44546 PyThreadState* __tstate = wxPyBeginAllowThreads();
44547 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44548
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 {
44553 resultobj = SWIG_From_int((int)(result));
44554 }
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44562 PyObject *resultobj;
44563 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44564 int result;
44565 PyObject * obj0 = 0 ;
44566 char *kwnames[] = {
44567 (char *) "self", NULL
44568 };
44569
44570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44572 if (SWIG_arg_fail(1)) SWIG_fail;
44573 {
44574 PyThreadState* __tstate = wxPyBeginAllowThreads();
44575 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44576
44577 wxPyEndAllowThreads(__tstate);
44578 if (PyErr_Occurred()) SWIG_fail;
44579 }
44580 {
44581 resultobj = SWIG_From_int((int)(result));
44582 }
44583 return resultobj;
44584 fail:
44585 return NULL;
44586 }
44587
44588
44589 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44590 PyObject *resultobj;
44591 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44592 int result;
44593 PyObject * obj0 = 0 ;
44594 char *kwnames[] = {
44595 (char *) "self", NULL
44596 };
44597
44598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44600 if (SWIG_arg_fail(1)) SWIG_fail;
44601 {
44602 PyThreadState* __tstate = wxPyBeginAllowThreads();
44603 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44604
44605 wxPyEndAllowThreads(__tstate);
44606 if (PyErr_Occurred()) SWIG_fail;
44607 }
44608 {
44609 resultobj = SWIG_From_int((int)(result));
44610 }
44611 return resultobj;
44612 fail:
44613 return NULL;
44614 }
44615
44616
44617 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44618 PyObject *resultobj;
44619 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44620 bool result;
44621 PyObject * obj0 = 0 ;
44622 char *kwnames[] = {
44623 (char *) "self", NULL
44624 };
44625
44626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44628 if (SWIG_arg_fail(1)) SWIG_fail;
44629 {
44630 PyThreadState* __tstate = wxPyBeginAllowThreads();
44631 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44632
44633 wxPyEndAllowThreads(__tstate);
44634 if (PyErr_Occurred()) SWIG_fail;
44635 }
44636 {
44637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44638 }
44639 return resultobj;
44640 fail:
44641 return NULL;
44642 }
44643
44644
44645 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44646 PyObject *resultobj;
44647 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44648 bool arg2 ;
44649 PyObject * obj0 = 0 ;
44650 PyObject * obj1 = 0 ;
44651 char *kwnames[] = {
44652 (char *) "self",(char *) "d", NULL
44653 };
44654
44655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44657 if (SWIG_arg_fail(1)) SWIG_fail;
44658 {
44659 arg2 = (bool)(SWIG_As_bool(obj1));
44660 if (SWIG_arg_fail(2)) SWIG_fail;
44661 }
44662 {
44663 PyThreadState* __tstate = wxPyBeginAllowThreads();
44664 (arg1)->SetDone(arg2);
44665
44666 wxPyEndAllowThreads(__tstate);
44667 if (PyErr_Occurred()) SWIG_fail;
44668 }
44669 Py_INCREF(Py_None); resultobj = Py_None;
44670 return resultobj;
44671 fail:
44672 return NULL;
44673 }
44674
44675
44676 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44677 PyObject *resultobj;
44678 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44679 wxRelationship result;
44680 PyObject * obj0 = 0 ;
44681 char *kwnames[] = {
44682 (char *) "self", NULL
44683 };
44684
44685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44687 if (SWIG_arg_fail(1)) SWIG_fail;
44688 {
44689 PyThreadState* __tstate = wxPyBeginAllowThreads();
44690 result = (wxRelationship)(arg1)->GetRelationship();
44691
44692 wxPyEndAllowThreads(__tstate);
44693 if (PyErr_Occurred()) SWIG_fail;
44694 }
44695 resultobj = SWIG_From_int((result));
44696 return resultobj;
44697 fail:
44698 return NULL;
44699 }
44700
44701
44702 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44703 PyObject *resultobj;
44704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44705 wxRelationship arg2 ;
44706 PyObject * obj0 = 0 ;
44707 PyObject * obj1 = 0 ;
44708 char *kwnames[] = {
44709 (char *) "self",(char *) "r", NULL
44710 };
44711
44712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44714 if (SWIG_arg_fail(1)) SWIG_fail;
44715 {
44716 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44717 if (SWIG_arg_fail(2)) SWIG_fail;
44718 }
44719 {
44720 PyThreadState* __tstate = wxPyBeginAllowThreads();
44721 (arg1)->SetRelationship((wxRelationship )arg2);
44722
44723 wxPyEndAllowThreads(__tstate);
44724 if (PyErr_Occurred()) SWIG_fail;
44725 }
44726 Py_INCREF(Py_None); resultobj = Py_None;
44727 return resultobj;
44728 fail:
44729 return NULL;
44730 }
44731
44732
44733 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44734 PyObject *resultobj;
44735 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44736 wxWindow *arg2 = (wxWindow *) 0 ;
44737 bool result;
44738 PyObject * obj0 = 0 ;
44739 PyObject * obj1 = 0 ;
44740 char *kwnames[] = {
44741 (char *) "self",(char *) "otherW", NULL
44742 };
44743
44744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44746 if (SWIG_arg_fail(1)) SWIG_fail;
44747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44748 if (SWIG_arg_fail(2)) SWIG_fail;
44749 {
44750 PyThreadState* __tstate = wxPyBeginAllowThreads();
44751 result = (bool)(arg1)->ResetIfWin(arg2);
44752
44753 wxPyEndAllowThreads(__tstate);
44754 if (PyErr_Occurred()) SWIG_fail;
44755 }
44756 {
44757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44758 }
44759 return resultobj;
44760 fail:
44761 return NULL;
44762 }
44763
44764
44765 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44766 PyObject *resultobj;
44767 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44768 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44769 wxWindow *arg3 = (wxWindow *) 0 ;
44770 bool result;
44771 PyObject * obj0 = 0 ;
44772 PyObject * obj1 = 0 ;
44773 PyObject * obj2 = 0 ;
44774 char *kwnames[] = {
44775 (char *) "self",(char *) "constraints",(char *) "win", NULL
44776 };
44777
44778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44780 if (SWIG_arg_fail(1)) SWIG_fail;
44781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44782 if (SWIG_arg_fail(2)) SWIG_fail;
44783 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44784 if (SWIG_arg_fail(3)) SWIG_fail;
44785 {
44786 PyThreadState* __tstate = wxPyBeginAllowThreads();
44787 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44788
44789 wxPyEndAllowThreads(__tstate);
44790 if (PyErr_Occurred()) SWIG_fail;
44791 }
44792 {
44793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44794 }
44795 return resultobj;
44796 fail:
44797 return NULL;
44798 }
44799
44800
44801 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44802 PyObject *resultobj;
44803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44804 wxEdge arg2 ;
44805 wxWindow *arg3 = (wxWindow *) 0 ;
44806 wxWindow *arg4 = (wxWindow *) 0 ;
44807 int result;
44808 PyObject * obj0 = 0 ;
44809 PyObject * obj1 = 0 ;
44810 PyObject * obj2 = 0 ;
44811 PyObject * obj3 = 0 ;
44812 char *kwnames[] = {
44813 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44814 };
44815
44816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44818 if (SWIG_arg_fail(1)) SWIG_fail;
44819 {
44820 arg2 = (wxEdge)(SWIG_As_int(obj1));
44821 if (SWIG_arg_fail(2)) SWIG_fail;
44822 }
44823 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44824 if (SWIG_arg_fail(3)) SWIG_fail;
44825 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44826 if (SWIG_arg_fail(4)) SWIG_fail;
44827 {
44828 PyThreadState* __tstate = wxPyBeginAllowThreads();
44829 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44830
44831 wxPyEndAllowThreads(__tstate);
44832 if (PyErr_Occurred()) SWIG_fail;
44833 }
44834 {
44835 resultobj = SWIG_From_int((int)(result));
44836 }
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44844 PyObject *obj;
44845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44846 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44847 Py_INCREF(obj);
44848 return Py_BuildValue((char *)"");
44849 }
44850 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44851 PyObject *resultobj;
44852 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44853 wxIndividualLayoutConstraint *result;
44854 PyObject * obj0 = 0 ;
44855 char *kwnames[] = {
44856 (char *) "self", NULL
44857 };
44858
44859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44861 if (SWIG_arg_fail(1)) SWIG_fail;
44862 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44863
44864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44865 return resultobj;
44866 fail:
44867 return NULL;
44868 }
44869
44870
44871 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44872 PyObject *resultobj;
44873 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44874 wxIndividualLayoutConstraint *result;
44875 PyObject * obj0 = 0 ;
44876 char *kwnames[] = {
44877 (char *) "self", NULL
44878 };
44879
44880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44882 if (SWIG_arg_fail(1)) SWIG_fail;
44883 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44884
44885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44886 return resultobj;
44887 fail:
44888 return NULL;
44889 }
44890
44891
44892 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44893 PyObject *resultobj;
44894 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44895 wxIndividualLayoutConstraint *result;
44896 PyObject * obj0 = 0 ;
44897 char *kwnames[] = {
44898 (char *) "self", NULL
44899 };
44900
44901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44903 if (SWIG_arg_fail(1)) SWIG_fail;
44904 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44905
44906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44907 return resultobj;
44908 fail:
44909 return NULL;
44910 }
44911
44912
44913 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44914 PyObject *resultobj;
44915 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44916 wxIndividualLayoutConstraint *result;
44917 PyObject * obj0 = 0 ;
44918 char *kwnames[] = {
44919 (char *) "self", NULL
44920 };
44921
44922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44924 if (SWIG_arg_fail(1)) SWIG_fail;
44925 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44926
44927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44928 return resultobj;
44929 fail:
44930 return NULL;
44931 }
44932
44933
44934 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44935 PyObject *resultobj;
44936 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44937 wxIndividualLayoutConstraint *result;
44938 PyObject * obj0 = 0 ;
44939 char *kwnames[] = {
44940 (char *) "self", NULL
44941 };
44942
44943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44945 if (SWIG_arg_fail(1)) SWIG_fail;
44946 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44947
44948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44949 return resultobj;
44950 fail:
44951 return NULL;
44952 }
44953
44954
44955 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44956 PyObject *resultobj;
44957 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44958 wxIndividualLayoutConstraint *result;
44959 PyObject * obj0 = 0 ;
44960 char *kwnames[] = {
44961 (char *) "self", NULL
44962 };
44963
44964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44966 if (SWIG_arg_fail(1)) SWIG_fail;
44967 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44968
44969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44970 return resultobj;
44971 fail:
44972 return NULL;
44973 }
44974
44975
44976 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44977 PyObject *resultobj;
44978 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44979 wxIndividualLayoutConstraint *result;
44980 PyObject * obj0 = 0 ;
44981 char *kwnames[] = {
44982 (char *) "self", NULL
44983 };
44984
44985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44987 if (SWIG_arg_fail(1)) SWIG_fail;
44988 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44989
44990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44991 return resultobj;
44992 fail:
44993 return NULL;
44994 }
44995
44996
44997 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44998 PyObject *resultobj;
44999 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45000 wxIndividualLayoutConstraint *result;
45001 PyObject * obj0 = 0 ;
45002 char *kwnames[] = {
45003 (char *) "self", NULL
45004 };
45005
45006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45008 if (SWIG_arg_fail(1)) SWIG_fail;
45009 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45010
45011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45012 return resultobj;
45013 fail:
45014 return NULL;
45015 }
45016
45017
45018 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45019 PyObject *resultobj;
45020 wxLayoutConstraints *result;
45021 char *kwnames[] = {
45022 NULL
45023 };
45024
45025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45026 {
45027 PyThreadState* __tstate = wxPyBeginAllowThreads();
45028 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45029
45030 wxPyEndAllowThreads(__tstate);
45031 if (PyErr_Occurred()) SWIG_fail;
45032 }
45033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45034 return resultobj;
45035 fail:
45036 return NULL;
45037 }
45038
45039
45040 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45041 PyObject *resultobj;
45042 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45043 wxWindow *arg2 = (wxWindow *) 0 ;
45044 int *arg3 = (int *) 0 ;
45045 bool result;
45046 int temp3 ;
45047 int res3 = 0 ;
45048 PyObject * obj0 = 0 ;
45049 PyObject * obj1 = 0 ;
45050 char *kwnames[] = {
45051 (char *) "self",(char *) "win", NULL
45052 };
45053
45054 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45057 if (SWIG_arg_fail(1)) SWIG_fail;
45058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45059 if (SWIG_arg_fail(2)) SWIG_fail;
45060 {
45061 PyThreadState* __tstate = wxPyBeginAllowThreads();
45062 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45063
45064 wxPyEndAllowThreads(__tstate);
45065 if (PyErr_Occurred()) SWIG_fail;
45066 }
45067 {
45068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45069 }
45070 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45071 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45072 return resultobj;
45073 fail:
45074 return NULL;
45075 }
45076
45077
45078 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45079 PyObject *resultobj;
45080 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45081 bool result;
45082 PyObject * obj0 = 0 ;
45083 char *kwnames[] = {
45084 (char *) "self", NULL
45085 };
45086
45087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45089 if (SWIG_arg_fail(1)) SWIG_fail;
45090 {
45091 PyThreadState* __tstate = wxPyBeginAllowThreads();
45092 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45093
45094 wxPyEndAllowThreads(__tstate);
45095 if (PyErr_Occurred()) SWIG_fail;
45096 }
45097 {
45098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45099 }
45100 return resultobj;
45101 fail:
45102 return NULL;
45103 }
45104
45105
45106 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45107 PyObject *obj;
45108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45109 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45110 Py_INCREF(obj);
45111 return Py_BuildValue((char *)"");
45112 }
45113 static PyMethodDef SwigMethods[] = {
45114 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45115 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45116 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45119 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45140 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45153 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45168 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45222 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45250 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45269 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45271 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45279 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45280 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45292 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45304 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45308 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45314 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45324 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45334 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45338 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45417 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45419 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45421 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45423 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45425 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45427 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45429 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45431 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45433 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45435 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45437 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45439 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45441 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45455 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45473 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45476 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45479 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45491 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45496 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45502 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45508 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45571 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45578 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45614 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45624 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45630 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45632 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45634 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45637 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45641 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45647 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45649 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45662 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45666 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45669 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45671 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45675 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45692 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45694 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45697 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45699 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45703 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45707 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45718 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45721 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45724 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45728 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45735 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45740 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45745 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45749 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45794 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45814 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45821 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45825 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45835 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46007 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46049 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46063 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46066 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46121 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46148 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46192 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46200 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46219 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46220 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46257 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46287 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46290 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46294 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46297 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46307 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46319 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46331 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46341 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46351 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46365 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46372 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46373 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46374 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46375 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46376 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46381 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46408 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46420 { NULL, NULL, 0, NULL }
46421 };
46422
46423
46424 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46425
46426 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46427 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46428 }
46429 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46430 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46431 }
46432 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46433 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46434 }
46435 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46436 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46437 }
46438 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46439 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46440 }
46441 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46442 return (void *)((wxSizer *) ((wxGridSizer *) x));
46443 }
46444 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46445 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46446 }
46447 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46448 return (void *)((wxSizer *) ((wxPySizer *) x));
46449 }
46450 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46451 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46452 }
46453 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46454 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46455 }
46456 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46457 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46458 }
46459 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46460 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46461 }
46462 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46463 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46464 }
46465 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46466 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46467 }
46468 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46469 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46470 }
46471 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46472 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46473 }
46474 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46475 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46476 }
46477 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46478 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46479 }
46480 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46481 return (void *)((wxEvent *) ((wxPyEvent *) x));
46482 }
46483 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46484 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46485 }
46486 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46487 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46488 }
46489 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46490 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46491 }
46492 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46493 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46494 }
46495 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46496 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46497 }
46498 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46499 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46500 }
46501 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46502 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46503 }
46504 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46505 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46506 }
46507 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46508 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46509 }
46510 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46511 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46512 }
46513 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46514 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46515 }
46516 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46517 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46518 }
46519 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46520 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46521 }
46522 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46523 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46524 }
46525 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46526 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46527 }
46528 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46529 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46530 }
46531 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46532 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46533 }
46534 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46535 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46536 }
46537 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46538 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46539 }
46540 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46541 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46542 }
46543 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46544 return (void *)((wxEvent *) ((wxShowEvent *) x));
46545 }
46546 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46547 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46548 }
46549 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46550 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46551 }
46552 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46553 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46554 }
46555 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46556 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46557 }
46558 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46559 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46560 }
46561 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46562 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46563 }
46564 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46565 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46566 }
46567 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46568 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46569 }
46570 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46571 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46572 }
46573 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46574 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46575 }
46576 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46577 return (void *)((wxControl *) ((wxControlWithItems *) x));
46578 }
46579 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46580 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46581 }
46582 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46583 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46584 }
46585 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46586 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46587 }
46588 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46589 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46590 }
46591 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46592 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46593 }
46594 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46595 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46596 }
46597 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46598 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46599 }
46600 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46601 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46602 }
46603 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46604 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46605 }
46606 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46607 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46608 }
46609 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46610 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46611 }
46612 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46613 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46614 }
46615 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46616 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46617 }
46618 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46619 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46620 }
46621 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46622 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46623 }
46624 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46625 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46626 }
46627 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46628 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46629 }
46630 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46631 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46632 }
46633 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46634 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46635 }
46636 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46637 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46638 }
46639 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46640 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46641 }
46642 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46643 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46644 }
46645 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46646 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46647 }
46648 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46649 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46650 }
46651 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46652 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46653 }
46654 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46655 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46656 }
46657 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46658 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46659 }
46660 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46661 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46662 }
46663 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46664 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46665 }
46666 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46667 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46668 }
46669 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46670 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46671 }
46672 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46673 return (void *)((wxObject *) ((wxSizerItem *) x));
46674 }
46675 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46676 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46677 }
46678 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46679 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46680 }
46681 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46682 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46683 }
46684 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46685 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46686 }
46687 static void *_p_wxSizerTo_p_wxObject(void *x) {
46688 return (void *)((wxObject *) ((wxSizer *) x));
46689 }
46690 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46691 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46692 }
46693 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46694 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46695 }
46696 static void *_p_wxEventTo_p_wxObject(void *x) {
46697 return (void *)((wxObject *) ((wxEvent *) x));
46698 }
46699 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46700 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46701 }
46702 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46703 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46704 }
46705 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46706 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46707 }
46708 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46709 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46710 }
46711 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46712 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46713 }
46714 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46715 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46716 }
46717 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46718 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46719 }
46720 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46721 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46722 }
46723 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46724 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46725 }
46726 static void *_p_wxControlTo_p_wxObject(void *x) {
46727 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46728 }
46729 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46730 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46731 }
46732 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46733 return (void *)((wxObject *) ((wxFSFile *) x));
46734 }
46735 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46736 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46737 }
46738 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46739 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46740 }
46741 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46742 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46743 }
46744 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46745 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46746 }
46747 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46748 return (void *)((wxObject *) ((wxMenuItem *) x));
46749 }
46750 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46751 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46752 }
46753 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46754 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46755 }
46756 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46757 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46758 }
46759 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46760 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46761 }
46762 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46763 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46764 }
46765 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46766 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46767 }
46768 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46769 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46770 }
46771 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46772 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46773 }
46774 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46775 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46776 }
46777 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46778 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46779 }
46780 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46781 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46782 }
46783 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46784 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46785 }
46786 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46787 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46788 }
46789 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46790 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46791 }
46792 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46793 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46794 }
46795 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46796 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46797 }
46798 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46799 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46800 }
46801 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46802 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46803 }
46804 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46805 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46806 }
46807 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46808 return (void *)((wxObject *) ((wxImageHandler *) x));
46809 }
46810 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46811 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46812 }
46813 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46814 return (void *)((wxObject *) ((wxEvtHandler *) x));
46815 }
46816 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46817 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46818 }
46819 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46820 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46821 }
46822 static void *_p_wxImageTo_p_wxObject(void *x) {
46823 return (void *)((wxObject *) ((wxImage *) x));
46824 }
46825 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46826 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46827 }
46828 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46829 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46830 }
46831 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46832 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46833 }
46834 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46835 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46836 }
46837 static void *_p_wxWindowTo_p_wxObject(void *x) {
46838 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46839 }
46840 static void *_p_wxMenuTo_p_wxObject(void *x) {
46841 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46842 }
46843 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46844 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46845 }
46846 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46847 return (void *)((wxObject *) ((wxFileSystem *) x));
46848 }
46849 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46850 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46851 }
46852 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46853 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46854 }
46855 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46856 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46857 }
46858 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46859 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46860 }
46861 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46862 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46863 }
46864 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46865 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46866 }
46867 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46868 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46869 }
46870 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46871 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46872 }
46873 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46874 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46875 }
46876 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46877 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46878 }
46879 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46880 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46881 }
46882 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46883 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46884 }
46885 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46886 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46887 }
46888 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46889 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46890 }
46891 static void *_p_wxControlTo_p_wxWindow(void *x) {
46892 return (void *)((wxWindow *) ((wxControl *) x));
46893 }
46894 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46895 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46896 }
46897 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46898 return (void *)((wxWindow *) ((wxMenuBar *) x));
46899 }
46900 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46901 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46902 }
46903 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46904 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46905 }
46906 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46907 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46908 }
46909 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46910 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46911 }
46912 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46913 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46914 }
46915 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46916 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46917 }
46918 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46919 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46920 }
46921 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46922 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46923 }
46924 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46925 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46926 }
46927 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46928 return (void *)((wxValidator *) ((wxPyValidator *) x));
46929 }
46930 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}};
46931 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}};
46932 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}};
46933 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}};
46934 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}};
46935 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}};
46936 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}};
46937 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}};
46938 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}};
46939 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}};
46940 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}};
46941 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}};
46942 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}};
46943 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}};
46944 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}};
46945 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}};
46946 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}};
46947 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}};
46948 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}};
46949 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}};
46950 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}};
46951 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}};
46952 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}};
46953 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}};
46954 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}};
46955 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}};
46956 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}};
46957 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}};
46958 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}};
46959 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}};
46960 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}};
46961 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}};
46962 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}};
46963 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}};
46964 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}};
46965 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}};
46966 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}};
46967 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}};
46968 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}};
46969 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}};
46970 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}};
46971 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}};
46972 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}};
46973 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}};
46974 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}};
46975 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}};
46976 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}};
46977 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}};
46978 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}};
46979 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}};
46980 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}};
46981 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}};
46982 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}};
46983 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}};
46984 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}};
46985 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}};
46986 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}};
46987 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}};
46988 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}};
46989 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}};
46990 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}};
46991 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}};
46992 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}};
46993 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}};
46994 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}};
46995 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}};
46996 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}};
46997 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}};
46998 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}};
46999 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}};
47000 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}};
47001 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}};
47002 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}};
47003 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}};
47004 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}};
47005 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}};
47006 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}};
47007 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}};
47008 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}};
47009 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}};
47010 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}};
47011 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}};
47012 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}};
47013 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}};
47014 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}};
47015 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}};
47016 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}};
47017 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}};
47018 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}};
47019 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}};
47020 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}};
47021 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}};
47022 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}};
47023 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}};
47024 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}};
47025 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}};
47026 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}};
47027 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}};
47028 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}};
47029 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}};
47030 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}};
47031 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}};
47032 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}};
47033 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}};
47034 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}};
47035 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}};
47036 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}};
47037 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}};
47038 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}};
47039 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}};
47040 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}};
47041 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}};
47042 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}};
47043 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}};
47044 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}};
47045 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}};
47046 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}};
47047 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}};
47048 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}};
47049 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}};
47050 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}};
47051 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}};
47052 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}};
47053 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}};
47054 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}};
47055 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}};
47056 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}};
47057
47058 static swig_type_info *swig_types_initial[] = {
47059 _swigt__p_wxLayoutConstraints,
47060 _swigt__p_wxRealPoint,
47061 _swigt__p_wxSizerItem,
47062 _swigt__p_wxGBSizerItem,
47063 _swigt__p_wxScrollEvent,
47064 _swigt__p_wxEventLoop,
47065 _swigt__p_wxIndividualLayoutConstraint,
47066 _swigt__p_wxSizer,
47067 _swigt__p_wxBoxSizer,
47068 _swigt__p_wxStaticBoxSizer,
47069 _swigt__p_wxGridBagSizer,
47070 _swigt__p_wxAcceleratorEntry,
47071 _swigt__p_wxUpdateUIEvent,
47072 _swigt__p_wxEvent,
47073 _swigt__p_wxMenu,
47074 _swigt__p_wxGridSizer,
47075 _swigt__p_wxFlexGridSizer,
47076 _swigt__p_wxInitDialogEvent,
47077 _swigt__p_wxItemContainer,
47078 _swigt__p_wxNcPaintEvent,
47079 _swigt__p_wxPaintEvent,
47080 _swigt__p_wxSysColourChangedEvent,
47081 _swigt__p_wxMouseCaptureChangedEvent,
47082 _swigt__p_wxDisplayChangedEvent,
47083 _swigt__p_wxPaletteChangedEvent,
47084 _swigt__p_wxControl,
47085 _swigt__p_wxFont,
47086 _swigt__p_wxMenuBarBase,
47087 _swigt__p_wxSetCursorEvent,
47088 _swigt__p_wxFSFile,
47089 _swigt__p_wxCaret,
47090 _swigt__ptrdiff_t,
47091 _swigt__std__ptrdiff_t,
47092 _swigt__p_wxRegion,
47093 _swigt__p_wxPoint2D,
47094 _swigt__p_int,
47095 _swigt__p_wxSize,
47096 _swigt__p_wxDC,
47097 _swigt__p_wxPySizer,
47098 _swigt__p_wxVisualAttributes,
47099 _swigt__p_wxNotifyEvent,
47100 _swigt__p_wxPyEvent,
47101 _swigt__p_wxPropagationDisabler,
47102 _swigt__p_form_ops_t,
47103 _swigt__p_wxAppTraits,
47104 _swigt__p_wxArrayString,
47105 _swigt__p_wxShowEvent,
47106 _swigt__p_wxToolTip,
47107 _swigt__p_wxMoveEvent,
47108 _swigt__p_wxSizeEvent,
47109 _swigt__p_wxActivateEvent,
47110 _swigt__p_wxIconizeEvent,
47111 _swigt__p_wxMaximizeEvent,
47112 _swigt__p_wxQueryNewPaletteEvent,
47113 _swigt__p_wxWindowCreateEvent,
47114 _swigt__p_wxIdleEvent,
47115 _swigt__p_wxDateEvent,
47116 _swigt__p_wxMenuItem,
47117 _swigt__p_wxStaticBox,
47118 _swigt__p_long,
47119 _swigt__p_wxDuplexMode,
47120 _swigt__p_wxTIFFHandler,
47121 _swigt__p_wxXPMHandler,
47122 _swigt__p_wxPNMHandler,
47123 _swigt__p_wxJPEGHandler,
47124 _swigt__p_wxPCXHandler,
47125 _swigt__p_wxGIFHandler,
47126 _swigt__p_wxPNGHandler,
47127 _swigt__p_wxANIHandler,
47128 _swigt__p_wxMemoryFSHandler,
47129 _swigt__p_wxZipFSHandler,
47130 _swigt__p_wxInternetFSHandler,
47131 _swigt__p_wxPyFileSystemHandler,
47132 _swigt__p_wxEvtHandler,
47133 _swigt__p_wxCURHandler,
47134 _swigt__p_wxICOHandler,
47135 _swigt__p_wxBMPHandler,
47136 _swigt__p_wxImageHandler,
47137 _swigt__p_wxFileSystemHandler,
47138 _swigt__p_wxRect,
47139 _swigt__p_wxButton,
47140 _swigt__p_wxGBSpan,
47141 _swigt__p_wxPropagateOnce,
47142 _swigt__p_wxAcceleratorTable,
47143 _swigt__p_wxStdDialogButtonSizer,
47144 _swigt__p_char,
47145 _swigt__p_wxGBPosition,
47146 _swigt__p_wxImage,
47147 _swigt__p_wxFrame,
47148 _swigt__p_wxScrollWinEvent,
47149 _swigt__p_wxPaperSize,
47150 _swigt__p_wxImageHistogram,
47151 _swigt__p_wxPoint,
47152 _swigt__p_wxCursor,
47153 _swigt__p_wxObject,
47154 _swigt__p_wxInputStream,
47155 _swigt__p_wxOutputStream,
47156 _swigt__p_wxPyInputStream,
47157 _swigt__p_wxDateTime,
47158 _swigt__p_wxKeyEvent,
47159 _swigt__p_wxNavigationKeyEvent,
47160 _swigt__p_wxWindowDestroyEvent,
47161 _swigt__p_unsigned_long,
47162 _swigt__p_wxWindow,
47163 _swigt__p_wxMenuBar,
47164 _swigt__p_wxFileSystem,
47165 _swigt__p_wxBitmap,
47166 _swigt__unsigned_int,
47167 _swigt__p_unsigned_int,
47168 _swigt__p_wxMenuEvent,
47169 _swigt__p_wxContextMenuEvent,
47170 _swigt__p_unsigned_char,
47171 _swigt__p_wxEraseEvent,
47172 _swigt__p_wxMouseEvent,
47173 _swigt__p_wxCloseEvent,
47174 _swigt__p_wxPyApp,
47175 _swigt__p_wxCommandEvent,
47176 _swigt__p_wxPyCommandEvent,
47177 _swigt__p_wxPyDropTarget,
47178 _swigt__p_wxQuantize,
47179 _swigt__p_wxChildFocusEvent,
47180 _swigt__p_wxFocusEvent,
47181 _swigt__p_wxDropFilesEvent,
47182 _swigt__p_wxControlWithItems,
47183 _swigt__p_wxColour,
47184 _swigt__p_wxValidator,
47185 _swigt__p_wxPyValidator,
47186 0
47187 };
47188
47189
47190 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47191
47192 static swig_const_info swig_const_table[] = {
47193 {0, 0, 0, 0.0, 0, 0}};
47194
47195 #ifdef __cplusplus
47196 }
47197 #endif
47198
47199
47200 #ifdef __cplusplus
47201 extern "C" {
47202 #endif
47203
47204 /* Python-specific SWIG API */
47205 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47206 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47207 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47208
47209 /* -----------------------------------------------------------------------------
47210 * global variable support code.
47211 * ----------------------------------------------------------------------------- */
47212
47213 typedef struct swig_globalvar {
47214 char *name; /* Name of global variable */
47215 PyObject *(*get_attr)(); /* Return the current value */
47216 int (*set_attr)(PyObject *); /* Set the value */
47217 struct swig_globalvar *next;
47218 } swig_globalvar;
47219
47220 typedef struct swig_varlinkobject {
47221 PyObject_HEAD
47222 swig_globalvar *vars;
47223 } swig_varlinkobject;
47224
47225 static PyObject *
47226 swig_varlink_repr(swig_varlinkobject *v) {
47227 v = v;
47228 return PyString_FromString("<Swig global variables>");
47229 }
47230
47231 static int
47232 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47233 swig_globalvar *var;
47234 flags = flags;
47235 fprintf(fp,"Swig global variables { ");
47236 for (var = v->vars; var; var=var->next) {
47237 fprintf(fp,"%s", var->name);
47238 if (var->next) fprintf(fp,", ");
47239 }
47240 fprintf(fp," }\n");
47241 return 0;
47242 }
47243
47244 static PyObject *
47245 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47246 swig_globalvar *var = v->vars;
47247 while (var) {
47248 if (strcmp(var->name,n) == 0) {
47249 return (*var->get_attr)();
47250 }
47251 var = var->next;
47252 }
47253 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47254 return NULL;
47255 }
47256
47257 static int
47258 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47259 swig_globalvar *var = v->vars;
47260 while (var) {
47261 if (strcmp(var->name,n) == 0) {
47262 return (*var->set_attr)(p);
47263 }
47264 var = var->next;
47265 }
47266 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47267 return 1;
47268 }
47269
47270 static PyTypeObject varlinktype = {
47271 PyObject_HEAD_INIT(0)
47272 0, /* Number of items in variable part (ob_size) */
47273 (char *)"swigvarlink", /* Type name (tp_name) */
47274 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47275 0, /* Itemsize (tp_itemsize) */
47276 0, /* Deallocator (tp_dealloc) */
47277 (printfunc) swig_varlink_print, /* Print (tp_print) */
47278 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47279 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47280 0, /* tp_compare */
47281 (reprfunc) swig_varlink_repr, /* tp_repr */
47282 0, /* tp_as_number */
47283 0, /* tp_as_sequence */
47284 0, /* tp_as_mapping */
47285 0, /* tp_hash */
47286 0, /* tp_call */
47287 0, /* tp_str */
47288 0, /* tp_getattro */
47289 0, /* tp_setattro */
47290 0, /* tp_as_buffer */
47291 0, /* tp_flags */
47292 0, /* tp_doc */
47293 #if PY_VERSION_HEX >= 0x02000000
47294 0, /* tp_traverse */
47295 0, /* tp_clear */
47296 #endif
47297 #if PY_VERSION_HEX >= 0x02010000
47298 0, /* tp_richcompare */
47299 0, /* tp_weaklistoffset */
47300 #endif
47301 #if PY_VERSION_HEX >= 0x02020000
47302 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47303 #endif
47304 #if PY_VERSION_HEX >= 0x02030000
47305 0, /* tp_del */
47306 #endif
47307 #ifdef COUNT_ALLOCS
47308 0,0,0,0 /* tp_alloc -> tp_next */
47309 #endif
47310 };
47311
47312 /* Create a variable linking object for use later */
47313 static PyObject *
47314 SWIG_Python_newvarlink(void) {
47315 swig_varlinkobject *result = 0;
47316 result = PyMem_NEW(swig_varlinkobject,1);
47317 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47318 result->ob_type = &varlinktype;
47319 result->vars = 0;
47320 result->ob_refcnt = 0;
47321 Py_XINCREF((PyObject *) result);
47322 return ((PyObject*) result);
47323 }
47324
47325 static void
47326 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47327 swig_varlinkobject *v;
47328 swig_globalvar *gv;
47329 v= (swig_varlinkobject *) p;
47330 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47331 gv->name = (char *) malloc(strlen(name)+1);
47332 strcpy(gv->name,name);
47333 gv->get_attr = get_attr;
47334 gv->set_attr = set_attr;
47335 gv->next = v->vars;
47336 v->vars = gv;
47337 }
47338
47339 /* -----------------------------------------------------------------------------
47340 * constants/methods manipulation
47341 * ----------------------------------------------------------------------------- */
47342
47343 /* Install Constants */
47344 static void
47345 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47346 PyObject *obj = 0;
47347 size_t i;
47348 for (i = 0; constants[i].type; i++) {
47349 switch(constants[i].type) {
47350 case SWIG_PY_INT:
47351 obj = PyInt_FromLong(constants[i].lvalue);
47352 break;
47353 case SWIG_PY_FLOAT:
47354 obj = PyFloat_FromDouble(constants[i].dvalue);
47355 break;
47356 case SWIG_PY_STRING:
47357 if (constants[i].pvalue) {
47358 obj = PyString_FromString((char *) constants[i].pvalue);
47359 } else {
47360 Py_INCREF(Py_None);
47361 obj = Py_None;
47362 }
47363 break;
47364 case SWIG_PY_POINTER:
47365 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47366 break;
47367 case SWIG_PY_BINARY:
47368 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47369 break;
47370 default:
47371 obj = 0;
47372 break;
47373 }
47374 if (obj) {
47375 PyDict_SetItemString(d,constants[i].name,obj);
47376 Py_DECREF(obj);
47377 }
47378 }
47379 }
47380
47381 /* -----------------------------------------------------------------------------*/
47382 /* Fix SwigMethods to carry the callback ptrs when needed */
47383 /* -----------------------------------------------------------------------------*/
47384
47385 static void
47386 SWIG_Python_FixMethods(PyMethodDef *methods,
47387 swig_const_info *const_table,
47388 swig_type_info **types,
47389 swig_type_info **types_initial) {
47390 size_t i;
47391 for (i = 0; methods[i].ml_name; ++i) {
47392 char *c = methods[i].ml_doc;
47393 if (c && (c = strstr(c, "swig_ptr: "))) {
47394 int j;
47395 swig_const_info *ci = 0;
47396 char *name = c + 10;
47397 for (j = 0; const_table[j].type; j++) {
47398 if (strncmp(const_table[j].name, name,
47399 strlen(const_table[j].name)) == 0) {
47400 ci = &(const_table[j]);
47401 break;
47402 }
47403 }
47404 if (ci) {
47405 size_t shift = (ci->ptype) - types;
47406 swig_type_info *ty = types_initial[shift];
47407 size_t ldoc = (c - methods[i].ml_doc);
47408 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47409 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47410 char *buff = ndoc;
47411 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47412 strncpy(buff, methods[i].ml_doc, ldoc);
47413 buff += ldoc;
47414 strncpy(buff, "swig_ptr: ", 10);
47415 buff += 10;
47416 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47417 methods[i].ml_doc = ndoc;
47418 }
47419 }
47420 }
47421 }
47422
47423 /* -----------------------------------------------------------------------------*
47424 * Initialize type list
47425 * -----------------------------------------------------------------------------*/
47426
47427 #if PY_MAJOR_VERSION < 2
47428 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47429 is copied out of Python/modsupport.c in python version 2.3.4 */
47430 static int
47431 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47432 {
47433 PyObject *dict;
47434 if (!PyModule_Check(m)) {
47435 PyErr_SetString(PyExc_TypeError,
47436 "PyModule_AddObject() needs module as first arg");
47437 return -1;
47438 }
47439 if (!o) {
47440 PyErr_SetString(PyExc_TypeError,
47441 "PyModule_AddObject() needs non-NULL value");
47442 return -1;
47443 }
47444
47445 dict = PyModule_GetDict(m);
47446 if (dict == NULL) {
47447 /* Internal error -- modules must have a dict! */
47448 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47449 PyModule_GetName(m));
47450 return -1;
47451 }
47452 if (PyDict_SetItemString(dict, name, o))
47453 return -1;
47454 Py_DECREF(o);
47455 return 0;
47456 }
47457 #endif
47458
47459 static swig_type_info **
47460 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47461 static PyMethodDef swig_empty_runtime_method_table[] = {
47462 {
47463 NULL, NULL, 0, NULL
47464 }
47465 };/* Sentinel */
47466
47467 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47468 swig_empty_runtime_method_table);
47469 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47470 if (pointer && module) {
47471 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47472 }
47473 return type_list_handle;
47474 }
47475
47476 static swig_type_info **
47477 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47478 swig_type_info **type_pointer;
47479
47480 /* first check if module already created */
47481 type_pointer = SWIG_Python_GetTypeListHandle();
47482 if (type_pointer) {
47483 return type_pointer;
47484 } else {
47485 /* create a new module and variable */
47486 return SWIG_Python_SetTypeListHandle(type_list_handle);
47487 }
47488 }
47489
47490 #ifdef __cplusplus
47491 }
47492 #endif
47493
47494 /* -----------------------------------------------------------------------------*
47495 * Partial Init method
47496 * -----------------------------------------------------------------------------*/
47497
47498 #ifdef SWIG_LINK_RUNTIME
47499 #ifdef __cplusplus
47500 extern "C"
47501 #endif
47502 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47503 #endif
47504
47505 #ifdef __cplusplus
47506 extern "C"
47507 #endif
47508 SWIGEXPORT(void) SWIG_init(void) {
47509 static PyObject *SWIG_globals = 0;
47510 static int typeinit = 0;
47511 PyObject *m, *d;
47512 int i;
47513 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47514
47515 /* Fix SwigMethods to carry the callback ptrs when needed */
47516 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47517
47518 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47519 d = PyModule_GetDict(m);
47520
47521 if (!typeinit) {
47522 #ifdef SWIG_LINK_RUNTIME
47523 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47524 #else
47525 # ifndef SWIG_STATIC_RUNTIME
47526 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47527 # endif
47528 #endif
47529 for (i = 0; swig_types_initial[i]; i++) {
47530 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47531 }
47532 typeinit = 1;
47533 }
47534 SWIG_InstallConstants(d,swig_const_table);
47535
47536
47537 #ifndef wxPyUSE_EXPORT
47538 // Make our API structure a CObject so other modules can import it
47539 // from this module.
47540 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47541 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47542 Py_XDECREF(cobj);
47543 #endif
47544
47545 {
47546 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49134 }
49135 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49136 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49137 {
49138 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49289 }
49290 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49291 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49292 {
49293 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49300 }
49301
49302 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49303
49304
49305 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49306
49307 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49308 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49309 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49310 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49311 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49312 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49313 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49314 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49315 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49316 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49317 {
49318 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49322 }
49323 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49324 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49325 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49326 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49327 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49328 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49329 {
49330 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49376 }
49377 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49378 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49379 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49380 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49381 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49382 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49383 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49384 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49385 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49386 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49387 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49388 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49389 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49390 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49391 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49392 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49393 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49394 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49395 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49396 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49397 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49398 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49399 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49400 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49401 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49402 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49403 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49404 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49405 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49406 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49407 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49408 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49409 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49410 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49411 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49412 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49413 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49414 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49415 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49416 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49417 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49418 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49419 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49420 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49421 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49422 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49423 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49424 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49425 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49426 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49427 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49428 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49429 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49430 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49431 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49432 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49433 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49434 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49435 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49436 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49437 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49438 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49439 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49440 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49441 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49442 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49443 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49444 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49445 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49446 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49447 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49448 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49449 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49450 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49451 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49452 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49453 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49454 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49455 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49456 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49457 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49458 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49459 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49460 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49461 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49462 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49463 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49464 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49465 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49466 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49467 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49468 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49469 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49470 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49471 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49472 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49473 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49474 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49475 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49476 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49477 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49478 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49479 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49480 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49481 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49482 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49483 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49484 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49485 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49486 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49487 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49488 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49489 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49490 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49491 {
49492 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49529 }
49530 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49531 {
49532 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49548 }
49549 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49550 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49551 {
49552 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49565 }
49566 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49567 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49568 {
49569 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49576 }
49577 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49578 {
49579 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49634 }
49635
49636 // Initialize threading, some globals and such
49637 __wxPyPreStart(d);
49638
49639
49640 // Although these are defined in __version__ they need to be here too so
49641 // that an assert can be done to ensure that the wxPython and the wxWindows
49642 // versions match.
49643 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49644 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49645 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49646
49647 }
49648
wxWidgets (Impactor)