]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
refresh bitmap when it's label changes, this is necessary for wxMSW and maybe wxGTK...
[wxWidgets.git] / wxPython / src / gtk / _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
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2475 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2476 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2477 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2478 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2479
2480 #include <wx/quantize.h>
2481
2482 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2483 return wxQuantize::Quantize(src, dest,
2484 //NULL, // palette
2485 desiredNoColours,
2486 NULL, // eightBitData
2487 flags);
2488 }
2489 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2490 if (PyCallable_Check(func)) {
2491 self->Connect(id, lastId, eventType,
2492 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2493 new wxPyCallback(func));
2494 }
2495 else if (func == Py_None) {
2496 self->Disconnect(id, lastId, eventType,
2497 (wxObjectEventFunction)
2498 &wxPyCallback::EventThunker);
2499 }
2500 else {
2501 wxPyBLOCK_THREADS(
2502 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2503 }
2504 }
2505 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2506 return self->Disconnect(id, lastId, eventType,
2507 (wxObjectEventFunction)
2508 &wxPyCallback::EventThunker);
2509 }
2510 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2511 if (_self && _self != Py_None) {
2512 self->SetClientObject(new wxPyOORClientData(_self, incref));
2513 }
2514 else {
2515 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2516 if (data) {
2517 self->SetClientObject(NULL); // This will delete it too
2518 }
2519 }
2520 }
2521
2522 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2523 #if wxUSE_UNICODE
2524 return self->GetUnicodeKey();
2525 #else
2526 return 0;
2527 #endif
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540
2541 #if UINT_MAX != ULONG_MAX
2542 SWIGINTERN int
2543 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2544 {
2545 const char* errmsg = val ? "unsigned int" : (char*)0;
2546 unsigned long v;
2547 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2548 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2549 if (val) *val = (unsigned int)(v);
2550 return 1;
2551 }
2552 } else {
2553 PyErr_Clear();
2554 }
2555 if (val) {
2556 SWIG_type_error(errmsg, obj);
2557 }
2558 return 0;
2559 }
2560 #else
2561 SWIGINTERNSHORT unsigned int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2565 }
2566 #endif
2567
2568
2569 SWIGINTERNSHORT unsigned int
2570 SWIG_As_unsigned_SS_int(PyObject* obj)
2571 {
2572 unsigned int v;
2573 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2574 /*
2575 this is needed to make valgrind/purify happier.
2576 */
2577 memset((void*)&v, 0, sizeof(unsigned int));
2578 }
2579 return v;
2580 }
2581
2582
2583 SWIGINTERNSHORT int
2584 SWIG_Check_unsigned_SS_int(PyObject* obj)
2585 {
2586 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2587 }
2588
2589 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2590 self->m_size = size;
2591 }
2592 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2593 int count = self->GetNumberOfFiles();
2594 wxString* files = self->GetFiles();
2595 PyObject* list = PyList_New(count);
2596
2597 if (!list) {
2598 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2599 return NULL;
2600 }
2601
2602 for (int i=0; i<count; i++) {
2603 PyList_SetItem(list, i, wx2PyString(files[i]));
2604 }
2605 return list;
2606 }
2607
2608
2609 static wxPyApp *new_wxPyApp(){
2610 wxPythonApp = new wxPyApp();
2611 return wxPythonApp;
2612 }
2613 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2614
2615 void wxApp_CleanUp() {
2616 __wxPyCleanup();
2617 }
2618
2619
2620 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2621
2622
2623 SWIGINTERNSHORT int
2624 SWIG_AsCharPtr(PyObject *obj, char **val)
2625 {
2626 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2627 return 1;
2628 }
2629 if (val) {
2630 PyErr_Clear();
2631 SWIG_type_error("char *", obj);
2632 }
2633 return 0;
2634 }
2635
2636
2637 SWIGINTERN PyObject *
2638 SWIG_FromCharPtr(const char* cptr)
2639 {
2640 if (cptr) {
2641 size_t size = strlen(cptr);
2642 if (size > INT_MAX) {
2643 return SWIG_NewPointerObj((char*)(cptr),
2644 SWIG_TypeQuery("char *"), 0);
2645 } else {
2646 if (size != 0) {
2647 return PyString_FromStringAndSize(cptr, size);
2648 } else {
2649 return PyString_FromString(cptr);
2650 }
2651 }
2652 }
2653 Py_INCREF(Py_None);
2654 return Py_None;
2655 }
2656
2657
2658 #ifdef __WXMAC__
2659
2660 // A dummy class that raises an exception if used...
2661 class wxEventLoop
2662 {
2663 public:
2664 wxEventLoop() { wxPyRaiseNotImplemented(); }
2665 int Run() { return 0; }
2666 void Exit(int rc = 0) {}
2667 bool Pending() const { return false; }
2668 bool Dispatch() { return false; }
2669 bool IsRunning() const { return false; }
2670 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2671 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2672 };
2673
2674 #else
2675
2676 #include <wx/evtloop.h>
2677
2678 #endif
2679
2680
2681
2682 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2683 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2684 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2685 static PyObject *wxWindow_GetChildren(wxWindow *self){
2686 wxWindowList& list = self->GetChildren();
2687 return wxPy_ConvertList(&list);
2688 }
2689 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2690 #if wxUSE_HOTKEY
2691 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2692 #else
2693 return false;
2694 #endif
2695 }
2696 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2697
2698
2699
2700 return false;
2701
2702 }
2703 static long wxWindow_GetHandle(wxWindow *self){
2704 return wxPyGetWinHandle(self);
2705 }
2706 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2707 self->AssociateHandle((WXWidget)handle);
2708 }
2709
2710 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2711 return wxWindow::FindWindowById(id, parent);
2712 }
2713
2714 wxWindow* wxFindWindowByName( const wxString& name,
2715 const wxWindow *parent = NULL ) {
2716 return wxWindow::FindWindowByName(name, parent);
2717 }
2718
2719 wxWindow* wxFindWindowByLabel( const wxString& label,
2720 const wxWindow *parent = NULL ) {
2721 return wxWindow::FindWindowByLabel(label, parent);
2722 }
2723
2724
2725 #ifdef __WXMSW__
2726 #include <wx/msw/private.h> // to get wxGetWindowId
2727 #endif
2728
2729
2730 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2731 #ifdef __WXMSW__
2732 WXHWND hWnd = (WXHWND)_hWnd;
2733 long id = wxGetWindowId(hWnd);
2734 wxWindow* win = new wxWindow;
2735 parent->AddChild(win);
2736 win->SetEventHandler(win);
2737 win->SetHWND(hWnd);
2738 win->SetId(id);
2739 win->SubclassWin(hWnd);
2740 win->AdoptAttributesFromHWND();
2741 win->SetupColours();
2742 return win;
2743 #else
2744 wxPyRaiseNotImplemented();
2745 return NULL;
2746 #endif
2747 }
2748
2749
2750 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2751 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2752 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2753
2754 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2755
2756 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2757 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2758 wxMenuItemList& list = self->GetMenuItems();
2759 return wxPy_ConvertList(&list);
2760 }
2761 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2762 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2763 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2764 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2765 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2766 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2767 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2768 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2769 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2770 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2771 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2772 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2773 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2774 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2775 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2776 static const wxString wxPyControlNameStr(wxControlNameStr);
2777 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2778 if (clientData) {
2779 wxPyClientData* data = new wxPyClientData(clientData);
2780 return self->Append(item, data);
2781 } else
2782 return self->Append(item);
2783 }
2784 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2785 if (clientData) {
2786 wxPyClientData* data = new wxPyClientData(clientData);
2787 return self->Insert(item, pos, data);
2788 } else
2789 return self->Insert(item, pos);
2790 }
2791 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2792 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2793 if (data) {
2794 Py_INCREF(data->m_obj);
2795 return data->m_obj;
2796 } else {
2797 Py_INCREF(Py_None);
2798 return Py_None;
2799 }
2800 }
2801 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2802 wxPyClientData* data = new wxPyClientData(clientData);
2803 self->SetClientObject(n, data);
2804 }
2805
2806
2807 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2808 wxPyUserData* data = NULL;
2809 if ( userData ) {
2810 bool blocked = wxPyBeginBlockThreads();
2811 data = new wxPyUserData(userData);
2812 wxPyEndBlockThreads(blocked);
2813 }
2814 return new wxSizerItem(window, proportion, flag, border, data);
2815 }
2816 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2817 wxPyUserData* data = NULL;
2818 if ( userData ) {
2819 bool blocked = wxPyBeginBlockThreads();
2820 data = new wxPyUserData(userData);
2821 wxPyEndBlockThreads(blocked);
2822 }
2823 return new wxSizerItem(width, height, proportion, flag, border, data);
2824 }
2825 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2826 wxPyUserData* data = NULL;
2827 if ( userData ) {
2828 bool blocked = wxPyBeginBlockThreads();
2829 data = new wxPyUserData(userData);
2830 wxPyEndBlockThreads(blocked);
2831 }
2832 return new wxSizerItem(sizer, proportion, flag, border, data);
2833 }
2834
2835 #include <float.h>
2836 SWIGINTERN int
2837 SWIG_CheckDoubleInRange(double value, double min_value,
2838 double max_value, const char* errmsg)
2839 {
2840 if (value < min_value) {
2841 if (errmsg) {
2842 PyErr_Format(PyExc_OverflowError,
2843 "value %g is less than %s minimum %g",
2844 value, errmsg, min_value);
2845 }
2846 return 0;
2847 } else if (value > max_value) {
2848 if (errmsg) {
2849 PyErr_Format(PyExc_OverflowError,
2850 "value %g is greater than %s maximum %g",
2851 value, errmsg, max_value);
2852 }
2853 return 0;
2854 }
2855 return 1;
2856 }
2857
2858
2859 SWIGINTERN int
2860 SWIG_AsVal_float(PyObject *obj, float *val)
2861 {
2862 const char* errmsg = val ? "float" : (char*)0;
2863 double v;
2864 if (SWIG_AsVal_double(obj, &v)) {
2865 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2866 if (val) *val = (float)(v);
2867 return 1;
2868 } else {
2869 return 0;
2870 }
2871 } else {
2872 PyErr_Clear();
2873 }
2874 if (val) {
2875 SWIG_type_error(errmsg, obj);
2876 }
2877 return 0;
2878 }
2879
2880
2881 SWIGINTERNSHORT float
2882 SWIG_As_float(PyObject* obj)
2883 {
2884 float v;
2885 if (!SWIG_AsVal_float(obj, &v)) {
2886 /*
2887 this is needed to make valgrind/purify happier.
2888 */
2889 memset((void*)&v, 0, sizeof(float));
2890 }
2891 return v;
2892 }
2893
2894
2895 SWIGINTERNSHORT int
2896 SWIG_Check_float(PyObject* obj)
2897 {
2898 return SWIG_AsVal_float(obj, (float*)0);
2899 }
2900
2901
2902 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2903 #define SWIG_From_float PyFloat_FromDouble
2904 /*@@*/
2905
2906 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2907 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2908 if (data) {
2909 Py_INCREF(data->m_obj);
2910 return data->m_obj;
2911 } else {
2912 Py_INCREF(Py_None);
2913 return Py_None;
2914 }
2915 }
2916
2917 // Figure out the type of the sizer item
2918
2919 struct wxPySizerItemInfo {
2920 wxPySizerItemInfo()
2921 : window(NULL), sizer(NULL), gotSize(false),
2922 size(wxDefaultSize), gotPos(false), pos(-1)
2923 {}
2924
2925 wxWindow* window;
2926 wxSizer* sizer;
2927 bool gotSize;
2928 wxSize size;
2929 bool gotPos;
2930 int pos;
2931 };
2932
2933 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2934
2935 wxPySizerItemInfo info;
2936 wxSize size;
2937 wxSize* sizePtr = &size;
2938
2939 // Find out what the type of the item is
2940 // try wxWindow
2941 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2942 PyErr_Clear();
2943 info.window = NULL;
2944
2945 // try wxSizer
2946 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2947 PyErr_Clear();
2948 info.sizer = NULL;
2949
2950 // try wxSize or (w,h)
2951 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2952 info.size = *sizePtr;
2953 info.gotSize = true;
2954 }
2955
2956 // or a single int
2957 if (checkIdx && PyInt_Check(item)) {
2958 info.pos = PyInt_AsLong(item);
2959 info.gotPos = true;
2960 }
2961 }
2962 }
2963
2964 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2965 // no expected type, figure out what kind of error message to generate
2966 if ( !checkSize && !checkIdx )
2967 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2968 else if ( checkSize && !checkIdx )
2969 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2970 else if ( !checkSize && checkIdx)
2971 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2972 else
2973 // can this one happen?
2974 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2975 }
2976
2977 return info;
2978 }
2979
2980 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2981 if (!self->GetClientObject())
2982 self->SetClientObject(new wxPyOORClientData(_self));
2983 }
2984 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2985
2986 wxPyUserData* data = NULL;
2987 bool blocked = wxPyBeginBlockThreads();
2988 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2989 if ( userData && (info.window || info.sizer || info.gotSize) )
2990 data = new wxPyUserData(userData);
2991 wxPyEndBlockThreads(blocked);
2992
2993 // Now call the real Add method if a valid item type was found
2994 if ( info.window )
2995 return self->Add(info.window, proportion, flag, border, data);
2996 else if ( info.sizer )
2997 return self->Add(info.sizer, proportion, flag, border, data);
2998 else if (info.gotSize)
2999 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3000 proportion, flag, border, data);
3001 else
3002 return NULL;
3003 }
3004 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3005
3006 wxPyUserData* data = NULL;
3007 bool blocked = wxPyBeginBlockThreads();
3008 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3009 if ( userData && (info.window || info.sizer || info.gotSize) )
3010 data = new wxPyUserData(userData);
3011 wxPyEndBlockThreads(blocked);
3012
3013 // Now call the real Insert method if a valid item type was found
3014 if ( info.window )
3015 return self->Insert(before, info.window, proportion, flag, border, data);
3016 else if ( info.sizer )
3017 return self->Insert(before, info.sizer, proportion, flag, border, data);
3018 else if (info.gotSize)
3019 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3020 proportion, flag, border, data);
3021 else
3022 return NULL;
3023 }
3024 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3025
3026 wxPyUserData* data = NULL;
3027 bool blocked = wxPyBeginBlockThreads();
3028 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3029 if ( userData && (info.window || info.sizer || info.gotSize) )
3030 data = new wxPyUserData(userData);
3031 wxPyEndBlockThreads(blocked);
3032
3033 // Now call the real Prepend method if a valid item type was found
3034 if ( info.window )
3035 return self->Prepend(info.window, proportion, flag, border, data);
3036 else if ( info.sizer )
3037 return self->Prepend(info.sizer, proportion, flag, border, data);
3038 else if (info.gotSize)
3039 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3040 proportion, flag, border, data);
3041 else
3042 return NULL;
3043 }
3044 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3045 bool blocked = wxPyBeginBlockThreads();
3046 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3047 wxPyEndBlockThreads(blocked);
3048 if ( info.window )
3049 return self->Remove(info.window);
3050 else if ( info.sizer )
3051 return self->Remove(info.sizer);
3052 else if ( info.gotPos )
3053 return self->Remove(info.pos);
3054 else
3055 return false;
3056 }
3057 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3058 bool blocked = wxPyBeginBlockThreads();
3059 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3060 wxPyEndBlockThreads(blocked);
3061 if ( info.window )
3062 return self->Detach(info.window);
3063 else if ( info.sizer )
3064 return self->Detach(info.sizer);
3065 else if ( info.gotPos )
3066 return self->Detach(info.pos);
3067 else
3068 return false;
3069 }
3070 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3071 bool blocked = wxPyBeginBlockThreads();
3072 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3073 wxPyEndBlockThreads(blocked);
3074 if ( info.window )
3075 return self->GetItem(info.window);
3076 else if ( info.sizer )
3077 return self->GetItem(info.sizer);
3078 else if ( info.gotPos )
3079 return self->GetItem(info.pos);
3080 else
3081 return NULL;
3082 }
3083 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3084 bool blocked = wxPyBeginBlockThreads();
3085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3086 wxPyEndBlockThreads(blocked);
3087 if ( info.window )
3088 self->SetItemMinSize(info.window, size);
3089 else if ( info.sizer )
3090 self->SetItemMinSize(info.sizer, size);
3091 else if ( info.gotPos )
3092 self->SetItemMinSize(info.pos, size);
3093 }
3094 static PyObject *wxSizer_GetChildren(wxSizer *self){
3095 wxSizerItemList& list = self->GetChildren();
3096 return wxPy_ConvertList(&list);
3097 }
3098 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3099 bool blocked = wxPyBeginBlockThreads();
3100 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3101 wxPyEndBlockThreads(blocked);
3102 if ( info.window )
3103 return self->Show(info.window, show, recursive);
3104 else if ( info.sizer )
3105 return self->Show(info.sizer, show, recursive);
3106 else if ( info.gotPos )
3107 return self->Show(info.pos, show);
3108 else
3109 return false;
3110 }
3111 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3112 bool blocked = wxPyBeginBlockThreads();
3113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3114 wxPyEndBlockThreads(blocked);
3115 if ( info.window )
3116 return self->IsShown(info.window);
3117 else if ( info.sizer )
3118 return self->IsShown(info.sizer);
3119 else if ( info.gotPos )
3120 return self->IsShown(info.pos);
3121 else
3122 return false;
3123 }
3124
3125 // See pyclasses.h
3126 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3127 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3128 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3129
3130
3131
3132
3133 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3134 {
3135 if (source == Py_None) {
3136 **obj = wxGBPosition(-1,-1);
3137 return true;
3138 }
3139 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3140 }
3141
3142 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3143 {
3144 if (source == Py_None) {
3145 **obj = wxGBSpan(-1,-1);
3146 return true;
3147 }
3148 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3149 }
3150
3151
3152 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3153 self->SetRow(row);
3154 self->SetCol(col);
3155 }
3156 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3157 bool blocked = wxPyBeginBlockThreads();
3158 PyObject* tup = PyTuple_New(2);
3159 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3160 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3161 wxPyEndBlockThreads(blocked);
3162 return tup;
3163 }
3164 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3165 self->SetRowspan(rowspan);
3166 self->SetColspan(colspan);
3167 }
3168 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3169 bool blocked = wxPyBeginBlockThreads();
3170 PyObject* tup = PyTuple_New(2);
3171 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3172 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3173 wxPyEndBlockThreads(blocked);
3174 return tup;
3175 }
3176 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3177 wxPyUserData* data = NULL;
3178 if ( userData ) {
3179 bool blocked = wxPyBeginBlockThreads();
3180 data = new wxPyUserData(userData);
3181 wxPyEndBlockThreads(blocked);
3182 }
3183 return new wxGBSizerItem(window, pos, span, flag, border, data);
3184 }
3185 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3186 wxPyUserData* data = NULL;
3187 if ( userData ) {
3188 bool blocked = wxPyBeginBlockThreads();
3189 data = new wxPyUserData(userData);
3190 wxPyEndBlockThreads(blocked);
3191 }
3192 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3193 }
3194 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3195 wxPyUserData* data = NULL;
3196 if ( userData ) {
3197 bool blocked = wxPyBeginBlockThreads();
3198 data = new wxPyUserData(userData);
3199 wxPyEndBlockThreads(blocked);
3200 }
3201 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3202 }
3203 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3204 int row, col;
3205 self->GetEndPos(row, col);
3206 return wxGBPosition(row, col);
3207 }
3208 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3209
3210 wxPyUserData* data = NULL;
3211 bool blocked = wxPyBeginBlockThreads();
3212 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3213 if ( userData && (info.window || info.sizer || info.gotSize) )
3214 data = new wxPyUserData(userData);
3215 wxPyEndBlockThreads(blocked);
3216
3217 // Now call the real Add method if a valid item type was found
3218 if ( info.window )
3219 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3220 else if ( info.sizer )
3221 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3222 else if (info.gotSize)
3223 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3224 pos, span, flag, border, data);
3225 return NULL;
3226 }
3227
3228
3229 #ifdef __cplusplus
3230 extern "C" {
3231 #endif
3232 static int _wrap_EmptyString_set(PyObject *) {
3233 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3234 return 1;
3235 }
3236
3237
3238 static PyObject *_wrap_EmptyString_get(void) {
3239 PyObject *pyobj;
3240
3241 {
3242 #if wxUSE_UNICODE
3243 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3244 #else
3245 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3246 #endif
3247 }
3248 return pyobj;
3249 }
3250
3251
3252 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3253 PyObject *resultobj;
3254 wxObject *arg1 = (wxObject *) 0 ;
3255 wxString result;
3256 PyObject * obj0 = 0 ;
3257 char *kwnames[] = {
3258 (char *) "self", NULL
3259 };
3260
3261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3263 if (SWIG_arg_fail(1)) SWIG_fail;
3264 {
3265 PyThreadState* __tstate = wxPyBeginAllowThreads();
3266 result = wxObject_GetClassName(arg1);
3267
3268 wxPyEndAllowThreads(__tstate);
3269 if (PyErr_Occurred()) SWIG_fail;
3270 }
3271 {
3272 #if wxUSE_UNICODE
3273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3274 #else
3275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3276 #endif
3277 }
3278 return resultobj;
3279 fail:
3280 return NULL;
3281 }
3282
3283
3284 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3285 PyObject *resultobj;
3286 wxObject *arg1 = (wxObject *) 0 ;
3287 PyObject * obj0 = 0 ;
3288 char *kwnames[] = {
3289 (char *) "self", NULL
3290 };
3291
3292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3294 if (SWIG_arg_fail(1)) SWIG_fail;
3295 {
3296 PyThreadState* __tstate = wxPyBeginAllowThreads();
3297 wxObject_Destroy(arg1);
3298
3299 wxPyEndAllowThreads(__tstate);
3300 if (PyErr_Occurred()) SWIG_fail;
3301 }
3302 Py_INCREF(Py_None); resultobj = Py_None;
3303 return resultobj;
3304 fail:
3305 return NULL;
3306 }
3307
3308
3309 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3310 PyObject *obj;
3311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3312 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3313 Py_INCREF(obj);
3314 return Py_BuildValue((char *)"");
3315 }
3316 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3317 PyObject *resultobj;
3318 wxSize *arg1 = (wxSize *) 0 ;
3319 int arg2 ;
3320 PyObject * obj0 = 0 ;
3321 PyObject * obj1 = 0 ;
3322 char *kwnames[] = {
3323 (char *) "self",(char *) "x", NULL
3324 };
3325
3326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3328 if (SWIG_arg_fail(1)) SWIG_fail;
3329 {
3330 arg2 = (int)(SWIG_As_int(obj1));
3331 if (SWIG_arg_fail(2)) SWIG_fail;
3332 }
3333 if (arg1) (arg1)->x = arg2;
3334
3335 Py_INCREF(Py_None); resultobj = Py_None;
3336 return resultobj;
3337 fail:
3338 return NULL;
3339 }
3340
3341
3342 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3343 PyObject *resultobj;
3344 wxSize *arg1 = (wxSize *) 0 ;
3345 int result;
3346 PyObject * obj0 = 0 ;
3347 char *kwnames[] = {
3348 (char *) "self", NULL
3349 };
3350
3351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3353 if (SWIG_arg_fail(1)) SWIG_fail;
3354 result = (int) ((arg1)->x);
3355
3356 {
3357 resultobj = SWIG_From_int((int)(result));
3358 }
3359 return resultobj;
3360 fail:
3361 return NULL;
3362 }
3363
3364
3365 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3366 PyObject *resultobj;
3367 wxSize *arg1 = (wxSize *) 0 ;
3368 int arg2 ;
3369 PyObject * obj0 = 0 ;
3370 PyObject * obj1 = 0 ;
3371 char *kwnames[] = {
3372 (char *) "self",(char *) "y", NULL
3373 };
3374
3375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3377 if (SWIG_arg_fail(1)) SWIG_fail;
3378 {
3379 arg2 = (int)(SWIG_As_int(obj1));
3380 if (SWIG_arg_fail(2)) SWIG_fail;
3381 }
3382 if (arg1) (arg1)->y = arg2;
3383
3384 Py_INCREF(Py_None); resultobj = Py_None;
3385 return resultobj;
3386 fail:
3387 return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3392 PyObject *resultobj;
3393 wxSize *arg1 = (wxSize *) 0 ;
3394 int result;
3395 PyObject * obj0 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "self", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3402 if (SWIG_arg_fail(1)) SWIG_fail;
3403 result = (int) ((arg1)->y);
3404
3405 {
3406 resultobj = SWIG_From_int((int)(result));
3407 }
3408 return resultobj;
3409 fail:
3410 return NULL;
3411 }
3412
3413
3414 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3415 PyObject *resultobj;
3416 int arg1 = (int) 0 ;
3417 int arg2 = (int) 0 ;
3418 wxSize *result;
3419 PyObject * obj0 = 0 ;
3420 PyObject * obj1 = 0 ;
3421 char *kwnames[] = {
3422 (char *) "w",(char *) "h", NULL
3423 };
3424
3425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3426 if (obj0) {
3427 {
3428 arg1 = (int)(SWIG_As_int(obj0));
3429 if (SWIG_arg_fail(1)) SWIG_fail;
3430 }
3431 }
3432 if (obj1) {
3433 {
3434 arg2 = (int)(SWIG_As_int(obj1));
3435 if (SWIG_arg_fail(2)) SWIG_fail;
3436 }
3437 }
3438 {
3439 PyThreadState* __tstate = wxPyBeginAllowThreads();
3440 result = (wxSize *)new wxSize(arg1,arg2);
3441
3442 wxPyEndAllowThreads(__tstate);
3443 if (PyErr_Occurred()) SWIG_fail;
3444 }
3445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3446 return resultobj;
3447 fail:
3448 return NULL;
3449 }
3450
3451
3452 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3453 PyObject *resultobj;
3454 wxSize *arg1 = (wxSize *) 0 ;
3455 PyObject * obj0 = 0 ;
3456 char *kwnames[] = {
3457 (char *) "self", NULL
3458 };
3459
3460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3462 if (SWIG_arg_fail(1)) SWIG_fail;
3463 {
3464 PyThreadState* __tstate = wxPyBeginAllowThreads();
3465 delete arg1;
3466
3467 wxPyEndAllowThreads(__tstate);
3468 if (PyErr_Occurred()) SWIG_fail;
3469 }
3470 Py_INCREF(Py_None); resultobj = Py_None;
3471 return resultobj;
3472 fail:
3473 return NULL;
3474 }
3475
3476
3477 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3478 PyObject *resultobj;
3479 wxSize *arg1 = (wxSize *) 0 ;
3480 wxSize *arg2 = 0 ;
3481 bool result;
3482 wxSize temp2 ;
3483 PyObject * obj0 = 0 ;
3484 PyObject * obj1 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self",(char *) "sz", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 {
3493 arg2 = &temp2;
3494 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3495 }
3496 {
3497 PyThreadState* __tstate = wxPyBeginAllowThreads();
3498 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3499
3500 wxPyEndAllowThreads(__tstate);
3501 if (PyErr_Occurred()) SWIG_fail;
3502 }
3503 {
3504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3505 }
3506 return resultobj;
3507 fail:
3508 return NULL;
3509 }
3510
3511
3512 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3513 PyObject *resultobj;
3514 wxSize *arg1 = (wxSize *) 0 ;
3515 wxSize *arg2 = 0 ;
3516 bool result;
3517 wxSize temp2 ;
3518 PyObject * obj0 = 0 ;
3519 PyObject * obj1 = 0 ;
3520 char *kwnames[] = {
3521 (char *) "self",(char *) "sz", NULL
3522 };
3523
3524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3526 if (SWIG_arg_fail(1)) SWIG_fail;
3527 {
3528 arg2 = &temp2;
3529 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3530 }
3531 {
3532 PyThreadState* __tstate = wxPyBeginAllowThreads();
3533 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3534
3535 wxPyEndAllowThreads(__tstate);
3536 if (PyErr_Occurred()) SWIG_fail;
3537 }
3538 {
3539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3540 }
3541 return resultobj;
3542 fail:
3543 return NULL;
3544 }
3545
3546
3547 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3548 PyObject *resultobj;
3549 wxSize *arg1 = (wxSize *) 0 ;
3550 wxSize *arg2 = 0 ;
3551 wxSize result;
3552 wxSize temp2 ;
3553 PyObject * obj0 = 0 ;
3554 PyObject * obj1 = 0 ;
3555 char *kwnames[] = {
3556 (char *) "self",(char *) "sz", NULL
3557 };
3558
3559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3561 if (SWIG_arg_fail(1)) SWIG_fail;
3562 {
3563 arg2 = &temp2;
3564 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3565 }
3566 {
3567 PyThreadState* __tstate = wxPyBeginAllowThreads();
3568 result = (arg1)->operator +((wxSize const &)*arg2);
3569
3570 wxPyEndAllowThreads(__tstate);
3571 if (PyErr_Occurred()) SWIG_fail;
3572 }
3573 {
3574 wxSize * resultptr;
3575 resultptr = new wxSize((wxSize &)(result));
3576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3577 }
3578 return resultobj;
3579 fail:
3580 return NULL;
3581 }
3582
3583
3584 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3585 PyObject *resultobj;
3586 wxSize *arg1 = (wxSize *) 0 ;
3587 wxSize *arg2 = 0 ;
3588 wxSize result;
3589 wxSize temp2 ;
3590 PyObject * obj0 = 0 ;
3591 PyObject * obj1 = 0 ;
3592 char *kwnames[] = {
3593 (char *) "self",(char *) "sz", NULL
3594 };
3595
3596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3598 if (SWIG_arg_fail(1)) SWIG_fail;
3599 {
3600 arg2 = &temp2;
3601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3602 }
3603 {
3604 PyThreadState* __tstate = wxPyBeginAllowThreads();
3605 result = (arg1)->operator -((wxSize const &)*arg2);
3606
3607 wxPyEndAllowThreads(__tstate);
3608 if (PyErr_Occurred()) SWIG_fail;
3609 }
3610 {
3611 wxSize * resultptr;
3612 resultptr = new wxSize((wxSize &)(result));
3613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3614 }
3615 return resultobj;
3616 fail:
3617 return NULL;
3618 }
3619
3620
3621 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3622 PyObject *resultobj;
3623 wxSize *arg1 = (wxSize *) 0 ;
3624 wxSize *arg2 = 0 ;
3625 wxSize temp2 ;
3626 PyObject * obj0 = 0 ;
3627 PyObject * obj1 = 0 ;
3628 char *kwnames[] = {
3629 (char *) "self",(char *) "sz", NULL
3630 };
3631
3632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3634 if (SWIG_arg_fail(1)) SWIG_fail;
3635 {
3636 arg2 = &temp2;
3637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3638 }
3639 {
3640 PyThreadState* __tstate = wxPyBeginAllowThreads();
3641 (arg1)->IncTo((wxSize const &)*arg2);
3642
3643 wxPyEndAllowThreads(__tstate);
3644 if (PyErr_Occurred()) SWIG_fail;
3645 }
3646 Py_INCREF(Py_None); resultobj = Py_None;
3647 return resultobj;
3648 fail:
3649 return NULL;
3650 }
3651
3652
3653 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3654 PyObject *resultobj;
3655 wxSize *arg1 = (wxSize *) 0 ;
3656 wxSize *arg2 = 0 ;
3657 wxSize temp2 ;
3658 PyObject * obj0 = 0 ;
3659 PyObject * obj1 = 0 ;
3660 char *kwnames[] = {
3661 (char *) "self",(char *) "sz", NULL
3662 };
3663
3664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3666 if (SWIG_arg_fail(1)) SWIG_fail;
3667 {
3668 arg2 = &temp2;
3669 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3670 }
3671 {
3672 PyThreadState* __tstate = wxPyBeginAllowThreads();
3673 (arg1)->DecTo((wxSize const &)*arg2);
3674
3675 wxPyEndAllowThreads(__tstate);
3676 if (PyErr_Occurred()) SWIG_fail;
3677 }
3678 Py_INCREF(Py_None); resultobj = Py_None;
3679 return resultobj;
3680 fail:
3681 return NULL;
3682 }
3683
3684
3685 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3686 PyObject *resultobj;
3687 wxSize *arg1 = (wxSize *) 0 ;
3688 int arg2 ;
3689 int arg3 ;
3690 PyObject * obj0 = 0 ;
3691 PyObject * obj1 = 0 ;
3692 PyObject * obj2 = 0 ;
3693 char *kwnames[] = {
3694 (char *) "self",(char *) "w",(char *) "h", NULL
3695 };
3696
3697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3699 if (SWIG_arg_fail(1)) SWIG_fail;
3700 {
3701 arg2 = (int)(SWIG_As_int(obj1));
3702 if (SWIG_arg_fail(2)) SWIG_fail;
3703 }
3704 {
3705 arg3 = (int)(SWIG_As_int(obj2));
3706 if (SWIG_arg_fail(3)) SWIG_fail;
3707 }
3708 {
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 (arg1)->Set(arg2,arg3);
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 wxSize *arg1 = (wxSize *) 0 ;
3725 int arg2 ;
3726 PyObject * obj0 = 0 ;
3727 PyObject * obj1 = 0 ;
3728 char *kwnames[] = {
3729 (char *) "self",(char *) "w", NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3734 if (SWIG_arg_fail(1)) SWIG_fail;
3735 {
3736 arg2 = (int)(SWIG_As_int(obj1));
3737 if (SWIG_arg_fail(2)) SWIG_fail;
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 (arg1)->SetWidth(arg2);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 wxSize *arg1 = (wxSize *) 0 ;
3756 int arg2 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "self",(char *) "h", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(1)) SWIG_fail;
3766 {
3767 arg2 = (int)(SWIG_As_int(obj1));
3768 if (SWIG_arg_fail(2)) SWIG_fail;
3769 }
3770 {
3771 PyThreadState* __tstate = wxPyBeginAllowThreads();
3772 (arg1)->SetHeight(arg2);
3773
3774 wxPyEndAllowThreads(__tstate);
3775 if (PyErr_Occurred()) SWIG_fail;
3776 }
3777 Py_INCREF(Py_None); resultobj = Py_None;
3778 return resultobj;
3779 fail:
3780 return NULL;
3781 }
3782
3783
3784 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3785 PyObject *resultobj;
3786 wxSize *arg1 = (wxSize *) 0 ;
3787 int result;
3788 PyObject * obj0 = 0 ;
3789 char *kwnames[] = {
3790 (char *) "self", NULL
3791 };
3792
3793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3795 if (SWIG_arg_fail(1)) SWIG_fail;
3796 {
3797 PyThreadState* __tstate = wxPyBeginAllowThreads();
3798 result = (int)((wxSize const *)arg1)->GetWidth();
3799
3800 wxPyEndAllowThreads(__tstate);
3801 if (PyErr_Occurred()) SWIG_fail;
3802 }
3803 {
3804 resultobj = SWIG_From_int((int)(result));
3805 }
3806 return resultobj;
3807 fail:
3808 return NULL;
3809 }
3810
3811
3812 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3813 PyObject *resultobj;
3814 wxSize *arg1 = (wxSize *) 0 ;
3815 int result;
3816 PyObject * obj0 = 0 ;
3817 char *kwnames[] = {
3818 (char *) "self", NULL
3819 };
3820
3821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3823 if (SWIG_arg_fail(1)) SWIG_fail;
3824 {
3825 PyThreadState* __tstate = wxPyBeginAllowThreads();
3826 result = (int)((wxSize const *)arg1)->GetHeight();
3827
3828 wxPyEndAllowThreads(__tstate);
3829 if (PyErr_Occurred()) SWIG_fail;
3830 }
3831 {
3832 resultobj = SWIG_From_int((int)(result));
3833 }
3834 return resultobj;
3835 fail:
3836 return NULL;
3837 }
3838
3839
3840 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3841 PyObject *resultobj;
3842 wxSize *arg1 = (wxSize *) 0 ;
3843 bool result;
3844 PyObject * obj0 = 0 ;
3845 char *kwnames[] = {
3846 (char *) "self", NULL
3847 };
3848
3849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3851 if (SWIG_arg_fail(1)) SWIG_fail;
3852 {
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 {
3860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3861 }
3862 return resultobj;
3863 fail:
3864 return NULL;
3865 }
3866
3867
3868 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3869 PyObject *resultobj;
3870 wxSize *arg1 = (wxSize *) 0 ;
3871 wxSize *arg2 = 0 ;
3872 wxSize temp2 ;
3873 PyObject * obj0 = 0 ;
3874 PyObject * obj1 = 0 ;
3875 char *kwnames[] = {
3876 (char *) "self",(char *) "size", NULL
3877 };
3878
3879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3881 if (SWIG_arg_fail(1)) SWIG_fail;
3882 {
3883 arg2 = &temp2;
3884 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3885 }
3886 {
3887 PyThreadState* __tstate = wxPyBeginAllowThreads();
3888 (arg1)->SetDefaults((wxSize const &)*arg2);
3889
3890 wxPyEndAllowThreads(__tstate);
3891 if (PyErr_Occurred()) SWIG_fail;
3892 }
3893 Py_INCREF(Py_None); resultobj = Py_None;
3894 return resultobj;
3895 fail:
3896 return NULL;
3897 }
3898
3899
3900 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3901 PyObject *resultobj;
3902 wxSize *arg1 = (wxSize *) 0 ;
3903 PyObject *result;
3904 PyObject * obj0 = 0 ;
3905 char *kwnames[] = {
3906 (char *) "self", NULL
3907 };
3908
3909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3911 if (SWIG_arg_fail(1)) SWIG_fail;
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 result = (PyObject *)wxSize_Get(arg1);
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 resultobj = result;
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3927 PyObject *obj;
3928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3929 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3930 Py_INCREF(obj);
3931 return Py_BuildValue((char *)"");
3932 }
3933 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3934 PyObject *resultobj;
3935 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3936 double arg2 ;
3937 PyObject * obj0 = 0 ;
3938 PyObject * obj1 = 0 ;
3939 char *kwnames[] = {
3940 (char *) "self",(char *) "x", NULL
3941 };
3942
3943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3945 if (SWIG_arg_fail(1)) SWIG_fail;
3946 {
3947 arg2 = (double)(SWIG_As_double(obj1));
3948 if (SWIG_arg_fail(2)) SWIG_fail;
3949 }
3950 if (arg1) (arg1)->x = arg2;
3951
3952 Py_INCREF(Py_None); resultobj = Py_None;
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj;
3961 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3962 double result;
3963 PyObject * obj0 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 result = (double) ((arg1)->x);
3972
3973 {
3974 resultobj = SWIG_From_double((double)(result));
3975 }
3976 return resultobj;
3977 fail:
3978 return NULL;
3979 }
3980
3981
3982 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj;
3984 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3985 double arg2 ;
3986 PyObject * obj0 = 0 ;
3987 PyObject * obj1 = 0 ;
3988 char *kwnames[] = {
3989 (char *) "self",(char *) "y", NULL
3990 };
3991
3992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3994 if (SWIG_arg_fail(1)) SWIG_fail;
3995 {
3996 arg2 = (double)(SWIG_As_double(obj1));
3997 if (SWIG_arg_fail(2)) SWIG_fail;
3998 }
3999 if (arg1) (arg1)->y = arg2;
4000
4001 Py_INCREF(Py_None); resultobj = Py_None;
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4011 double result;
4012 PyObject * obj0 = 0 ;
4013 char *kwnames[] = {
4014 (char *) "self", NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 result = (double) ((arg1)->y);
4021
4022 {
4023 resultobj = SWIG_From_double((double)(result));
4024 }
4025 return resultobj;
4026 fail:
4027 return NULL;
4028 }
4029
4030
4031 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4032 PyObject *resultobj;
4033 double arg1 = (double) 0.0 ;
4034 double arg2 = (double) 0.0 ;
4035 wxRealPoint *result;
4036 PyObject * obj0 = 0 ;
4037 PyObject * obj1 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "x",(char *) "y", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4043 if (obj0) {
4044 {
4045 arg1 = (double)(SWIG_As_double(obj0));
4046 if (SWIG_arg_fail(1)) SWIG_fail;
4047 }
4048 }
4049 if (obj1) {
4050 {
4051 arg2 = (double)(SWIG_As_double(obj1));
4052 if (SWIG_arg_fail(2)) SWIG_fail;
4053 }
4054 }
4055 {
4056 PyThreadState* __tstate = wxPyBeginAllowThreads();
4057 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4058
4059 wxPyEndAllowThreads(__tstate);
4060 if (PyErr_Occurred()) SWIG_fail;
4061 }
4062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4063 return resultobj;
4064 fail:
4065 return NULL;
4066 }
4067
4068
4069 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4070 PyObject *resultobj;
4071 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4072 PyObject * obj0 = 0 ;
4073 char *kwnames[] = {
4074 (char *) "self", NULL
4075 };
4076
4077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4079 if (SWIG_arg_fail(1)) SWIG_fail;
4080 {
4081 PyThreadState* __tstate = wxPyBeginAllowThreads();
4082 delete arg1;
4083
4084 wxPyEndAllowThreads(__tstate);
4085 if (PyErr_Occurred()) SWIG_fail;
4086 }
4087 Py_INCREF(Py_None); resultobj = Py_None;
4088 return resultobj;
4089 fail:
4090 return NULL;
4091 }
4092
4093
4094 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj;
4096 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4097 wxRealPoint *arg2 = 0 ;
4098 bool result;
4099 wxRealPoint temp2 ;
4100 PyObject * obj0 = 0 ;
4101 PyObject * obj1 = 0 ;
4102 char *kwnames[] = {
4103 (char *) "self",(char *) "pt", NULL
4104 };
4105
4106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4108 if (SWIG_arg_fail(1)) SWIG_fail;
4109 {
4110 arg2 = &temp2;
4111 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4112 }
4113 {
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 {
4121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4122 }
4123 return resultobj;
4124 fail:
4125 return NULL;
4126 }
4127
4128
4129 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4130 PyObject *resultobj;
4131 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4132 wxRealPoint *arg2 = 0 ;
4133 bool result;
4134 wxRealPoint temp2 ;
4135 PyObject * obj0 = 0 ;
4136 PyObject * obj1 = 0 ;
4137 char *kwnames[] = {
4138 (char *) "self",(char *) "pt", NULL
4139 };
4140
4141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4143 if (SWIG_arg_fail(1)) SWIG_fail;
4144 {
4145 arg2 = &temp2;
4146 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4147 }
4148 {
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4151
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 {
4156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4157 }
4158 return resultobj;
4159 fail:
4160 return NULL;
4161 }
4162
4163
4164 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4165 PyObject *resultobj;
4166 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4167 wxRealPoint *arg2 = 0 ;
4168 wxRealPoint result;
4169 wxRealPoint temp2 ;
4170 PyObject * obj0 = 0 ;
4171 PyObject * obj1 = 0 ;
4172 char *kwnames[] = {
4173 (char *) "self",(char *) "pt", NULL
4174 };
4175
4176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4178 if (SWIG_arg_fail(1)) SWIG_fail;
4179 {
4180 arg2 = &temp2;
4181 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4182 }
4183 {
4184 PyThreadState* __tstate = wxPyBeginAllowThreads();
4185 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4186
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 {
4191 wxRealPoint * resultptr;
4192 resultptr = new wxRealPoint((wxRealPoint &)(result));
4193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4194 }
4195 return resultobj;
4196 fail:
4197 return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4202 PyObject *resultobj;
4203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4204 wxRealPoint *arg2 = 0 ;
4205 wxRealPoint result;
4206 wxRealPoint temp2 ;
4207 PyObject * obj0 = 0 ;
4208 PyObject * obj1 = 0 ;
4209 char *kwnames[] = {
4210 (char *) "self",(char *) "pt", NULL
4211 };
4212
4213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4215 if (SWIG_arg_fail(1)) SWIG_fail;
4216 {
4217 arg2 = &temp2;
4218 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4219 }
4220 {
4221 PyThreadState* __tstate = wxPyBeginAllowThreads();
4222 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4223
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 {
4228 wxRealPoint * resultptr;
4229 resultptr = new wxRealPoint((wxRealPoint &)(result));
4230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4231 }
4232 return resultobj;
4233 fail:
4234 return NULL;
4235 }
4236
4237
4238 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4239 PyObject *resultobj;
4240 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4241 double arg2 ;
4242 double arg3 ;
4243 PyObject * obj0 = 0 ;
4244 PyObject * obj1 = 0 ;
4245 PyObject * obj2 = 0 ;
4246 char *kwnames[] = {
4247 (char *) "self",(char *) "x",(char *) "y", NULL
4248 };
4249
4250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4252 if (SWIG_arg_fail(1)) SWIG_fail;
4253 {
4254 arg2 = (double)(SWIG_As_double(obj1));
4255 if (SWIG_arg_fail(2)) SWIG_fail;
4256 }
4257 {
4258 arg3 = (double)(SWIG_As_double(obj2));
4259 if (SWIG_arg_fail(3)) SWIG_fail;
4260 }
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 wxRealPoint_Set(arg1,arg2,arg3);
4264
4265 wxPyEndAllowThreads(__tstate);
4266 if (PyErr_Occurred()) SWIG_fail;
4267 }
4268 Py_INCREF(Py_None); resultobj = Py_None;
4269 return resultobj;
4270 fail:
4271 return NULL;
4272 }
4273
4274
4275 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4276 PyObject *resultobj;
4277 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4278 PyObject *result;
4279 PyObject * obj0 = 0 ;
4280 char *kwnames[] = {
4281 (char *) "self", NULL
4282 };
4283
4284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4286 if (SWIG_arg_fail(1)) SWIG_fail;
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 result = (PyObject *)wxRealPoint_Get(arg1);
4290
4291 wxPyEndAllowThreads(__tstate);
4292 if (PyErr_Occurred()) SWIG_fail;
4293 }
4294 resultobj = result;
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4302 PyObject *obj;
4303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4304 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4305 Py_INCREF(obj);
4306 return Py_BuildValue((char *)"");
4307 }
4308 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj;
4310 wxPoint *arg1 = (wxPoint *) 0 ;
4311 int arg2 ;
4312 PyObject * obj0 = 0 ;
4313 PyObject * obj1 = 0 ;
4314 char *kwnames[] = {
4315 (char *) "self",(char *) "x", NULL
4316 };
4317
4318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4320 if (SWIG_arg_fail(1)) SWIG_fail;
4321 {
4322 arg2 = (int)(SWIG_As_int(obj1));
4323 if (SWIG_arg_fail(2)) SWIG_fail;
4324 }
4325 if (arg1) (arg1)->x = arg2;
4326
4327 Py_INCREF(Py_None); resultobj = Py_None;
4328 return resultobj;
4329 fail:
4330 return NULL;
4331 }
4332
4333
4334 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4335 PyObject *resultobj;
4336 wxPoint *arg1 = (wxPoint *) 0 ;
4337 int result;
4338 PyObject * obj0 = 0 ;
4339 char *kwnames[] = {
4340 (char *) "self", NULL
4341 };
4342
4343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4345 if (SWIG_arg_fail(1)) SWIG_fail;
4346 result = (int) ((arg1)->x);
4347
4348 {
4349 resultobj = SWIG_From_int((int)(result));
4350 }
4351 return resultobj;
4352 fail:
4353 return NULL;
4354 }
4355
4356
4357 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4358 PyObject *resultobj;
4359 wxPoint *arg1 = (wxPoint *) 0 ;
4360 int arg2 ;
4361 PyObject * obj0 = 0 ;
4362 PyObject * obj1 = 0 ;
4363 char *kwnames[] = {
4364 (char *) "self",(char *) "y", NULL
4365 };
4366
4367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4369 if (SWIG_arg_fail(1)) SWIG_fail;
4370 {
4371 arg2 = (int)(SWIG_As_int(obj1));
4372 if (SWIG_arg_fail(2)) SWIG_fail;
4373 }
4374 if (arg1) (arg1)->y = arg2;
4375
4376 Py_INCREF(Py_None); resultobj = Py_None;
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
4383 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj;
4385 wxPoint *arg1 = (wxPoint *) 0 ;
4386 int result;
4387 PyObject * obj0 = 0 ;
4388 char *kwnames[] = {
4389 (char *) "self", NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 result = (int) ((arg1)->y);
4396
4397 {
4398 resultobj = SWIG_From_int((int)(result));
4399 }
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4407 PyObject *resultobj;
4408 int arg1 = (int) 0 ;
4409 int arg2 = (int) 0 ;
4410 wxPoint *result;
4411 PyObject * obj0 = 0 ;
4412 PyObject * obj1 = 0 ;
4413 char *kwnames[] = {
4414 (char *) "x",(char *) "y", NULL
4415 };
4416
4417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4418 if (obj0) {
4419 {
4420 arg1 = (int)(SWIG_As_int(obj0));
4421 if (SWIG_arg_fail(1)) SWIG_fail;
4422 }
4423 }
4424 if (obj1) {
4425 {
4426 arg2 = (int)(SWIG_As_int(obj1));
4427 if (SWIG_arg_fail(2)) SWIG_fail;
4428 }
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = (wxPoint *)new wxPoint(arg1,arg2);
4433
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4445 PyObject *resultobj;
4446 wxPoint *arg1 = (wxPoint *) 0 ;
4447 PyObject * obj0 = 0 ;
4448 char *kwnames[] = {
4449 (char *) "self", NULL
4450 };
4451
4452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4454 if (SWIG_arg_fail(1)) SWIG_fail;
4455 {
4456 PyThreadState* __tstate = wxPyBeginAllowThreads();
4457 delete arg1;
4458
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 Py_INCREF(Py_None); resultobj = Py_None;
4463 return resultobj;
4464 fail:
4465 return NULL;
4466 }
4467
4468
4469 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4470 PyObject *resultobj;
4471 wxPoint *arg1 = (wxPoint *) 0 ;
4472 wxPoint *arg2 = 0 ;
4473 bool result;
4474 wxPoint temp2 ;
4475 PyObject * obj0 = 0 ;
4476 PyObject * obj1 = 0 ;
4477 char *kwnames[] = {
4478 (char *) "self",(char *) "pt", NULL
4479 };
4480
4481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4483 if (SWIG_arg_fail(1)) SWIG_fail;
4484 {
4485 arg2 = &temp2;
4486 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4487 }
4488 {
4489 PyThreadState* __tstate = wxPyBeginAllowThreads();
4490 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4491
4492 wxPyEndAllowThreads(__tstate);
4493 if (PyErr_Occurred()) SWIG_fail;
4494 }
4495 {
4496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4497 }
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj;
4506 wxPoint *arg1 = (wxPoint *) 0 ;
4507 wxPoint *arg2 = 0 ;
4508 bool result;
4509 wxPoint temp2 ;
4510 PyObject * obj0 = 0 ;
4511 PyObject * obj1 = 0 ;
4512 char *kwnames[] = {
4513 (char *) "self",(char *) "pt", NULL
4514 };
4515
4516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4518 if (SWIG_arg_fail(1)) SWIG_fail;
4519 {
4520 arg2 = &temp2;
4521 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4526
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj;
4541 wxPoint *arg1 = (wxPoint *) 0 ;
4542 wxPoint *arg2 = 0 ;
4543 wxPoint result;
4544 wxPoint temp2 ;
4545 PyObject * obj0 = 0 ;
4546 PyObject * obj1 = 0 ;
4547 char *kwnames[] = {
4548 (char *) "self",(char *) "pt", NULL
4549 };
4550
4551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4553 if (SWIG_arg_fail(1)) SWIG_fail;
4554 {
4555 arg2 = &temp2;
4556 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4557 }
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (arg1)->operator +((wxPoint const &)*arg2);
4561
4562 wxPyEndAllowThreads(__tstate);
4563 if (PyErr_Occurred()) SWIG_fail;
4564 }
4565 {
4566 wxPoint * resultptr;
4567 resultptr = new wxPoint((wxPoint &)(result));
4568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4569 }
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj;
4578 wxPoint *arg1 = (wxPoint *) 0 ;
4579 wxPoint *arg2 = 0 ;
4580 wxPoint result;
4581 wxPoint temp2 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char *kwnames[] = {
4585 (char *) "self",(char *) "pt", NULL
4586 };
4587
4588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4590 if (SWIG_arg_fail(1)) SWIG_fail;
4591 {
4592 arg2 = &temp2;
4593 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4594 }
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 result = (arg1)->operator -((wxPoint const &)*arg2);
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 {
4603 wxPoint * resultptr;
4604 resultptr = new wxPoint((wxPoint &)(result));
4605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4606 }
4607 return resultobj;
4608 fail:
4609 return NULL;
4610 }
4611
4612
4613 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4614 PyObject *resultobj;
4615 wxPoint *arg1 = (wxPoint *) 0 ;
4616 wxPoint *arg2 = 0 ;
4617 wxPoint *result;
4618 wxPoint temp2 ;
4619 PyObject * obj0 = 0 ;
4620 PyObject * obj1 = 0 ;
4621 char *kwnames[] = {
4622 (char *) "self",(char *) "pt", NULL
4623 };
4624
4625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4627 if (SWIG_arg_fail(1)) SWIG_fail;
4628 {
4629 arg2 = &temp2;
4630 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4631 }
4632 {
4633 PyThreadState* __tstate = wxPyBeginAllowThreads();
4634 {
4635 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4636 result = (wxPoint *) &_result_ref;
4637 }
4638
4639 wxPyEndAllowThreads(__tstate);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4643 return resultobj;
4644 fail:
4645 return NULL;
4646 }
4647
4648
4649 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4650 PyObject *resultobj;
4651 wxPoint *arg1 = (wxPoint *) 0 ;
4652 wxPoint *arg2 = 0 ;
4653 wxPoint *result;
4654 wxPoint temp2 ;
4655 PyObject * obj0 = 0 ;
4656 PyObject * obj1 = 0 ;
4657 char *kwnames[] = {
4658 (char *) "self",(char *) "pt", NULL
4659 };
4660
4661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4663 if (SWIG_arg_fail(1)) SWIG_fail;
4664 {
4665 arg2 = &temp2;
4666 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4667 }
4668 {
4669 PyThreadState* __tstate = wxPyBeginAllowThreads();
4670 {
4671 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4672 result = (wxPoint *) &_result_ref;
4673 }
4674
4675 wxPyEndAllowThreads(__tstate);
4676 if (PyErr_Occurred()) SWIG_fail;
4677 }
4678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4679 return resultobj;
4680 fail:
4681 return NULL;
4682 }
4683
4684
4685 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4686 PyObject *resultobj;
4687 wxPoint *arg1 = (wxPoint *) 0 ;
4688 long arg2 ;
4689 long arg3 ;
4690 PyObject * obj0 = 0 ;
4691 PyObject * obj1 = 0 ;
4692 PyObject * obj2 = 0 ;
4693 char *kwnames[] = {
4694 (char *) "self",(char *) "x",(char *) "y", NULL
4695 };
4696
4697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4699 if (SWIG_arg_fail(1)) SWIG_fail;
4700 {
4701 arg2 = (long)(SWIG_As_long(obj1));
4702 if (SWIG_arg_fail(2)) SWIG_fail;
4703 }
4704 {
4705 arg3 = (long)(SWIG_As_long(obj2));
4706 if (SWIG_arg_fail(3)) SWIG_fail;
4707 }
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 wxPoint_Set(arg1,arg2,arg3);
4711
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 Py_INCREF(Py_None); resultobj = Py_None;
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj;
4724 wxPoint *arg1 = (wxPoint *) 0 ;
4725 PyObject *result;
4726 PyObject * obj0 = 0 ;
4727 char *kwnames[] = {
4728 (char *) "self", NULL
4729 };
4730
4731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4733 if (SWIG_arg_fail(1)) SWIG_fail;
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (PyObject *)wxPoint_Get(arg1);
4737
4738 wxPyEndAllowThreads(__tstate);
4739 if (PyErr_Occurred()) SWIG_fail;
4740 }
4741 resultobj = result;
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4749 PyObject *obj;
4750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4751 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4752 Py_INCREF(obj);
4753 return Py_BuildValue((char *)"");
4754 }
4755 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj;
4757 int arg1 = (int) 0 ;
4758 int arg2 = (int) 0 ;
4759 int arg3 = (int) 0 ;
4760 int arg4 = (int) 0 ;
4761 wxRect *result;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 PyObject * obj2 = 0 ;
4765 PyObject * obj3 = 0 ;
4766 char *kwnames[] = {
4767 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4768 };
4769
4770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4771 if (obj0) {
4772 {
4773 arg1 = (int)(SWIG_As_int(obj0));
4774 if (SWIG_arg_fail(1)) SWIG_fail;
4775 }
4776 }
4777 if (obj1) {
4778 {
4779 arg2 = (int)(SWIG_As_int(obj1));
4780 if (SWIG_arg_fail(2)) SWIG_fail;
4781 }
4782 }
4783 if (obj2) {
4784 {
4785 arg3 = (int)(SWIG_As_int(obj2));
4786 if (SWIG_arg_fail(3)) SWIG_fail;
4787 }
4788 }
4789 if (obj3) {
4790 {
4791 arg4 = (int)(SWIG_As_int(obj3));
4792 if (SWIG_arg_fail(4)) SWIG_fail;
4793 }
4794 }
4795 {
4796 PyThreadState* __tstate = wxPyBeginAllowThreads();
4797 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4798
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj;
4811 wxPoint *arg1 = 0 ;
4812 wxPoint *arg2 = 0 ;
4813 wxRect *result;
4814 wxPoint temp1 ;
4815 wxPoint temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char *kwnames[] = {
4819 (char *) "topLeft",(char *) "bottomRight", NULL
4820 };
4821
4822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4823 {
4824 arg1 = &temp1;
4825 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4826 }
4827 {
4828 arg2 = &temp2;
4829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4830 }
4831 {
4832 PyThreadState* __tstate = wxPyBeginAllowThreads();
4833 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4834
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj;
4847 wxPoint *arg1 = 0 ;
4848 wxSize *arg2 = 0 ;
4849 wxRect *result;
4850 wxPoint temp1 ;
4851 wxSize temp2 ;
4852 PyObject * obj0 = 0 ;
4853 PyObject * obj1 = 0 ;
4854 char *kwnames[] = {
4855 (char *) "pos",(char *) "size", NULL
4856 };
4857
4858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4859 {
4860 arg1 = &temp1;
4861 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4862 }
4863 {
4864 arg2 = &temp2;
4865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4866 }
4867 {
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4870
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj;
4883 wxSize *arg1 = 0 ;
4884 wxRect *result;
4885 wxSize temp1 ;
4886 PyObject * obj0 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "size", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4892 {
4893 arg1 = &temp1;
4894 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4895 }
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxRect *arg1 = (wxRect *) 0 ;
4913 PyObject * obj0 = 0 ;
4914 char *kwnames[] = {
4915 (char *) "self", NULL
4916 };
4917
4918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4920 if (SWIG_arg_fail(1)) SWIG_fail;
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 delete arg1;
4924
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 Py_INCREF(Py_None); resultobj = Py_None;
4929 return resultobj;
4930 fail:
4931 return NULL;
4932 }
4933
4934
4935 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4936 PyObject *resultobj;
4937 wxRect *arg1 = (wxRect *) 0 ;
4938 int result;
4939 PyObject * obj0 = 0 ;
4940 char *kwnames[] = {
4941 (char *) "self", NULL
4942 };
4943
4944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4946 if (SWIG_arg_fail(1)) SWIG_fail;
4947 {
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (int)((wxRect const *)arg1)->GetX();
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 {
4955 resultobj = SWIG_From_int((int)(result));
4956 }
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj;
4965 wxRect *arg1 = (wxRect *) 0 ;
4966 int arg2 ;
4967 PyObject * obj0 = 0 ;
4968 PyObject * obj1 = 0 ;
4969 char *kwnames[] = {
4970 (char *) "self",(char *) "x", NULL
4971 };
4972
4973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4975 if (SWIG_arg_fail(1)) SWIG_fail;
4976 {
4977 arg2 = (int)(SWIG_As_int(obj1));
4978 if (SWIG_arg_fail(2)) SWIG_fail;
4979 }
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 (arg1)->SetX(arg2);
4983
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 Py_INCREF(Py_None); resultobj = Py_None;
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxRect *arg1 = (wxRect *) 0 ;
4997 int result;
4998 PyObject * obj0 = 0 ;
4999 char *kwnames[] = {
5000 (char *) "self", NULL
5001 };
5002
5003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5005 if (SWIG_arg_fail(1)) SWIG_fail;
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = (int)(arg1)->GetY();
5009
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 {
5014 resultobj = SWIG_From_int((int)(result));
5015 }
5016 return resultobj;
5017 fail:
5018 return NULL;
5019 }
5020
5021
5022 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj;
5024 wxRect *arg1 = (wxRect *) 0 ;
5025 int arg2 ;
5026 PyObject * obj0 = 0 ;
5027 PyObject * obj1 = 0 ;
5028 char *kwnames[] = {
5029 (char *) "self",(char *) "y", NULL
5030 };
5031
5032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5034 if (SWIG_arg_fail(1)) SWIG_fail;
5035 {
5036 arg2 = (int)(SWIG_As_int(obj1));
5037 if (SWIG_arg_fail(2)) SWIG_fail;
5038 }
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 (arg1)->SetY(arg2);
5042
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 Py_INCREF(Py_None); resultobj = Py_None;
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5054 PyObject *resultobj;
5055 wxRect *arg1 = (wxRect *) 0 ;
5056 int result;
5057 PyObject * obj0 = 0 ;
5058 char *kwnames[] = {
5059 (char *) "self", NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5064 if (SWIG_arg_fail(1)) SWIG_fail;
5065 {
5066 PyThreadState* __tstate = wxPyBeginAllowThreads();
5067 result = (int)((wxRect const *)arg1)->GetWidth();
5068
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 {
5073 resultobj = SWIG_From_int((int)(result));
5074 }
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj;
5083 wxRect *arg1 = (wxRect *) 0 ;
5084 int arg2 ;
5085 PyObject * obj0 = 0 ;
5086 PyObject * obj1 = 0 ;
5087 char *kwnames[] = {
5088 (char *) "self",(char *) "w", NULL
5089 };
5090
5091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5093 if (SWIG_arg_fail(1)) SWIG_fail;
5094 {
5095 arg2 = (int)(SWIG_As_int(obj1));
5096 if (SWIG_arg_fail(2)) SWIG_fail;
5097 }
5098 {
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 (arg1)->SetWidth(arg2);
5101
5102 wxPyEndAllowThreads(__tstate);
5103 if (PyErr_Occurred()) SWIG_fail;
5104 }
5105 Py_INCREF(Py_None); resultobj = Py_None;
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj;
5114 wxRect *arg1 = (wxRect *) 0 ;
5115 int result;
5116 PyObject * obj0 = 0 ;
5117 char *kwnames[] = {
5118 (char *) "self", NULL
5119 };
5120
5121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 {
5125 PyThreadState* __tstate = wxPyBeginAllowThreads();
5126 result = (int)((wxRect const *)arg1)->GetHeight();
5127
5128 wxPyEndAllowThreads(__tstate);
5129 if (PyErr_Occurred()) SWIG_fail;
5130 }
5131 {
5132 resultobj = SWIG_From_int((int)(result));
5133 }
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5141 PyObject *resultobj;
5142 wxRect *arg1 = (wxRect *) 0 ;
5143 int arg2 ;
5144 PyObject * obj0 = 0 ;
5145 PyObject * obj1 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "self",(char *) "h", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5152 if (SWIG_arg_fail(1)) SWIG_fail;
5153 {
5154 arg2 = (int)(SWIG_As_int(obj1));
5155 if (SWIG_arg_fail(2)) SWIG_fail;
5156 }
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 (arg1)->SetHeight(arg2);
5160
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 Py_INCREF(Py_None); resultobj = Py_None;
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5172 PyObject *resultobj;
5173 wxRect *arg1 = (wxRect *) 0 ;
5174 wxPoint result;
5175 PyObject * obj0 = 0 ;
5176 char *kwnames[] = {
5177 (char *) "self", NULL
5178 };
5179
5180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5182 if (SWIG_arg_fail(1)) SWIG_fail;
5183 {
5184 PyThreadState* __tstate = wxPyBeginAllowThreads();
5185 result = ((wxRect const *)arg1)->GetPosition();
5186
5187 wxPyEndAllowThreads(__tstate);
5188 if (PyErr_Occurred()) SWIG_fail;
5189 }
5190 {
5191 wxPoint * resultptr;
5192 resultptr = new wxPoint((wxPoint &)(result));
5193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5194 }
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5202 PyObject *resultobj;
5203 wxRect *arg1 = (wxRect *) 0 ;
5204 wxPoint *arg2 = 0 ;
5205 wxPoint temp2 ;
5206 PyObject * obj0 = 0 ;
5207 PyObject * obj1 = 0 ;
5208 char *kwnames[] = {
5209 (char *) "self",(char *) "p", NULL
5210 };
5211
5212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5214 if (SWIG_arg_fail(1)) SWIG_fail;
5215 {
5216 arg2 = &temp2;
5217 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5218 }
5219 {
5220 PyThreadState* __tstate = wxPyBeginAllowThreads();
5221 (arg1)->SetPosition((wxPoint const &)*arg2);
5222
5223 wxPyEndAllowThreads(__tstate);
5224 if (PyErr_Occurred()) SWIG_fail;
5225 }
5226 Py_INCREF(Py_None); resultobj = Py_None;
5227 return resultobj;
5228 fail:
5229 return NULL;
5230 }
5231
5232
5233 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5234 PyObject *resultobj;
5235 wxRect *arg1 = (wxRect *) 0 ;
5236 wxSize result;
5237 PyObject * obj0 = 0 ;
5238 char *kwnames[] = {
5239 (char *) "self", NULL
5240 };
5241
5242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5244 if (SWIG_arg_fail(1)) SWIG_fail;
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 result = ((wxRect const *)arg1)->GetSize();
5248
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 {
5253 wxSize * resultptr;
5254 resultptr = new wxSize((wxSize &)(result));
5255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5256 }
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj;
5265 wxRect *arg1 = (wxRect *) 0 ;
5266 wxSize *arg2 = 0 ;
5267 wxSize temp2 ;
5268 PyObject * obj0 = 0 ;
5269 PyObject * obj1 = 0 ;
5270 char *kwnames[] = {
5271 (char *) "self",(char *) "s", NULL
5272 };
5273
5274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5276 if (SWIG_arg_fail(1)) SWIG_fail;
5277 {
5278 arg2 = &temp2;
5279 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5280 }
5281 {
5282 PyThreadState* __tstate = wxPyBeginAllowThreads();
5283 (arg1)->SetSize((wxSize const &)*arg2);
5284
5285 wxPyEndAllowThreads(__tstate);
5286 if (PyErr_Occurred()) SWIG_fail;
5287 }
5288 Py_INCREF(Py_None); resultobj = Py_None;
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5296 PyObject *resultobj;
5297 wxRect *arg1 = (wxRect *) 0 ;
5298 wxPoint result;
5299 PyObject * obj0 = 0 ;
5300 char *kwnames[] = {
5301 (char *) "self", NULL
5302 };
5303
5304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5306 if (SWIG_arg_fail(1)) SWIG_fail;
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 result = ((wxRect const *)arg1)->GetTopLeft();
5310
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 {
5315 wxPoint * resultptr;
5316 resultptr = new wxPoint((wxPoint &)(result));
5317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5318 }
5319 return resultobj;
5320 fail:
5321 return NULL;
5322 }
5323
5324
5325 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5326 PyObject *resultobj;
5327 wxRect *arg1 = (wxRect *) 0 ;
5328 wxPoint *arg2 = 0 ;
5329 wxPoint temp2 ;
5330 PyObject * obj0 = 0 ;
5331 PyObject * obj1 = 0 ;
5332 char *kwnames[] = {
5333 (char *) "self",(char *) "p", NULL
5334 };
5335
5336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5338 if (SWIG_arg_fail(1)) SWIG_fail;
5339 {
5340 arg2 = &temp2;
5341 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5342 }
5343 {
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5346
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 Py_INCREF(Py_None); resultobj = Py_None;
5351 return resultobj;
5352 fail:
5353 return NULL;
5354 }
5355
5356
5357 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5358 PyObject *resultobj;
5359 wxRect *arg1 = (wxRect *) 0 ;
5360 wxPoint result;
5361 PyObject * obj0 = 0 ;
5362 char *kwnames[] = {
5363 (char *) "self", NULL
5364 };
5365
5366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5368 if (SWIG_arg_fail(1)) SWIG_fail;
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 result = ((wxRect const *)arg1)->GetBottomRight();
5372
5373 wxPyEndAllowThreads(__tstate);
5374 if (PyErr_Occurred()) SWIG_fail;
5375 }
5376 {
5377 wxPoint * resultptr;
5378 resultptr = new wxPoint((wxPoint &)(result));
5379 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5380 }
5381 return resultobj;
5382 fail:
5383 return NULL;
5384 }
5385
5386
5387 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5388 PyObject *resultobj;
5389 wxRect *arg1 = (wxRect *) 0 ;
5390 wxPoint *arg2 = 0 ;
5391 wxPoint temp2 ;
5392 PyObject * obj0 = 0 ;
5393 PyObject * obj1 = 0 ;
5394 char *kwnames[] = {
5395 (char *) "self",(char *) "p", NULL
5396 };
5397
5398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5400 if (SWIG_arg_fail(1)) SWIG_fail;
5401 {
5402 arg2 = &temp2;
5403 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5404 }
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5408
5409 wxPyEndAllowThreads(__tstate);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 Py_INCREF(Py_None); resultobj = Py_None;
5413 return resultobj;
5414 fail:
5415 return NULL;
5416 }
5417
5418
5419 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5420 PyObject *resultobj;
5421 wxRect *arg1 = (wxRect *) 0 ;
5422 int result;
5423 PyObject * obj0 = 0 ;
5424 char *kwnames[] = {
5425 (char *) "self", NULL
5426 };
5427
5428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5430 if (SWIG_arg_fail(1)) SWIG_fail;
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (int)((wxRect const *)arg1)->GetLeft();
5434
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 {
5439 resultobj = SWIG_From_int((int)(result));
5440 }
5441 return resultobj;
5442 fail:
5443 return NULL;
5444 }
5445
5446
5447 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5448 PyObject *resultobj;
5449 wxRect *arg1 = (wxRect *) 0 ;
5450 int result;
5451 PyObject * obj0 = 0 ;
5452 char *kwnames[] = {
5453 (char *) "self", NULL
5454 };
5455
5456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5458 if (SWIG_arg_fail(1)) SWIG_fail;
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 result = (int)((wxRect const *)arg1)->GetTop();
5462
5463 wxPyEndAllowThreads(__tstate);
5464 if (PyErr_Occurred()) SWIG_fail;
5465 }
5466 {
5467 resultobj = SWIG_From_int((int)(result));
5468 }
5469 return resultobj;
5470 fail:
5471 return NULL;
5472 }
5473
5474
5475 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5476 PyObject *resultobj;
5477 wxRect *arg1 = (wxRect *) 0 ;
5478 int result;
5479 PyObject * obj0 = 0 ;
5480 char *kwnames[] = {
5481 (char *) "self", NULL
5482 };
5483
5484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5486 if (SWIG_arg_fail(1)) SWIG_fail;
5487 {
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = (int)((wxRect const *)arg1)->GetBottom();
5490
5491 wxPyEndAllowThreads(__tstate);
5492 if (PyErr_Occurred()) SWIG_fail;
5493 }
5494 {
5495 resultobj = SWIG_From_int((int)(result));
5496 }
5497 return resultobj;
5498 fail:
5499 return NULL;
5500 }
5501
5502
5503 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5504 PyObject *resultobj;
5505 wxRect *arg1 = (wxRect *) 0 ;
5506 int result;
5507 PyObject * obj0 = 0 ;
5508 char *kwnames[] = {
5509 (char *) "self", NULL
5510 };
5511
5512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5514 if (SWIG_arg_fail(1)) SWIG_fail;
5515 {
5516 PyThreadState* __tstate = wxPyBeginAllowThreads();
5517 result = (int)((wxRect const *)arg1)->GetRight();
5518
5519 wxPyEndAllowThreads(__tstate);
5520 if (PyErr_Occurred()) SWIG_fail;
5521 }
5522 {
5523 resultobj = SWIG_From_int((int)(result));
5524 }
5525 return resultobj;
5526 fail:
5527 return NULL;
5528 }
5529
5530
5531 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5532 PyObject *resultobj;
5533 wxRect *arg1 = (wxRect *) 0 ;
5534 int arg2 ;
5535 PyObject * obj0 = 0 ;
5536 PyObject * obj1 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self",(char *) "left", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5543 if (SWIG_arg_fail(1)) SWIG_fail;
5544 {
5545 arg2 = (int)(SWIG_As_int(obj1));
5546 if (SWIG_arg_fail(2)) SWIG_fail;
5547 }
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 (arg1)->SetLeft(arg2);
5551
5552 wxPyEndAllowThreads(__tstate);
5553 if (PyErr_Occurred()) SWIG_fail;
5554 }
5555 Py_INCREF(Py_None); resultobj = Py_None;
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 int arg2 ;
5566 PyObject * obj0 = 0 ;
5567 PyObject * obj1 = 0 ;
5568 char *kwnames[] = {
5569 (char *) "self",(char *) "right", NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5574 if (SWIG_arg_fail(1)) SWIG_fail;
5575 {
5576 arg2 = (int)(SWIG_As_int(obj1));
5577 if (SWIG_arg_fail(2)) SWIG_fail;
5578 }
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 (arg1)->SetRight(arg2);
5582
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 Py_INCREF(Py_None); resultobj = Py_None;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5594 PyObject *resultobj;
5595 wxRect *arg1 = (wxRect *) 0 ;
5596 int arg2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self",(char *) "top", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 arg2 = (int)(SWIG_As_int(obj1));
5608 if (SWIG_arg_fail(2)) SWIG_fail;
5609 }
5610 {
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 (arg1)->SetTop(arg2);
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 Py_INCREF(Py_None); resultobj = Py_None;
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxRect *arg1 = (wxRect *) 0 ;
5627 int arg2 ;
5628 PyObject * obj0 = 0 ;
5629 PyObject * obj1 = 0 ;
5630 char *kwnames[] = {
5631 (char *) "self",(char *) "bottom", NULL
5632 };
5633
5634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5636 if (SWIG_arg_fail(1)) SWIG_fail;
5637 {
5638 arg2 = (int)(SWIG_As_int(obj1));
5639 if (SWIG_arg_fail(2)) SWIG_fail;
5640 }
5641 {
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 (arg1)->SetBottom(arg2);
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 Py_INCREF(Py_None); resultobj = Py_None;
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxRect *arg1 = (wxRect *) 0 ;
5658 int arg2 ;
5659 int arg3 ;
5660 wxRect *result;
5661 PyObject * obj0 = 0 ;
5662 PyObject * obj1 = 0 ;
5663 PyObject * obj2 = 0 ;
5664 char *kwnames[] = {
5665 (char *) "self",(char *) "dx",(char *) "dy", NULL
5666 };
5667
5668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5670 if (SWIG_arg_fail(1)) SWIG_fail;
5671 {
5672 arg2 = (int)(SWIG_As_int(obj1));
5673 if (SWIG_arg_fail(2)) SWIG_fail;
5674 }
5675 {
5676 arg3 = (int)(SWIG_As_int(obj2));
5677 if (SWIG_arg_fail(3)) SWIG_fail;
5678 }
5679 {
5680 PyThreadState* __tstate = wxPyBeginAllowThreads();
5681 {
5682 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5683 result = (wxRect *) &_result_ref;
5684 }
5685
5686 wxPyEndAllowThreads(__tstate);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5690 return resultobj;
5691 fail:
5692 return NULL;
5693 }
5694
5695
5696 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5697 PyObject *resultobj;
5698 wxRect *arg1 = (wxRect *) 0 ;
5699 int arg2 ;
5700 int arg3 ;
5701 wxRect *result;
5702 PyObject * obj0 = 0 ;
5703 PyObject * obj1 = 0 ;
5704 PyObject * obj2 = 0 ;
5705 char *kwnames[] = {
5706 (char *) "self",(char *) "dx",(char *) "dy", NULL
5707 };
5708
5709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5711 if (SWIG_arg_fail(1)) SWIG_fail;
5712 {
5713 arg2 = (int)(SWIG_As_int(obj1));
5714 if (SWIG_arg_fail(2)) SWIG_fail;
5715 }
5716 {
5717 arg3 = (int)(SWIG_As_int(obj2));
5718 if (SWIG_arg_fail(3)) SWIG_fail;
5719 }
5720 {
5721 PyThreadState* __tstate = wxPyBeginAllowThreads();
5722 {
5723 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5724 result = (wxRect *) &_result_ref;
5725 }
5726
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5738 PyObject *resultobj;
5739 wxRect *arg1 = (wxRect *) 0 ;
5740 int arg2 ;
5741 int arg3 ;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 PyObject * obj2 = 0 ;
5745 char *kwnames[] = {
5746 (char *) "self",(char *) "dx",(char *) "dy", NULL
5747 };
5748
5749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5751 if (SWIG_arg_fail(1)) SWIG_fail;
5752 {
5753 arg2 = (int)(SWIG_As_int(obj1));
5754 if (SWIG_arg_fail(2)) SWIG_fail;
5755 }
5756 {
5757 arg3 = (int)(SWIG_As_int(obj2));
5758 if (SWIG_arg_fail(3)) SWIG_fail;
5759 }
5760 {
5761 PyThreadState* __tstate = wxPyBeginAllowThreads();
5762 (arg1)->Offset(arg2,arg3);
5763
5764 wxPyEndAllowThreads(__tstate);
5765 if (PyErr_Occurred()) SWIG_fail;
5766 }
5767 Py_INCREF(Py_None); resultobj = Py_None;
5768 return resultobj;
5769 fail:
5770 return NULL;
5771 }
5772
5773
5774 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5775 PyObject *resultobj;
5776 wxRect *arg1 = (wxRect *) 0 ;
5777 wxPoint *arg2 = 0 ;
5778 wxPoint temp2 ;
5779 PyObject * obj0 = 0 ;
5780 PyObject * obj1 = 0 ;
5781 char *kwnames[] = {
5782 (char *) "self",(char *) "pt", NULL
5783 };
5784
5785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5787 if (SWIG_arg_fail(1)) SWIG_fail;
5788 {
5789 arg2 = &temp2;
5790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5791 }
5792 {
5793 PyThreadState* __tstate = wxPyBeginAllowThreads();
5794 (arg1)->Offset((wxPoint const &)*arg2);
5795
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 Py_INCREF(Py_None); resultobj = Py_None;
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj;
5808 wxRect *arg1 = (wxRect *) 0 ;
5809 wxRect *arg2 = 0 ;
5810 wxRect result;
5811 wxRect temp2 ;
5812 PyObject * obj0 = 0 ;
5813 PyObject * obj1 = 0 ;
5814 char *kwnames[] = {
5815 (char *) "self",(char *) "rect", NULL
5816 };
5817
5818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5820 if (SWIG_arg_fail(1)) SWIG_fail;
5821 {
5822 arg2 = &temp2;
5823 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5824 }
5825 {
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = (arg1)->Intersect((wxRect const &)*arg2);
5828
5829 wxPyEndAllowThreads(__tstate);
5830 if (PyErr_Occurred()) SWIG_fail;
5831 }
5832 {
5833 wxRect * resultptr;
5834 resultptr = new wxRect((wxRect &)(result));
5835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5836 }
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj;
5845 wxRect *arg1 = (wxRect *) 0 ;
5846 wxRect *arg2 = 0 ;
5847 wxRect result;
5848 wxRect temp2 ;
5849 PyObject * obj0 = 0 ;
5850 PyObject * obj1 = 0 ;
5851 char *kwnames[] = {
5852 (char *) "self",(char *) "rect", NULL
5853 };
5854
5855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5857 if (SWIG_arg_fail(1)) SWIG_fail;
5858 {
5859 arg2 = &temp2;
5860 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5861 }
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 result = (arg1)->Union((wxRect const &)*arg2);
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 {
5870 wxRect * resultptr;
5871 resultptr = new wxRect((wxRect &)(result));
5872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5873 }
5874 return resultobj;
5875 fail:
5876 return NULL;
5877 }
5878
5879
5880 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5881 PyObject *resultobj;
5882 wxRect *arg1 = (wxRect *) 0 ;
5883 wxRect *arg2 = 0 ;
5884 wxRect result;
5885 wxRect temp2 ;
5886 PyObject * obj0 = 0 ;
5887 PyObject * obj1 = 0 ;
5888 char *kwnames[] = {
5889 (char *) "self",(char *) "rect", NULL
5890 };
5891
5892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5894 if (SWIG_arg_fail(1)) SWIG_fail;
5895 {
5896 arg2 = &temp2;
5897 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5898 }
5899 {
5900 PyThreadState* __tstate = wxPyBeginAllowThreads();
5901 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5902
5903 wxPyEndAllowThreads(__tstate);
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 {
5907 wxRect * resultptr;
5908 resultptr = new wxRect((wxRect &)(result));
5909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5910 }
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj;
5919 wxRect *arg1 = (wxRect *) 0 ;
5920 wxRect *arg2 = 0 ;
5921 wxRect *result;
5922 wxRect temp2 ;
5923 PyObject * obj0 = 0 ;
5924 PyObject * obj1 = 0 ;
5925 char *kwnames[] = {
5926 (char *) "self",(char *) "rect", NULL
5927 };
5928
5929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5931 if (SWIG_arg_fail(1)) SWIG_fail;
5932 {
5933 arg2 = &temp2;
5934 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5935 }
5936 {
5937 PyThreadState* __tstate = wxPyBeginAllowThreads();
5938 {
5939 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5940 result = (wxRect *) &_result_ref;
5941 }
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj;
5955 wxRect *arg1 = (wxRect *) 0 ;
5956 wxRect *arg2 = 0 ;
5957 bool result;
5958 wxRect temp2 ;
5959 PyObject * obj0 = 0 ;
5960 PyObject * obj1 = 0 ;
5961 char *kwnames[] = {
5962 (char *) "self",(char *) "rect", NULL
5963 };
5964
5965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5967 if (SWIG_arg_fail(1)) SWIG_fail;
5968 {
5969 arg2 = &temp2;
5970 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5971 }
5972 {
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5975
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 {
5980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5981 }
5982 return resultobj;
5983 fail:
5984 return NULL;
5985 }
5986
5987
5988 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5989 PyObject *resultobj;
5990 wxRect *arg1 = (wxRect *) 0 ;
5991 wxRect *arg2 = 0 ;
5992 bool result;
5993 wxRect temp2 ;
5994 PyObject * obj0 = 0 ;
5995 PyObject * obj1 = 0 ;
5996 char *kwnames[] = {
5997 (char *) "self",(char *) "rect", NULL
5998 };
5999
6000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6002 if (SWIG_arg_fail(1)) SWIG_fail;
6003 {
6004 arg2 = &temp2;
6005 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6006 }
6007 {
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6010
6011 wxPyEndAllowThreads(__tstate);
6012 if (PyErr_Occurred()) SWIG_fail;
6013 }
6014 {
6015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6016 }
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 wxRect *arg1 = (wxRect *) 0 ;
6026 int arg2 ;
6027 int arg3 ;
6028 bool result;
6029 PyObject * obj0 = 0 ;
6030 PyObject * obj1 = 0 ;
6031 PyObject * obj2 = 0 ;
6032 char *kwnames[] = {
6033 (char *) "self",(char *) "x",(char *) "y", NULL
6034 };
6035
6036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6038 if (SWIG_arg_fail(1)) SWIG_fail;
6039 {
6040 arg2 = (int)(SWIG_As_int(obj1));
6041 if (SWIG_arg_fail(2)) SWIG_fail;
6042 }
6043 {
6044 arg3 = (int)(SWIG_As_int(obj2));
6045 if (SWIG_arg_fail(3)) SWIG_fail;
6046 }
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 {
6055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6056 }
6057 return resultobj;
6058 fail:
6059 return NULL;
6060 }
6061
6062
6063 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6064 PyObject *resultobj;
6065 wxRect *arg1 = (wxRect *) 0 ;
6066 wxPoint *arg2 = 0 ;
6067 bool result;
6068 wxPoint temp2 ;
6069 PyObject * obj0 = 0 ;
6070 PyObject * obj1 = 0 ;
6071 char *kwnames[] = {
6072 (char *) "self",(char *) "pt", NULL
6073 };
6074
6075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6077 if (SWIG_arg_fail(1)) SWIG_fail;
6078 {
6079 arg2 = &temp2;
6080 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6081 }
6082 {
6083 PyThreadState* __tstate = wxPyBeginAllowThreads();
6084 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6085
6086 wxPyEndAllowThreads(__tstate);
6087 if (PyErr_Occurred()) SWIG_fail;
6088 }
6089 {
6090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6091 }
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj;
6100 wxRect *arg1 = (wxRect *) 0 ;
6101 wxRect *arg2 = 0 ;
6102 bool result;
6103 wxRect temp2 ;
6104 PyObject * obj0 = 0 ;
6105 PyObject * obj1 = 0 ;
6106 char *kwnames[] = {
6107 (char *) "self",(char *) "rect", NULL
6108 };
6109
6110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6112 if (SWIG_arg_fail(1)) SWIG_fail;
6113 {
6114 arg2 = &temp2;
6115 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6116 }
6117 {
6118 PyThreadState* __tstate = wxPyBeginAllowThreads();
6119 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6120
6121 wxPyEndAllowThreads(__tstate);
6122 if (PyErr_Occurred()) SWIG_fail;
6123 }
6124 {
6125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6126 }
6127 return resultobj;
6128 fail:
6129 return NULL;
6130 }
6131
6132
6133 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6134 PyObject *resultobj;
6135 wxRect *arg1 = (wxRect *) 0 ;
6136 int arg2 ;
6137 PyObject * obj0 = 0 ;
6138 PyObject * obj1 = 0 ;
6139 char *kwnames[] = {
6140 (char *) "self",(char *) "x", NULL
6141 };
6142
6143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6145 if (SWIG_arg_fail(1)) SWIG_fail;
6146 {
6147 arg2 = (int)(SWIG_As_int(obj1));
6148 if (SWIG_arg_fail(2)) SWIG_fail;
6149 }
6150 if (arg1) (arg1)->x = arg2;
6151
6152 Py_INCREF(Py_None); resultobj = Py_None;
6153 return resultobj;
6154 fail:
6155 return NULL;
6156 }
6157
6158
6159 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj;
6161 wxRect *arg1 = (wxRect *) 0 ;
6162 int result;
6163 PyObject * obj0 = 0 ;
6164 char *kwnames[] = {
6165 (char *) "self", NULL
6166 };
6167
6168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6170 if (SWIG_arg_fail(1)) SWIG_fail;
6171 result = (int) ((arg1)->x);
6172
6173 {
6174 resultobj = SWIG_From_int((int)(result));
6175 }
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj;
6184 wxRect *arg1 = (wxRect *) 0 ;
6185 int arg2 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self",(char *) "y", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 {
6196 arg2 = (int)(SWIG_As_int(obj1));
6197 if (SWIG_arg_fail(2)) SWIG_fail;
6198 }
6199 if (arg1) (arg1)->y = arg2;
6200
6201 Py_INCREF(Py_None); resultobj = Py_None;
6202 return resultobj;
6203 fail:
6204 return NULL;
6205 }
6206
6207
6208 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj;
6210 wxRect *arg1 = (wxRect *) 0 ;
6211 int result;
6212 PyObject * obj0 = 0 ;
6213 char *kwnames[] = {
6214 (char *) "self", NULL
6215 };
6216
6217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6219 if (SWIG_arg_fail(1)) SWIG_fail;
6220 result = (int) ((arg1)->y);
6221
6222 {
6223 resultobj = SWIG_From_int((int)(result));
6224 }
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6232 PyObject *resultobj;
6233 wxRect *arg1 = (wxRect *) 0 ;
6234 int arg2 ;
6235 PyObject * obj0 = 0 ;
6236 PyObject * obj1 = 0 ;
6237 char *kwnames[] = {
6238 (char *) "self",(char *) "width", NULL
6239 };
6240
6241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6243 if (SWIG_arg_fail(1)) SWIG_fail;
6244 {
6245 arg2 = (int)(SWIG_As_int(obj1));
6246 if (SWIG_arg_fail(2)) SWIG_fail;
6247 }
6248 if (arg1) (arg1)->width = arg2;
6249
6250 Py_INCREF(Py_None); resultobj = Py_None;
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6258 PyObject *resultobj;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int result;
6261 PyObject * obj0 = 0 ;
6262 char *kwnames[] = {
6263 (char *) "self", NULL
6264 };
6265
6266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6268 if (SWIG_arg_fail(1)) SWIG_fail;
6269 result = (int) ((arg1)->width);
6270
6271 {
6272 resultobj = SWIG_From_int((int)(result));
6273 }
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
6280 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj;
6282 wxRect *arg1 = (wxRect *) 0 ;
6283 int arg2 ;
6284 PyObject * obj0 = 0 ;
6285 PyObject * obj1 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "self",(char *) "height", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 {
6294 arg2 = (int)(SWIG_As_int(obj1));
6295 if (SWIG_arg_fail(2)) SWIG_fail;
6296 }
6297 if (arg1) (arg1)->height = arg2;
6298
6299 Py_INCREF(Py_None); resultobj = Py_None;
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int result;
6310 PyObject * obj0 = 0 ;
6311 char *kwnames[] = {
6312 (char *) "self", NULL
6313 };
6314
6315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6317 if (SWIG_arg_fail(1)) SWIG_fail;
6318 result = (int) ((arg1)->height);
6319
6320 {
6321 resultobj = SWIG_From_int((int)(result));
6322 }
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6330 PyObject *resultobj;
6331 wxRect *arg1 = (wxRect *) 0 ;
6332 int arg2 = (int) 0 ;
6333 int arg3 = (int) 0 ;
6334 int arg4 = (int) 0 ;
6335 int arg5 = (int) 0 ;
6336 PyObject * obj0 = 0 ;
6337 PyObject * obj1 = 0 ;
6338 PyObject * obj2 = 0 ;
6339 PyObject * obj3 = 0 ;
6340 PyObject * obj4 = 0 ;
6341 char *kwnames[] = {
6342 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6343 };
6344
6345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6347 if (SWIG_arg_fail(1)) SWIG_fail;
6348 if (obj1) {
6349 {
6350 arg2 = (int)(SWIG_As_int(obj1));
6351 if (SWIG_arg_fail(2)) SWIG_fail;
6352 }
6353 }
6354 if (obj2) {
6355 {
6356 arg3 = (int)(SWIG_As_int(obj2));
6357 if (SWIG_arg_fail(3)) SWIG_fail;
6358 }
6359 }
6360 if (obj3) {
6361 {
6362 arg4 = (int)(SWIG_As_int(obj3));
6363 if (SWIG_arg_fail(4)) SWIG_fail;
6364 }
6365 }
6366 if (obj4) {
6367 {
6368 arg5 = (int)(SWIG_As_int(obj4));
6369 if (SWIG_arg_fail(5)) SWIG_fail;
6370 }
6371 }
6372 {
6373 PyThreadState* __tstate = wxPyBeginAllowThreads();
6374 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6375
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 Py_INCREF(Py_None); resultobj = Py_None;
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 PyObject *result;
6390 PyObject * obj0 = 0 ;
6391 char *kwnames[] = {
6392 (char *) "self", NULL
6393 };
6394
6395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6397 if (SWIG_arg_fail(1)) SWIG_fail;
6398 {
6399 PyThreadState* __tstate = wxPyBeginAllowThreads();
6400 result = (PyObject *)wxRect_Get(arg1);
6401
6402 wxPyEndAllowThreads(__tstate);
6403 if (PyErr_Occurred()) SWIG_fail;
6404 }
6405 resultobj = result;
6406 return resultobj;
6407 fail:
6408 return NULL;
6409 }
6410
6411
6412 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6413 PyObject *obj;
6414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6415 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6416 Py_INCREF(obj);
6417 return Py_BuildValue((char *)"");
6418 }
6419 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj;
6421 wxRect *arg1 = (wxRect *) 0 ;
6422 wxRect *arg2 = (wxRect *) 0 ;
6423 PyObject *result;
6424 PyObject * obj0 = 0 ;
6425 PyObject * obj1 = 0 ;
6426 char *kwnames[] = {
6427 (char *) "r1",(char *) "r2", NULL
6428 };
6429
6430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6432 if (SWIG_arg_fail(1)) SWIG_fail;
6433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(2)) SWIG_fail;
6435 {
6436 if (!wxPyCheckForApp()) SWIG_fail;
6437 PyThreadState* __tstate = wxPyBeginAllowThreads();
6438 result = (PyObject *)wxIntersectRect(arg1,arg2);
6439
6440 wxPyEndAllowThreads(__tstate);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = result;
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj;
6452 double arg1 = (double) 0.0 ;
6453 double arg2 = (double) 0.0 ;
6454 wxPoint2D *result;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "x",(char *) "y", NULL
6459 };
6460
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6462 if (obj0) {
6463 {
6464 arg1 = (double)(SWIG_As_double(obj0));
6465 if (SWIG_arg_fail(1)) SWIG_fail;
6466 }
6467 }
6468 if (obj1) {
6469 {
6470 arg2 = (double)(SWIG_As_double(obj1));
6471 if (SWIG_arg_fail(2)) SWIG_fail;
6472 }
6473 }
6474 {
6475 PyThreadState* __tstate = wxPyBeginAllowThreads();
6476 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6477
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxPoint2D *arg1 = 0 ;
6491 wxPoint2D *result;
6492 wxPoint2D temp1 ;
6493 PyObject * obj0 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "pt", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6499 {
6500 arg1 = &temp1;
6501 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6502 }
6503 {
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6506
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj;
6519 wxPoint *arg1 = 0 ;
6520 wxPoint2D *result;
6521 wxPoint temp1 ;
6522 PyObject * obj0 = 0 ;
6523 char *kwnames[] = {
6524 (char *) "pt", NULL
6525 };
6526
6527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6528 {
6529 arg1 = &temp1;
6530 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6531 }
6532 {
6533 PyThreadState* __tstate = wxPyBeginAllowThreads();
6534 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6535
6536 wxPyEndAllowThreads(__tstate);
6537 if (PyErr_Occurred()) SWIG_fail;
6538 }
6539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6540 return resultobj;
6541 fail:
6542 return NULL;
6543 }
6544
6545
6546 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6547 PyObject *resultobj;
6548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6549 int *arg2 = (int *) 0 ;
6550 int *arg3 = (int *) 0 ;
6551 int temp2 ;
6552 int res2 = 0 ;
6553 int temp3 ;
6554 int res3 = 0 ;
6555 PyObject * obj0 = 0 ;
6556 char *kwnames[] = {
6557 (char *) "self", NULL
6558 };
6559
6560 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6561 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6564 if (SWIG_arg_fail(1)) SWIG_fail;
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6568
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 Py_INCREF(Py_None); resultobj = Py_None;
6573 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6574 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6575 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6576 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6584 PyObject *resultobj;
6585 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6586 int *arg2 = (int *) 0 ;
6587 int *arg3 = (int *) 0 ;
6588 int temp2 ;
6589 int res2 = 0 ;
6590 int temp3 ;
6591 int res3 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 char *kwnames[] = {
6594 (char *) "self", NULL
6595 };
6596
6597 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6598 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6601 if (SWIG_arg_fail(1)) SWIG_fail;
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6605
6606 wxPyEndAllowThreads(__tstate);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 Py_INCREF(Py_None); resultobj = Py_None;
6610 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6611 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6612 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6613 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6623 double result;
6624 PyObject * obj0 = 0 ;
6625 char *kwnames[] = {
6626 (char *) "self", NULL
6627 };
6628
6629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6631 if (SWIG_arg_fail(1)) SWIG_fail;
6632 {
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6635
6636 wxPyEndAllowThreads(__tstate);
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 {
6640 resultobj = SWIG_From_double((double)(result));
6641 }
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj;
6650 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6651 double result;
6652 PyObject * obj0 = 0 ;
6653 char *kwnames[] = {
6654 (char *) "self", NULL
6655 };
6656
6657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6659 if (SWIG_arg_fail(1)) SWIG_fail;
6660 {
6661 PyThreadState* __tstate = wxPyBeginAllowThreads();
6662 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6663
6664 wxPyEndAllowThreads(__tstate);
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 {
6668 resultobj = SWIG_From_double((double)(result));
6669 }
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6679 double arg2 ;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self",(char *) "length", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 arg2 = (double)(SWIG_As_double(obj1));
6691 if (SWIG_arg_fail(2)) SWIG_fail;
6692 }
6693 {
6694 PyThreadState* __tstate = wxPyBeginAllowThreads();
6695 (arg1)->SetVectorLength(arg2);
6696
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 Py_INCREF(Py_None); resultobj = Py_None;
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6710 double arg2 ;
6711 PyObject * obj0 = 0 ;
6712 PyObject * obj1 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "self",(char *) "degrees", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(1)) SWIG_fail;
6720 {
6721 arg2 = (double)(SWIG_As_double(obj1));
6722 if (SWIG_arg_fail(2)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 (arg1)->SetVectorAngle(arg2);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 Py_INCREF(Py_None); resultobj = Py_None;
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6739 PyObject *resultobj;
6740 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6741 wxPoint2D *arg2 = 0 ;
6742 double result;
6743 wxPoint2D temp2 ;
6744 PyObject * obj0 = 0 ;
6745 PyObject * obj1 = 0 ;
6746 char *kwnames[] = {
6747 (char *) "self",(char *) "pt", NULL
6748 };
6749
6750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6752 if (SWIG_arg_fail(1)) SWIG_fail;
6753 {
6754 arg2 = &temp2;
6755 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6756 }
6757 {
6758 PyThreadState* __tstate = wxPyBeginAllowThreads();
6759 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6760
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 {
6765 resultobj = SWIG_From_double((double)(result));
6766 }
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj;
6775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6776 wxPoint2D *arg2 = 0 ;
6777 double result;
6778 wxPoint2D temp2 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char *kwnames[] = {
6782 (char *) "self",(char *) "pt", NULL
6783 };
6784
6785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6787 if (SWIG_arg_fail(1)) SWIG_fail;
6788 {
6789 arg2 = &temp2;
6790 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6791 }
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6795
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 {
6800 resultobj = SWIG_From_double((double)(result));
6801 }
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6809 PyObject *resultobj;
6810 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6811 wxPoint2D *arg2 = 0 ;
6812 double result;
6813 wxPoint2D temp2 ;
6814 PyObject * obj0 = 0 ;
6815 PyObject * obj1 = 0 ;
6816 char *kwnames[] = {
6817 (char *) "self",(char *) "vec", NULL
6818 };
6819
6820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6822 if (SWIG_arg_fail(1)) SWIG_fail;
6823 {
6824 arg2 = &temp2;
6825 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6826 }
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6830
6831 wxPyEndAllowThreads(__tstate);
6832 if (PyErr_Occurred()) SWIG_fail;
6833 }
6834 {
6835 resultobj = SWIG_From_double((double)(result));
6836 }
6837 return resultobj;
6838 fail:
6839 return NULL;
6840 }
6841
6842
6843 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6844 PyObject *resultobj;
6845 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6846 wxPoint2D *arg2 = 0 ;
6847 double result;
6848 wxPoint2D temp2 ;
6849 PyObject * obj0 = 0 ;
6850 PyObject * obj1 = 0 ;
6851 char *kwnames[] = {
6852 (char *) "self",(char *) "vec", NULL
6853 };
6854
6855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6857 if (SWIG_arg_fail(1)) SWIG_fail;
6858 {
6859 arg2 = &temp2;
6860 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6861 }
6862 {
6863 PyThreadState* __tstate = wxPyBeginAllowThreads();
6864 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6865
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 {
6870 resultobj = SWIG_From_double((double)(result));
6871 }
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6881 wxPoint2D result;
6882 PyObject * obj0 = 0 ;
6883 char *kwnames[] = {
6884 (char *) "self", NULL
6885 };
6886
6887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6889 if (SWIG_arg_fail(1)) SWIG_fail;
6890 {
6891 PyThreadState* __tstate = wxPyBeginAllowThreads();
6892 result = (arg1)->operator -();
6893
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 {
6898 wxPoint2D * resultptr;
6899 resultptr = new wxPoint2D((wxPoint2D &)(result));
6900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6901 }
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6909 PyObject *resultobj;
6910 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6911 wxPoint2D *arg2 = 0 ;
6912 wxPoint2D *result;
6913 wxPoint2D temp2 ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 char *kwnames[] = {
6917 (char *) "self",(char *) "pt", NULL
6918 };
6919
6920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6922 if (SWIG_arg_fail(1)) SWIG_fail;
6923 {
6924 arg2 = &temp2;
6925 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6926 }
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 {
6930 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6931 result = (wxPoint2D *) &_result_ref;
6932 }
6933
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj;
6946 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6947 wxPoint2D *arg2 = 0 ;
6948 wxPoint2D *result;
6949 wxPoint2D temp2 ;
6950 PyObject * obj0 = 0 ;
6951 PyObject * obj1 = 0 ;
6952 char *kwnames[] = {
6953 (char *) "self",(char *) "pt", NULL
6954 };
6955
6956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6958 if (SWIG_arg_fail(1)) SWIG_fail;
6959 {
6960 arg2 = &temp2;
6961 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6962 }
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 {
6966 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6967 result = (wxPoint2D *) &_result_ref;
6968 }
6969
6970 wxPyEndAllowThreads(__tstate);
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6974 return resultobj;
6975 fail:
6976 return NULL;
6977 }
6978
6979
6980 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6981 PyObject *resultobj;
6982 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6983 wxPoint2D *arg2 = 0 ;
6984 wxPoint2D *result;
6985 wxPoint2D temp2 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char *kwnames[] = {
6989 (char *) "self",(char *) "pt", NULL
6990 };
6991
6992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6994 if (SWIG_arg_fail(1)) SWIG_fail;
6995 {
6996 arg2 = &temp2;
6997 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6998 }
6999 {
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 {
7002 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7003 result = (wxPoint2D *) &_result_ref;
7004 }
7005
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj;
7018 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7019 wxPoint2D *arg2 = 0 ;
7020 wxPoint2D *result;
7021 wxPoint2D temp2 ;
7022 PyObject * obj0 = 0 ;
7023 PyObject * obj1 = 0 ;
7024 char *kwnames[] = {
7025 (char *) "self",(char *) "pt", NULL
7026 };
7027
7028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7030 if (SWIG_arg_fail(1)) SWIG_fail;
7031 {
7032 arg2 = &temp2;
7033 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7034 }
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 {
7038 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7039 result = (wxPoint2D *) &_result_ref;
7040 }
7041
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7053 PyObject *resultobj;
7054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7055 wxPoint2D *arg2 = 0 ;
7056 bool result;
7057 wxPoint2D temp2 ;
7058 PyObject * obj0 = 0 ;
7059 PyObject * obj1 = 0 ;
7060 char *kwnames[] = {
7061 (char *) "self",(char *) "pt", NULL
7062 };
7063
7064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7066 if (SWIG_arg_fail(1)) SWIG_fail;
7067 {
7068 arg2 = &temp2;
7069 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7070 }
7071 {
7072 PyThreadState* __tstate = wxPyBeginAllowThreads();
7073 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7074
7075 wxPyEndAllowThreads(__tstate);
7076 if (PyErr_Occurred()) SWIG_fail;
7077 }
7078 {
7079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7080 }
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7088 PyObject *resultobj;
7089 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7090 wxPoint2D *arg2 = 0 ;
7091 bool result;
7092 wxPoint2D temp2 ;
7093 PyObject * obj0 = 0 ;
7094 PyObject * obj1 = 0 ;
7095 char *kwnames[] = {
7096 (char *) "self",(char *) "pt", NULL
7097 };
7098
7099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7101 if (SWIG_arg_fail(1)) SWIG_fail;
7102 {
7103 arg2 = &temp2;
7104 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7105 }
7106 {
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7109
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 {
7114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7115 }
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7125 double arg2 ;
7126 PyObject * obj0 = 0 ;
7127 PyObject * obj1 = 0 ;
7128 char *kwnames[] = {
7129 (char *) "self",(char *) "m_x", NULL
7130 };
7131
7132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7134 if (SWIG_arg_fail(1)) SWIG_fail;
7135 {
7136 arg2 = (double)(SWIG_As_double(obj1));
7137 if (SWIG_arg_fail(2)) SWIG_fail;
7138 }
7139 if (arg1) (arg1)->m_x = arg2;
7140
7141 Py_INCREF(Py_None); resultobj = Py_None;
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj;
7150 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7151 double result;
7152 PyObject * obj0 = 0 ;
7153 char *kwnames[] = {
7154 (char *) "self", NULL
7155 };
7156
7157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7159 if (SWIG_arg_fail(1)) SWIG_fail;
7160 result = (double) ((arg1)->m_x);
7161
7162 {
7163 resultobj = SWIG_From_double((double)(result));
7164 }
7165 return resultobj;
7166 fail:
7167 return NULL;
7168 }
7169
7170
7171 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7172 PyObject *resultobj;
7173 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7174 double arg2 ;
7175 PyObject * obj0 = 0 ;
7176 PyObject * obj1 = 0 ;
7177 char *kwnames[] = {
7178 (char *) "self",(char *) "m_y", NULL
7179 };
7180
7181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7183 if (SWIG_arg_fail(1)) SWIG_fail;
7184 {
7185 arg2 = (double)(SWIG_As_double(obj1));
7186 if (SWIG_arg_fail(2)) SWIG_fail;
7187 }
7188 if (arg1) (arg1)->m_y = arg2;
7189
7190 Py_INCREF(Py_None); resultobj = Py_None;
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj;
7199 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7200 double result;
7201 PyObject * obj0 = 0 ;
7202 char *kwnames[] = {
7203 (char *) "self", NULL
7204 };
7205
7206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7208 if (SWIG_arg_fail(1)) SWIG_fail;
7209 result = (double) ((arg1)->m_y);
7210
7211 {
7212 resultobj = SWIG_From_double((double)(result));
7213 }
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj;
7222 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7223 double arg2 = (double) 0 ;
7224 double arg3 = (double) 0 ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 PyObject * obj2 = 0 ;
7228 char *kwnames[] = {
7229 (char *) "self",(char *) "x",(char *) "y", NULL
7230 };
7231
7232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7234 if (SWIG_arg_fail(1)) SWIG_fail;
7235 if (obj1) {
7236 {
7237 arg2 = (double)(SWIG_As_double(obj1));
7238 if (SWIG_arg_fail(2)) SWIG_fail;
7239 }
7240 }
7241 if (obj2) {
7242 {
7243 arg3 = (double)(SWIG_As_double(obj2));
7244 if (SWIG_arg_fail(3)) SWIG_fail;
7245 }
7246 }
7247 {
7248 PyThreadState* __tstate = wxPyBeginAllowThreads();
7249 wxPoint2D_Set(arg1,arg2,arg3);
7250
7251 wxPyEndAllowThreads(__tstate);
7252 if (PyErr_Occurred()) SWIG_fail;
7253 }
7254 Py_INCREF(Py_None); resultobj = Py_None;
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj;
7263 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7264 PyObject *result;
7265 PyObject * obj0 = 0 ;
7266 char *kwnames[] = {
7267 (char *) "self", NULL
7268 };
7269
7270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7272 if (SWIG_arg_fail(1)) SWIG_fail;
7273 {
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 result = (PyObject *)wxPoint2D_Get(arg1);
7276
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 resultobj = result;
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7288 PyObject *obj;
7289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7290 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7291 Py_INCREF(obj);
7292 return Py_BuildValue((char *)"");
7293 }
7294 static int _wrap_DefaultPosition_set(PyObject *) {
7295 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7296 return 1;
7297 }
7298
7299
7300 static PyObject *_wrap_DefaultPosition_get(void) {
7301 PyObject *pyobj;
7302
7303 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7304 return pyobj;
7305 }
7306
7307
7308 static int _wrap_DefaultSize_set(PyObject *) {
7309 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7310 return 1;
7311 }
7312
7313
7314 static PyObject *_wrap_DefaultSize_get(void) {
7315 PyObject *pyobj;
7316
7317 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7318 return pyobj;
7319 }
7320
7321
7322 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj;
7324 PyObject *arg1 = (PyObject *) 0 ;
7325 wxPyInputStream *result;
7326 PyObject * obj0 = 0 ;
7327 char *kwnames[] = {
7328 (char *) "p", NULL
7329 };
7330
7331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7332 arg1 = obj0;
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7336
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7341 return resultobj;
7342 fail:
7343 return NULL;
7344 }
7345
7346
7347 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7348 PyObject *resultobj;
7349 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7350 PyObject * obj0 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self", NULL
7353 };
7354
7355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7357 if (SWIG_arg_fail(1)) SWIG_fail;
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 delete arg1;
7361
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 Py_INCREF(Py_None); resultobj = Py_None;
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj;
7374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7375 PyObject * obj0 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "self", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7382 if (SWIG_arg_fail(1)) SWIG_fail;
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 (arg1)->close();
7386
7387 wxPyEndAllowThreads(__tstate);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 Py_INCREF(Py_None); resultobj = Py_None;
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7400 PyObject * obj0 = 0 ;
7401 char *kwnames[] = {
7402 (char *) "self", NULL
7403 };
7404
7405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7407 if (SWIG_arg_fail(1)) SWIG_fail;
7408 {
7409 PyThreadState* __tstate = wxPyBeginAllowThreads();
7410 (arg1)->flush();
7411
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 Py_INCREF(Py_None); resultobj = Py_None;
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7423 PyObject *resultobj;
7424 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7425 bool result;
7426 PyObject * obj0 = 0 ;
7427 char *kwnames[] = {
7428 (char *) "self", NULL
7429 };
7430
7431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7433 if (SWIG_arg_fail(1)) SWIG_fail;
7434 {
7435 PyThreadState* __tstate = wxPyBeginAllowThreads();
7436 result = (bool)(arg1)->eof();
7437
7438 wxPyEndAllowThreads(__tstate);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 {
7442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7443 }
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj;
7452 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7453 int arg2 = (int) -1 ;
7454 PyObject *result;
7455 PyObject * obj0 = 0 ;
7456 PyObject * obj1 = 0 ;
7457 char *kwnames[] = {
7458 (char *) "self",(char *) "size", NULL
7459 };
7460
7461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7463 if (SWIG_arg_fail(1)) SWIG_fail;
7464 if (obj1) {
7465 {
7466 arg2 = (int)(SWIG_As_int(obj1));
7467 if (SWIG_arg_fail(2)) SWIG_fail;
7468 }
7469 }
7470 {
7471 PyThreadState* __tstate = wxPyBeginAllowThreads();
7472 result = (PyObject *)(arg1)->read(arg2);
7473
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 resultobj = result;
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj;
7486 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7487 int arg2 = (int) -1 ;
7488 PyObject *result;
7489 PyObject * obj0 = 0 ;
7490 PyObject * obj1 = 0 ;
7491 char *kwnames[] = {
7492 (char *) "self",(char *) "size", NULL
7493 };
7494
7495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(1)) SWIG_fail;
7498 if (obj1) {
7499 {
7500 arg2 = (int)(SWIG_As_int(obj1));
7501 if (SWIG_arg_fail(2)) SWIG_fail;
7502 }
7503 }
7504 {
7505 PyThreadState* __tstate = wxPyBeginAllowThreads();
7506 result = (PyObject *)(arg1)->readline(arg2);
7507
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 resultobj = result;
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7519 PyObject *resultobj;
7520 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7521 int arg2 = (int) -1 ;
7522 PyObject *result;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char *kwnames[] = {
7526 (char *) "self",(char *) "sizehint", NULL
7527 };
7528
7529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7531 if (SWIG_arg_fail(1)) SWIG_fail;
7532 if (obj1) {
7533 {
7534 arg2 = (int)(SWIG_As_int(obj1));
7535 if (SWIG_arg_fail(2)) SWIG_fail;
7536 }
7537 }
7538 {
7539 PyThreadState* __tstate = wxPyBeginAllowThreads();
7540 result = (PyObject *)(arg1)->readlines(arg2);
7541
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 resultobj = result;
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj;
7554 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7555 int arg2 ;
7556 int arg3 = (int) 0 ;
7557 PyObject * obj0 = 0 ;
7558 PyObject * obj1 = 0 ;
7559 PyObject * obj2 = 0 ;
7560 char *kwnames[] = {
7561 (char *) "self",(char *) "offset",(char *) "whence", NULL
7562 };
7563
7564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7566 if (SWIG_arg_fail(1)) SWIG_fail;
7567 {
7568 arg2 = (int)(SWIG_As_int(obj1));
7569 if (SWIG_arg_fail(2)) SWIG_fail;
7570 }
7571 if (obj2) {
7572 {
7573 arg3 = (int)(SWIG_As_int(obj2));
7574 if (SWIG_arg_fail(3)) SWIG_fail;
7575 }
7576 }
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 (arg1)->seek(arg2,arg3);
7580
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 Py_INCREF(Py_None); resultobj = Py_None;
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj;
7593 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7594 int result;
7595 PyObject * obj0 = 0 ;
7596 char *kwnames[] = {
7597 (char *) "self", NULL
7598 };
7599
7600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7602 if (SWIG_arg_fail(1)) SWIG_fail;
7603 {
7604 PyThreadState* __tstate = wxPyBeginAllowThreads();
7605 result = (int)(arg1)->tell();
7606
7607 wxPyEndAllowThreads(__tstate);
7608 if (PyErr_Occurred()) SWIG_fail;
7609 }
7610 {
7611 resultobj = SWIG_From_int((int)(result));
7612 }
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7620 PyObject *resultobj;
7621 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7622 char result;
7623 PyObject * obj0 = 0 ;
7624 char *kwnames[] = {
7625 (char *) "self", NULL
7626 };
7627
7628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7630 if (SWIG_arg_fail(1)) SWIG_fail;
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 result = (char)(arg1)->Peek();
7634
7635 wxPyEndAllowThreads(__tstate);
7636 if (PyErr_Occurred()) SWIG_fail;
7637 }
7638 {
7639 resultobj = SWIG_From_char((char)(result));
7640 }
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7648 PyObject *resultobj;
7649 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7650 char result;
7651 PyObject * obj0 = 0 ;
7652 char *kwnames[] = {
7653 (char *) "self", NULL
7654 };
7655
7656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7658 if (SWIG_arg_fail(1)) SWIG_fail;
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 result = (char)(arg1)->GetC();
7662
7663 wxPyEndAllowThreads(__tstate);
7664 if (PyErr_Occurred()) SWIG_fail;
7665 }
7666 {
7667 resultobj = SWIG_From_char((char)(result));
7668 }
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj;
7677 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7678 size_t result;
7679 PyObject * obj0 = 0 ;
7680 char *kwnames[] = {
7681 (char *) "self", NULL
7682 };
7683
7684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7686 if (SWIG_arg_fail(1)) SWIG_fail;
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 result = (size_t)(arg1)->LastRead();
7690
7691 wxPyEndAllowThreads(__tstate);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 {
7695 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7696 }
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj;
7705 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7706 bool result;
7707 PyObject * obj0 = 0 ;
7708 char *kwnames[] = {
7709 (char *) "self", NULL
7710 };
7711
7712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7714 if (SWIG_arg_fail(1)) SWIG_fail;
7715 {
7716 PyThreadState* __tstate = wxPyBeginAllowThreads();
7717 result = (bool)(arg1)->CanRead();
7718
7719 wxPyEndAllowThreads(__tstate);
7720 if (PyErr_Occurred()) SWIG_fail;
7721 }
7722 {
7723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7724 }
7725 return resultobj;
7726 fail:
7727 return NULL;
7728 }
7729
7730
7731 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7732 PyObject *resultobj;
7733 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7734 bool result;
7735 PyObject * obj0 = 0 ;
7736 char *kwnames[] = {
7737 (char *) "self", NULL
7738 };
7739
7740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7742 if (SWIG_arg_fail(1)) SWIG_fail;
7743 {
7744 PyThreadState* __tstate = wxPyBeginAllowThreads();
7745 result = (bool)(arg1)->Eof();
7746
7747 wxPyEndAllowThreads(__tstate);
7748 if (PyErr_Occurred()) SWIG_fail;
7749 }
7750 {
7751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7752 }
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7760 PyObject *resultobj;
7761 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7762 char arg2 ;
7763 bool result;
7764 PyObject * obj0 = 0 ;
7765 PyObject * obj1 = 0 ;
7766 char *kwnames[] = {
7767 (char *) "self",(char *) "c", NULL
7768 };
7769
7770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7772 if (SWIG_arg_fail(1)) SWIG_fail;
7773 {
7774 arg2 = (char)(SWIG_As_char(obj1));
7775 if (SWIG_arg_fail(2)) SWIG_fail;
7776 }
7777 {
7778 PyThreadState* __tstate = wxPyBeginAllowThreads();
7779 result = (bool)(arg1)->Ungetch(arg2);
7780
7781 wxPyEndAllowThreads(__tstate);
7782 if (PyErr_Occurred()) SWIG_fail;
7783 }
7784 {
7785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7786 }
7787 return resultobj;
7788 fail:
7789 return NULL;
7790 }
7791
7792
7793 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7794 PyObject *resultobj;
7795 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7796 long arg2 ;
7797 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7798 long result;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 PyObject * obj2 = 0 ;
7802 char *kwnames[] = {
7803 (char *) "self",(char *) "pos",(char *) "mode", NULL
7804 };
7805
7806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7808 if (SWIG_arg_fail(1)) SWIG_fail;
7809 {
7810 arg2 = (long)(SWIG_As_long(obj1));
7811 if (SWIG_arg_fail(2)) SWIG_fail;
7812 }
7813 if (obj2) {
7814 {
7815 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7816 if (SWIG_arg_fail(3)) SWIG_fail;
7817 }
7818 }
7819 {
7820 PyThreadState* __tstate = wxPyBeginAllowThreads();
7821 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7822
7823 wxPyEndAllowThreads(__tstate);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 {
7827 resultobj = SWIG_From_long((long)(result));
7828 }
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7838 long result;
7839 PyObject * obj0 = 0 ;
7840 char *kwnames[] = {
7841 (char *) "self", NULL
7842 };
7843
7844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7846 if (SWIG_arg_fail(1)) SWIG_fail;
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (long)(arg1)->TellI();
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 {
7855 resultobj = SWIG_From_long((long)(result));
7856 }
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7864 PyObject *obj;
7865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7866 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7867 Py_INCREF(obj);
7868 return Py_BuildValue((char *)"");
7869 }
7870 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7871 PyObject *resultobj;
7872 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7873 PyObject *arg2 = (PyObject *) 0 ;
7874 PyObject * obj0 = 0 ;
7875 PyObject * obj1 = 0 ;
7876 char *kwnames[] = {
7877 (char *) "self",(char *) "obj", NULL
7878 };
7879
7880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7882 if (SWIG_arg_fail(1)) SWIG_fail;
7883 arg2 = obj1;
7884 {
7885 PyThreadState* __tstate = wxPyBeginAllowThreads();
7886 wxOutputStream_write(arg1,arg2);
7887
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 Py_INCREF(Py_None); resultobj = Py_None;
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7899 PyObject *obj;
7900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7901 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7902 Py_INCREF(obj);
7903 return Py_BuildValue((char *)"");
7904 }
7905 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj;
7907 wxInputStream *arg1 = (wxInputStream *) 0 ;
7908 wxString *arg2 = 0 ;
7909 wxString *arg3 = 0 ;
7910 wxString *arg4 = 0 ;
7911 wxDateTime arg5 ;
7912 wxFSFile *result;
7913 wxPyInputStream *temp1 ;
7914 bool created1 ;
7915 bool temp2 = false ;
7916 bool temp3 = false ;
7917 bool temp4 = false ;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 PyObject * obj2 = 0 ;
7921 PyObject * obj3 = 0 ;
7922 PyObject * obj4 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7928 {
7929 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7930 arg1 = temp1->m_wxis;
7931 created1 = false;
7932 } else {
7933 PyErr_Clear(); // clear the failure of the wxPyConvert above
7934 arg1 = wxPyCBInputStream_create(obj0, false);
7935 if (arg1 == NULL) {
7936 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7937 SWIG_fail;
7938 }
7939 created1 = true;
7940 }
7941 }
7942 {
7943 arg2 = wxString_in_helper(obj1);
7944 if (arg2 == NULL) SWIG_fail;
7945 temp2 = true;
7946 }
7947 {
7948 arg3 = wxString_in_helper(obj2);
7949 if (arg3 == NULL) SWIG_fail;
7950 temp3 = true;
7951 }
7952 {
7953 arg4 = wxString_in_helper(obj3);
7954 if (arg4 == NULL) SWIG_fail;
7955 temp4 = true;
7956 }
7957 {
7958 wxDateTime * argp;
7959 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7960 if (SWIG_arg_fail(5)) SWIG_fail;
7961 if (argp == NULL) {
7962 SWIG_null_ref("wxDateTime");
7963 }
7964 if (SWIG_arg_fail(5)) SWIG_fail;
7965 arg5 = *argp;
7966 }
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7970
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 {
7975 resultobj = wxPyMake_wxObject(result, 1);
7976 }
7977 {
7978 if (created1)
7979 delete arg1;
7980 }
7981 {
7982 if (temp2)
7983 delete arg2;
7984 }
7985 {
7986 if (temp3)
7987 delete arg3;
7988 }
7989 {
7990 if (temp4)
7991 delete arg4;
7992 }
7993 return resultobj;
7994 fail:
7995 {
7996 if (created1)
7997 delete arg1;
7998 }
7999 {
8000 if (temp2)
8001 delete arg2;
8002 }
8003 {
8004 if (temp3)
8005 delete arg3;
8006 }
8007 {
8008 if (temp4)
8009 delete arg4;
8010 }
8011 return NULL;
8012 }
8013
8014
8015 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj;
8017 wxFSFile *arg1 = (wxFSFile *) 0 ;
8018 PyObject * obj0 = 0 ;
8019 char *kwnames[] = {
8020 (char *) "self", NULL
8021 };
8022
8023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8025 if (SWIG_arg_fail(1)) SWIG_fail;
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 delete arg1;
8029
8030 wxPyEndAllowThreads(__tstate);
8031 if (PyErr_Occurred()) SWIG_fail;
8032 }
8033 Py_INCREF(Py_None); resultobj = Py_None;
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8041 PyObject *resultobj;
8042 wxFSFile *arg1 = (wxFSFile *) 0 ;
8043 wxInputStream *result;
8044 PyObject * obj0 = 0 ;
8045 char *kwnames[] = {
8046 (char *) "self", NULL
8047 };
8048
8049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8051 if (SWIG_arg_fail(1)) SWIG_fail;
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 result = (wxInputStream *)(arg1)->GetStream();
8055
8056 wxPyEndAllowThreads(__tstate);
8057 if (PyErr_Occurred()) SWIG_fail;
8058 }
8059 {
8060 wxPyInputStream * _ptr = NULL;
8061
8062 if (result) {
8063 _ptr = new wxPyInputStream(result);
8064 }
8065 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8066 }
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj;
8075 wxFSFile *arg1 = (wxFSFile *) 0 ;
8076 wxString *result;
8077 PyObject * obj0 = 0 ;
8078 char *kwnames[] = {
8079 (char *) "self", NULL
8080 };
8081
8082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8084 if (SWIG_arg_fail(1)) SWIG_fail;
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 {
8088 wxString const &_result_ref = (arg1)->GetMimeType();
8089 result = (wxString *) &_result_ref;
8090 }
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 {
8096 #if wxUSE_UNICODE
8097 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8098 #else
8099 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8100 #endif
8101 }
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8109 PyObject *resultobj;
8110 wxFSFile *arg1 = (wxFSFile *) 0 ;
8111 wxString *result;
8112 PyObject * obj0 = 0 ;
8113 char *kwnames[] = {
8114 (char *) "self", NULL
8115 };
8116
8117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8119 if (SWIG_arg_fail(1)) SWIG_fail;
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 {
8123 wxString const &_result_ref = (arg1)->GetLocation();
8124 result = (wxString *) &_result_ref;
8125 }
8126
8127 wxPyEndAllowThreads(__tstate);
8128 if (PyErr_Occurred()) SWIG_fail;
8129 }
8130 {
8131 #if wxUSE_UNICODE
8132 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8133 #else
8134 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8135 #endif
8136 }
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8144 PyObject *resultobj;
8145 wxFSFile *arg1 = (wxFSFile *) 0 ;
8146 wxString *result;
8147 PyObject * obj0 = 0 ;
8148 char *kwnames[] = {
8149 (char *) "self", NULL
8150 };
8151
8152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8154 if (SWIG_arg_fail(1)) SWIG_fail;
8155 {
8156 PyThreadState* __tstate = wxPyBeginAllowThreads();
8157 {
8158 wxString const &_result_ref = (arg1)->GetAnchor();
8159 result = (wxString *) &_result_ref;
8160 }
8161
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 {
8166 #if wxUSE_UNICODE
8167 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8168 #else
8169 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8170 #endif
8171 }
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8179 PyObject *resultobj;
8180 wxFSFile *arg1 = (wxFSFile *) 0 ;
8181 wxDateTime result;
8182 PyObject * obj0 = 0 ;
8183 char *kwnames[] = {
8184 (char *) "self", NULL
8185 };
8186
8187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8189 if (SWIG_arg_fail(1)) SWIG_fail;
8190 {
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 result = (arg1)->GetModificationTime();
8193
8194 wxPyEndAllowThreads(__tstate);
8195 if (PyErr_Occurred()) SWIG_fail;
8196 }
8197 {
8198 wxDateTime * resultptr;
8199 resultptr = new wxDateTime((wxDateTime &)(result));
8200 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8201 }
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8209 PyObject *obj;
8210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8211 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8212 Py_INCREF(obj);
8213 return Py_BuildValue((char *)"");
8214 }
8215 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8216 PyObject *obj;
8217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8218 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8219 Py_INCREF(obj);
8220 return Py_BuildValue((char *)"");
8221 }
8222 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj;
8224 wxPyFileSystemHandler *result;
8225 char *kwnames[] = {
8226 NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8233
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj;
8246 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8247 PyObject *arg2 = (PyObject *) 0 ;
8248 PyObject *arg3 = (PyObject *) 0 ;
8249 PyObject * obj0 = 0 ;
8250 PyObject * obj1 = 0 ;
8251 PyObject * obj2 = 0 ;
8252 char *kwnames[] = {
8253 (char *) "self",(char *) "self",(char *) "_class", NULL
8254 };
8255
8256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8258 if (SWIG_arg_fail(1)) SWIG_fail;
8259 arg2 = obj1;
8260 arg3 = obj2;
8261 {
8262 PyThreadState* __tstate = wxPyBeginAllowThreads();
8263 (arg1)->_setCallbackInfo(arg2,arg3);
8264
8265 wxPyEndAllowThreads(__tstate);
8266 if (PyErr_Occurred()) SWIG_fail;
8267 }
8268 Py_INCREF(Py_None); resultobj = Py_None;
8269 return resultobj;
8270 fail:
8271 return NULL;
8272 }
8273
8274
8275 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8276 PyObject *resultobj;
8277 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8278 wxString *arg2 = 0 ;
8279 bool result;
8280 bool temp2 = false ;
8281 PyObject * obj0 = 0 ;
8282 PyObject * obj1 = 0 ;
8283 char *kwnames[] = {
8284 (char *) "self",(char *) "location", NULL
8285 };
8286
8287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8289 if (SWIG_arg_fail(1)) SWIG_fail;
8290 {
8291 arg2 = wxString_in_helper(obj1);
8292 if (arg2 == NULL) SWIG_fail;
8293 temp2 = true;
8294 }
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8304 }
8305 {
8306 if (temp2)
8307 delete arg2;
8308 }
8309 return resultobj;
8310 fail:
8311 {
8312 if (temp2)
8313 delete arg2;
8314 }
8315 return NULL;
8316 }
8317
8318
8319 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8320 PyObject *resultobj;
8321 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8322 wxFileSystem *arg2 = 0 ;
8323 wxString *arg3 = 0 ;
8324 wxFSFile *result;
8325 bool temp3 = false ;
8326 PyObject * obj0 = 0 ;
8327 PyObject * obj1 = 0 ;
8328 PyObject * obj2 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self",(char *) "fs",(char *) "location", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8338 if (SWIG_arg_fail(2)) SWIG_fail;
8339 if (arg2 == NULL) {
8340 SWIG_null_ref("wxFileSystem");
8341 }
8342 if (SWIG_arg_fail(2)) SWIG_fail;
8343 }
8344 {
8345 arg3 = wxString_in_helper(obj2);
8346 if (arg3 == NULL) SWIG_fail;
8347 temp3 = true;
8348 }
8349 {
8350 PyThreadState* __tstate = wxPyBeginAllowThreads();
8351 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8352
8353 wxPyEndAllowThreads(__tstate);
8354 if (PyErr_Occurred()) SWIG_fail;
8355 }
8356 {
8357 resultobj = wxPyMake_wxObject(result, 1);
8358 }
8359 {
8360 if (temp3)
8361 delete arg3;
8362 }
8363 return resultobj;
8364 fail:
8365 {
8366 if (temp3)
8367 delete arg3;
8368 }
8369 return NULL;
8370 }
8371
8372
8373 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj;
8375 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8376 wxString *arg2 = 0 ;
8377 int arg3 = (int) 0 ;
8378 wxString result;
8379 bool temp2 = false ;
8380 PyObject * obj0 = 0 ;
8381 PyObject * obj1 = 0 ;
8382 PyObject * obj2 = 0 ;
8383 char *kwnames[] = {
8384 (char *) "self",(char *) "spec",(char *) "flags", NULL
8385 };
8386
8387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8389 if (SWIG_arg_fail(1)) SWIG_fail;
8390 {
8391 arg2 = wxString_in_helper(obj1);
8392 if (arg2 == NULL) SWIG_fail;
8393 temp2 = true;
8394 }
8395 if (obj2) {
8396 {
8397 arg3 = (int)(SWIG_As_int(obj2));
8398 if (SWIG_arg_fail(3)) SWIG_fail;
8399 }
8400 }
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8404
8405 wxPyEndAllowThreads(__tstate);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 {
8409 #if wxUSE_UNICODE
8410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8411 #else
8412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8413 #endif
8414 }
8415 {
8416 if (temp2)
8417 delete arg2;
8418 }
8419 return resultobj;
8420 fail:
8421 {
8422 if (temp2)
8423 delete arg2;
8424 }
8425 return NULL;
8426 }
8427
8428
8429 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8430 PyObject *resultobj;
8431 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8432 wxString result;
8433 PyObject * obj0 = 0 ;
8434 char *kwnames[] = {
8435 (char *) "self", NULL
8436 };
8437
8438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8440 if (SWIG_arg_fail(1)) SWIG_fail;
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (arg1)->FindNext();
8444
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 {
8449 #if wxUSE_UNICODE
8450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8451 #else
8452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8453 #endif
8454 }
8455 return resultobj;
8456 fail:
8457 return NULL;
8458 }
8459
8460
8461 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8462 PyObject *resultobj;
8463 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8464 wxString *arg2 = 0 ;
8465 wxString result;
8466 bool temp2 = false ;
8467 PyObject * obj0 = 0 ;
8468 PyObject * obj1 = 0 ;
8469 char *kwnames[] = {
8470 (char *) "self",(char *) "location", NULL
8471 };
8472
8473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8475 if (SWIG_arg_fail(1)) SWIG_fail;
8476 {
8477 arg2 = wxString_in_helper(obj1);
8478 if (arg2 == NULL) SWIG_fail;
8479 temp2 = true;
8480 }
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 result = (arg1)->GetProtocol((wxString const &)*arg2);
8484
8485 wxPyEndAllowThreads(__tstate);
8486 if (PyErr_Occurred()) SWIG_fail;
8487 }
8488 {
8489 #if wxUSE_UNICODE
8490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8491 #else
8492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8493 #endif
8494 }
8495 {
8496 if (temp2)
8497 delete arg2;
8498 }
8499 return resultobj;
8500 fail:
8501 {
8502 if (temp2)
8503 delete arg2;
8504 }
8505 return NULL;
8506 }
8507
8508
8509 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj;
8511 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8512 wxString *arg2 = 0 ;
8513 wxString result;
8514 bool temp2 = false ;
8515 PyObject * obj0 = 0 ;
8516 PyObject * obj1 = 0 ;
8517 char *kwnames[] = {
8518 (char *) "self",(char *) "location", NULL
8519 };
8520
8521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 {
8525 arg2 = wxString_in_helper(obj1);
8526 if (arg2 == NULL) SWIG_fail;
8527 temp2 = true;
8528 }
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8532
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 {
8537 #if wxUSE_UNICODE
8538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8539 #else
8540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8541 #endif
8542 }
8543 {
8544 if (temp2)
8545 delete arg2;
8546 }
8547 return resultobj;
8548 fail:
8549 {
8550 if (temp2)
8551 delete arg2;
8552 }
8553 return NULL;
8554 }
8555
8556
8557 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj;
8559 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8560 wxString *arg2 = 0 ;
8561 wxString result;
8562 bool temp2 = false ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char *kwnames[] = {
8566 (char *) "self",(char *) "location", NULL
8567 };
8568
8569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8571 if (SWIG_arg_fail(1)) SWIG_fail;
8572 {
8573 arg2 = wxString_in_helper(obj1);
8574 if (arg2 == NULL) SWIG_fail;
8575 temp2 = true;
8576 }
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (arg1)->GetAnchor((wxString const &)*arg2);
8580
8581 wxPyEndAllowThreads(__tstate);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 {
8585 #if wxUSE_UNICODE
8586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8587 #else
8588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8589 #endif
8590 }
8591 {
8592 if (temp2)
8593 delete arg2;
8594 }
8595 return resultobj;
8596 fail:
8597 {
8598 if (temp2)
8599 delete arg2;
8600 }
8601 return NULL;
8602 }
8603
8604
8605 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8606 PyObject *resultobj;
8607 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8608 wxString *arg2 = 0 ;
8609 wxString result;
8610 bool temp2 = false ;
8611 PyObject * obj0 = 0 ;
8612 PyObject * obj1 = 0 ;
8613 char *kwnames[] = {
8614 (char *) "self",(char *) "location", NULL
8615 };
8616
8617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8619 if (SWIG_arg_fail(1)) SWIG_fail;
8620 {
8621 arg2 = wxString_in_helper(obj1);
8622 if (arg2 == NULL) SWIG_fail;
8623 temp2 = true;
8624 }
8625 {
8626 PyThreadState* __tstate = wxPyBeginAllowThreads();
8627 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8628
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 {
8633 #if wxUSE_UNICODE
8634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8635 #else
8636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8637 #endif
8638 }
8639 {
8640 if (temp2)
8641 delete arg2;
8642 }
8643 return resultobj;
8644 fail:
8645 {
8646 if (temp2)
8647 delete arg2;
8648 }
8649 return NULL;
8650 }
8651
8652
8653 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj;
8655 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8656 wxString *arg2 = 0 ;
8657 wxString result;
8658 bool temp2 = false ;
8659 PyObject * obj0 = 0 ;
8660 PyObject * obj1 = 0 ;
8661 char *kwnames[] = {
8662 (char *) "self",(char *) "location", NULL
8663 };
8664
8665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8667 if (SWIG_arg_fail(1)) SWIG_fail;
8668 {
8669 arg2 = wxString_in_helper(obj1);
8670 if (arg2 == NULL) SWIG_fail;
8671 temp2 = true;
8672 }
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8676
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 {
8681 #if wxUSE_UNICODE
8682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8683 #else
8684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8685 #endif
8686 }
8687 {
8688 if (temp2)
8689 delete arg2;
8690 }
8691 return resultobj;
8692 fail:
8693 {
8694 if (temp2)
8695 delete arg2;
8696 }
8697 return NULL;
8698 }
8699
8700
8701 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8702 PyObject *obj;
8703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8704 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8705 Py_INCREF(obj);
8706 return Py_BuildValue((char *)"");
8707 }
8708 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj;
8710 wxFileSystem *result;
8711 char *kwnames[] = {
8712 NULL
8713 };
8714
8715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 result = (wxFileSystem *)new wxFileSystem();
8719
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 {
8724 resultobj = wxPyMake_wxObject(result, 1);
8725 }
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj;
8734 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8735 PyObject * obj0 = 0 ;
8736 char *kwnames[] = {
8737 (char *) "self", NULL
8738 };
8739
8740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8742 if (SWIG_arg_fail(1)) SWIG_fail;
8743 {
8744 PyThreadState* __tstate = wxPyBeginAllowThreads();
8745 delete arg1;
8746
8747 wxPyEndAllowThreads(__tstate);
8748 if (PyErr_Occurred()) SWIG_fail;
8749 }
8750 Py_INCREF(Py_None); resultobj = Py_None;
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8758 PyObject *resultobj;
8759 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8760 wxString *arg2 = 0 ;
8761 bool arg3 = (bool) false ;
8762 bool temp2 = false ;
8763 PyObject * obj0 = 0 ;
8764 PyObject * obj1 = 0 ;
8765 PyObject * obj2 = 0 ;
8766 char *kwnames[] = {
8767 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8768 };
8769
8770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8772 if (SWIG_arg_fail(1)) SWIG_fail;
8773 {
8774 arg2 = wxString_in_helper(obj1);
8775 if (arg2 == NULL) SWIG_fail;
8776 temp2 = true;
8777 }
8778 if (obj2) {
8779 {
8780 arg3 = (bool)(SWIG_As_bool(obj2));
8781 if (SWIG_arg_fail(3)) SWIG_fail;
8782 }
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 Py_INCREF(Py_None); resultobj = Py_None;
8792 {
8793 if (temp2)
8794 delete arg2;
8795 }
8796 return resultobj;
8797 fail:
8798 {
8799 if (temp2)
8800 delete arg2;
8801 }
8802 return NULL;
8803 }
8804
8805
8806 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8807 PyObject *resultobj;
8808 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8809 wxString result;
8810 PyObject * obj0 = 0 ;
8811 char *kwnames[] = {
8812 (char *) "self", NULL
8813 };
8814
8815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8817 if (SWIG_arg_fail(1)) SWIG_fail;
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = (arg1)->GetPath();
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 #if wxUSE_UNICODE
8827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8828 #else
8829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8830 #endif
8831 }
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj;
8840 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8841 wxString *arg2 = 0 ;
8842 wxFSFile *result;
8843 bool temp2 = false ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 char *kwnames[] = {
8847 (char *) "self",(char *) "location", NULL
8848 };
8849
8850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8852 if (SWIG_arg_fail(1)) SWIG_fail;
8853 {
8854 arg2 = wxString_in_helper(obj1);
8855 if (arg2 == NULL) SWIG_fail;
8856 temp2 = true;
8857 }
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8861
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 {
8866 resultobj = wxPyMake_wxObject(result, 1);
8867 }
8868 {
8869 if (temp2)
8870 delete arg2;
8871 }
8872 return resultobj;
8873 fail:
8874 {
8875 if (temp2)
8876 delete arg2;
8877 }
8878 return NULL;
8879 }
8880
8881
8882 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8883 PyObject *resultobj;
8884 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8885 wxString *arg2 = 0 ;
8886 int arg3 = (int) 0 ;
8887 wxString result;
8888 bool temp2 = false ;
8889 PyObject * obj0 = 0 ;
8890 PyObject * obj1 = 0 ;
8891 PyObject * obj2 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self",(char *) "spec",(char *) "flags", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 {
8900 arg2 = wxString_in_helper(obj1);
8901 if (arg2 == NULL) SWIG_fail;
8902 temp2 = true;
8903 }
8904 if (obj2) {
8905 {
8906 arg3 = (int)(SWIG_As_int(obj2));
8907 if (SWIG_arg_fail(3)) SWIG_fail;
8908 }
8909 }
8910 {
8911 PyThreadState* __tstate = wxPyBeginAllowThreads();
8912 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8913
8914 wxPyEndAllowThreads(__tstate);
8915 if (PyErr_Occurred()) SWIG_fail;
8916 }
8917 {
8918 #if wxUSE_UNICODE
8919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8920 #else
8921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8922 #endif
8923 }
8924 {
8925 if (temp2)
8926 delete arg2;
8927 }
8928 return resultobj;
8929 fail:
8930 {
8931 if (temp2)
8932 delete arg2;
8933 }
8934 return NULL;
8935 }
8936
8937
8938 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8939 PyObject *resultobj;
8940 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8941 wxString result;
8942 PyObject * obj0 = 0 ;
8943 char *kwnames[] = {
8944 (char *) "self", NULL
8945 };
8946
8947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8949 if (SWIG_arg_fail(1)) SWIG_fail;
8950 {
8951 PyThreadState* __tstate = wxPyBeginAllowThreads();
8952 result = (arg1)->FindNext();
8953
8954 wxPyEndAllowThreads(__tstate);
8955 if (PyErr_Occurred()) SWIG_fail;
8956 }
8957 {
8958 #if wxUSE_UNICODE
8959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8960 #else
8961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8962 #endif
8963 }
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj;
8972 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8973 PyObject * obj0 = 0 ;
8974 char *kwnames[] = {
8975 (char *) "handler", NULL
8976 };
8977
8978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8980 if (SWIG_arg_fail(1)) SWIG_fail;
8981 {
8982 PyThreadState* __tstate = wxPyBeginAllowThreads();
8983 wxFileSystem::AddHandler(arg1);
8984
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 Py_INCREF(Py_None); resultobj = Py_None;
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8996 PyObject *resultobj;
8997 char *kwnames[] = {
8998 NULL
8999 };
9000
9001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 wxFileSystem::CleanUpHandlers();
9005
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 Py_INCREF(Py_None); resultobj = Py_None;
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj;
9018 wxString *arg1 = 0 ;
9019 wxString result;
9020 bool temp1 = false ;
9021 PyObject * obj0 = 0 ;
9022 char *kwnames[] = {
9023 (char *) "filename", NULL
9024 };
9025
9026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9027 {
9028 arg1 = wxString_in_helper(obj0);
9029 if (arg1 == NULL) SWIG_fail;
9030 temp1 = true;
9031 }
9032 {
9033 PyThreadState* __tstate = wxPyBeginAllowThreads();
9034 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9035
9036 wxPyEndAllowThreads(__tstate);
9037 if (PyErr_Occurred()) SWIG_fail;
9038 }
9039 {
9040 #if wxUSE_UNICODE
9041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9042 #else
9043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9044 #endif
9045 }
9046 {
9047 if (temp1)
9048 delete arg1;
9049 }
9050 return resultobj;
9051 fail:
9052 {
9053 if (temp1)
9054 delete arg1;
9055 }
9056 return NULL;
9057 }
9058
9059
9060 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9061 PyObject *resultobj;
9062 wxString *arg1 = 0 ;
9063 wxString result;
9064 bool temp1 = false ;
9065 PyObject * obj0 = 0 ;
9066 char *kwnames[] = {
9067 (char *) "url", NULL
9068 };
9069
9070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9071 {
9072 arg1 = wxString_in_helper(obj0);
9073 if (arg1 == NULL) SWIG_fail;
9074 temp1 = true;
9075 }
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 result = FileSystem_URLToFileName((wxString const &)*arg1);
9079
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 {
9084 #if wxUSE_UNICODE
9085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9086 #else
9087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9088 #endif
9089 }
9090 {
9091 if (temp1)
9092 delete arg1;
9093 }
9094 return resultobj;
9095 fail:
9096 {
9097 if (temp1)
9098 delete arg1;
9099 }
9100 return NULL;
9101 }
9102
9103
9104 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9105 PyObject *obj;
9106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9107 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9108 Py_INCREF(obj);
9109 return Py_BuildValue((char *)"");
9110 }
9111 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj;
9113 wxInternetFSHandler *result;
9114 char *kwnames[] = {
9115 NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9119 {
9120 PyThreadState* __tstate = wxPyBeginAllowThreads();
9121 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9122
9123 wxPyEndAllowThreads(__tstate);
9124 if (PyErr_Occurred()) SWIG_fail;
9125 }
9126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9127 return resultobj;
9128 fail:
9129 return NULL;
9130 }
9131
9132
9133 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9134 PyObject *resultobj;
9135 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9136 wxString *arg2 = 0 ;
9137 bool result;
9138 bool temp2 = false ;
9139 PyObject * obj0 = 0 ;
9140 PyObject * obj1 = 0 ;
9141 char *kwnames[] = {
9142 (char *) "self",(char *) "location", NULL
9143 };
9144
9145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9147 if (SWIG_arg_fail(1)) SWIG_fail;
9148 {
9149 arg2 = wxString_in_helper(obj1);
9150 if (arg2 == NULL) SWIG_fail;
9151 temp2 = true;
9152 }
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9156
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 {
9161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9162 }
9163 {
9164 if (temp2)
9165 delete arg2;
9166 }
9167 return resultobj;
9168 fail:
9169 {
9170 if (temp2)
9171 delete arg2;
9172 }
9173 return NULL;
9174 }
9175
9176
9177 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj;
9179 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9180 wxFileSystem *arg2 = 0 ;
9181 wxString *arg3 = 0 ;
9182 wxFSFile *result;
9183 bool temp3 = false ;
9184 PyObject * obj0 = 0 ;
9185 PyObject * obj1 = 0 ;
9186 PyObject * obj2 = 0 ;
9187 char *kwnames[] = {
9188 (char *) "self",(char *) "fs",(char *) "location", NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9193 if (SWIG_arg_fail(1)) SWIG_fail;
9194 {
9195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9196 if (SWIG_arg_fail(2)) SWIG_fail;
9197 if (arg2 == NULL) {
9198 SWIG_null_ref("wxFileSystem");
9199 }
9200 if (SWIG_arg_fail(2)) SWIG_fail;
9201 }
9202 {
9203 arg3 = wxString_in_helper(obj2);
9204 if (arg3 == NULL) SWIG_fail;
9205 temp3 = true;
9206 }
9207 {
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9210
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 {
9215 resultobj = wxPyMake_wxObject(result, 1);
9216 }
9217 {
9218 if (temp3)
9219 delete arg3;
9220 }
9221 return resultobj;
9222 fail:
9223 {
9224 if (temp3)
9225 delete arg3;
9226 }
9227 return NULL;
9228 }
9229
9230
9231 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9232 PyObject *obj;
9233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9234 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9235 Py_INCREF(obj);
9236 return Py_BuildValue((char *)"");
9237 }
9238 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj;
9240 wxZipFSHandler *result;
9241 char *kwnames[] = {
9242 NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9246 {
9247 PyThreadState* __tstate = wxPyBeginAllowThreads();
9248 result = (wxZipFSHandler *)new wxZipFSHandler();
9249
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj;
9262 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9263 wxString *arg2 = 0 ;
9264 bool result;
9265 bool temp2 = false ;
9266 PyObject * obj0 = 0 ;
9267 PyObject * obj1 = 0 ;
9268 char *kwnames[] = {
9269 (char *) "self",(char *) "location", NULL
9270 };
9271
9272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9274 if (SWIG_arg_fail(1)) SWIG_fail;
9275 {
9276 arg2 = wxString_in_helper(obj1);
9277 if (arg2 == NULL) SWIG_fail;
9278 temp2 = true;
9279 }
9280 {
9281 PyThreadState* __tstate = wxPyBeginAllowThreads();
9282 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9283
9284 wxPyEndAllowThreads(__tstate);
9285 if (PyErr_Occurred()) SWIG_fail;
9286 }
9287 {
9288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9289 }
9290 {
9291 if (temp2)
9292 delete arg2;
9293 }
9294 return resultobj;
9295 fail:
9296 {
9297 if (temp2)
9298 delete arg2;
9299 }
9300 return NULL;
9301 }
9302
9303
9304 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9305 PyObject *resultobj;
9306 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9307 wxFileSystem *arg2 = 0 ;
9308 wxString *arg3 = 0 ;
9309 wxFSFile *result;
9310 bool temp3 = false ;
9311 PyObject * obj0 = 0 ;
9312 PyObject * obj1 = 0 ;
9313 PyObject * obj2 = 0 ;
9314 char *kwnames[] = {
9315 (char *) "self",(char *) "fs",(char *) "location", NULL
9316 };
9317
9318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9320 if (SWIG_arg_fail(1)) SWIG_fail;
9321 {
9322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9323 if (SWIG_arg_fail(2)) SWIG_fail;
9324 if (arg2 == NULL) {
9325 SWIG_null_ref("wxFileSystem");
9326 }
9327 if (SWIG_arg_fail(2)) SWIG_fail;
9328 }
9329 {
9330 arg3 = wxString_in_helper(obj2);
9331 if (arg3 == NULL) SWIG_fail;
9332 temp3 = true;
9333 }
9334 {
9335 PyThreadState* __tstate = wxPyBeginAllowThreads();
9336 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9337
9338 wxPyEndAllowThreads(__tstate);
9339 if (PyErr_Occurred()) SWIG_fail;
9340 }
9341 {
9342 resultobj = wxPyMake_wxObject(result, 1);
9343 }
9344 {
9345 if (temp3)
9346 delete arg3;
9347 }
9348 return resultobj;
9349 fail:
9350 {
9351 if (temp3)
9352 delete arg3;
9353 }
9354 return NULL;
9355 }
9356
9357
9358 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9359 PyObject *resultobj;
9360 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9361 wxString *arg2 = 0 ;
9362 int arg3 = (int) 0 ;
9363 wxString result;
9364 bool temp2 = false ;
9365 PyObject * obj0 = 0 ;
9366 PyObject * obj1 = 0 ;
9367 PyObject * obj2 = 0 ;
9368 char *kwnames[] = {
9369 (char *) "self",(char *) "spec",(char *) "flags", NULL
9370 };
9371
9372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9374 if (SWIG_arg_fail(1)) SWIG_fail;
9375 {
9376 arg2 = wxString_in_helper(obj1);
9377 if (arg2 == NULL) SWIG_fail;
9378 temp2 = true;
9379 }
9380 if (obj2) {
9381 {
9382 arg3 = (int)(SWIG_As_int(obj2));
9383 if (SWIG_arg_fail(3)) SWIG_fail;
9384 }
9385 }
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9389
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 {
9394 #if wxUSE_UNICODE
9395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9396 #else
9397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9398 #endif
9399 }
9400 {
9401 if (temp2)
9402 delete arg2;
9403 }
9404 return resultobj;
9405 fail:
9406 {
9407 if (temp2)
9408 delete arg2;
9409 }
9410 return NULL;
9411 }
9412
9413
9414 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9415 PyObject *resultobj;
9416 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9417 wxString result;
9418 PyObject * obj0 = 0 ;
9419 char *kwnames[] = {
9420 (char *) "self", NULL
9421 };
9422
9423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9425 if (SWIG_arg_fail(1)) SWIG_fail;
9426 {
9427 PyThreadState* __tstate = wxPyBeginAllowThreads();
9428 result = (arg1)->FindNext();
9429
9430 wxPyEndAllowThreads(__tstate);
9431 if (PyErr_Occurred()) SWIG_fail;
9432 }
9433 {
9434 #if wxUSE_UNICODE
9435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9436 #else
9437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9438 #endif
9439 }
9440 return resultobj;
9441 fail:
9442 return NULL;
9443 }
9444
9445
9446 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9447 PyObject *obj;
9448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9449 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9450 Py_INCREF(obj);
9451 return Py_BuildValue((char *)"");
9452 }
9453 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj;
9455 wxString *arg1 = 0 ;
9456 wxImage *arg2 = 0 ;
9457 long arg3 ;
9458 bool temp1 = false ;
9459 PyObject * obj0 = 0 ;
9460 PyObject * obj1 = 0 ;
9461 PyObject * obj2 = 0 ;
9462 char *kwnames[] = {
9463 (char *) "filename",(char *) "image",(char *) "type", NULL
9464 };
9465
9466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9467 {
9468 arg1 = wxString_in_helper(obj0);
9469 if (arg1 == NULL) SWIG_fail;
9470 temp1 = true;
9471 }
9472 {
9473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9474 if (SWIG_arg_fail(2)) SWIG_fail;
9475 if (arg2 == NULL) {
9476 SWIG_null_ref("wxImage");
9477 }
9478 if (SWIG_arg_fail(2)) SWIG_fail;
9479 }
9480 {
9481 arg3 = (long)(SWIG_As_long(obj2));
9482 if (SWIG_arg_fail(3)) SWIG_fail;
9483 }
9484 {
9485 PyThreadState* __tstate = wxPyBeginAllowThreads();
9486 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9487
9488 wxPyEndAllowThreads(__tstate);
9489 if (PyErr_Occurred()) SWIG_fail;
9490 }
9491 Py_INCREF(Py_None); resultobj = Py_None;
9492 {
9493 if (temp1)
9494 delete arg1;
9495 }
9496 return resultobj;
9497 fail:
9498 {
9499 if (temp1)
9500 delete arg1;
9501 }
9502 return NULL;
9503 }
9504
9505
9506 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9507 PyObject *resultobj;
9508 wxString *arg1 = 0 ;
9509 wxBitmap *arg2 = 0 ;
9510 long arg3 ;
9511 bool temp1 = false ;
9512 PyObject * obj0 = 0 ;
9513 PyObject * obj1 = 0 ;
9514 PyObject * obj2 = 0 ;
9515 char *kwnames[] = {
9516 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9517 };
9518
9519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9520 {
9521 arg1 = wxString_in_helper(obj0);
9522 if (arg1 == NULL) SWIG_fail;
9523 temp1 = true;
9524 }
9525 {
9526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9527 if (SWIG_arg_fail(2)) SWIG_fail;
9528 if (arg2 == NULL) {
9529 SWIG_null_ref("wxBitmap");
9530 }
9531 if (SWIG_arg_fail(2)) SWIG_fail;
9532 }
9533 {
9534 arg3 = (long)(SWIG_As_long(obj2));
9535 if (SWIG_arg_fail(3)) SWIG_fail;
9536 }
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 Py_INCREF(Py_None); resultobj = Py_None;
9545 {
9546 if (temp1)
9547 delete arg1;
9548 }
9549 return resultobj;
9550 fail:
9551 {
9552 if (temp1)
9553 delete arg1;
9554 }
9555 return NULL;
9556 }
9557
9558
9559 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj;
9561 wxString *arg1 = 0 ;
9562 PyObject *arg2 = (PyObject *) 0 ;
9563 bool temp1 = false ;
9564 PyObject * obj0 = 0 ;
9565 PyObject * obj1 = 0 ;
9566 char *kwnames[] = {
9567 (char *) "filename",(char *) "data", NULL
9568 };
9569
9570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9571 {
9572 arg1 = wxString_in_helper(obj0);
9573 if (arg1 == NULL) SWIG_fail;
9574 temp1 = true;
9575 }
9576 arg2 = obj1;
9577 {
9578 PyThreadState* __tstate = wxPyBeginAllowThreads();
9579 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9580
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 Py_INCREF(Py_None); resultobj = Py_None;
9585 {
9586 if (temp1)
9587 delete arg1;
9588 }
9589 return resultobj;
9590 fail:
9591 {
9592 if (temp1)
9593 delete arg1;
9594 }
9595 return NULL;
9596 }
9597
9598
9599 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj;
9601 wxMemoryFSHandler *result;
9602 char *kwnames[] = {
9603 NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9610
9611 wxPyEndAllowThreads(__tstate);
9612 if (PyErr_Occurred()) SWIG_fail;
9613 }
9614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9615 return resultobj;
9616 fail:
9617 return NULL;
9618 }
9619
9620
9621 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9622 PyObject *resultobj;
9623 wxString *arg1 = 0 ;
9624 bool temp1 = false ;
9625 PyObject * obj0 = 0 ;
9626 char *kwnames[] = {
9627 (char *) "filename", NULL
9628 };
9629
9630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9631 {
9632 arg1 = wxString_in_helper(obj0);
9633 if (arg1 == NULL) SWIG_fail;
9634 temp1 = true;
9635 }
9636 {
9637 PyThreadState* __tstate = wxPyBeginAllowThreads();
9638 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9639
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 Py_INCREF(Py_None); resultobj = Py_None;
9644 {
9645 if (temp1)
9646 delete arg1;
9647 }
9648 return resultobj;
9649 fail:
9650 {
9651 if (temp1)
9652 delete arg1;
9653 }
9654 return NULL;
9655 }
9656
9657
9658 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj;
9660 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9661 wxString *arg2 = 0 ;
9662 bool result;
9663 bool temp2 = false ;
9664 PyObject * obj0 = 0 ;
9665 PyObject * obj1 = 0 ;
9666 char *kwnames[] = {
9667 (char *) "self",(char *) "location", NULL
9668 };
9669
9670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9672 if (SWIG_arg_fail(1)) SWIG_fail;
9673 {
9674 arg2 = wxString_in_helper(obj1);
9675 if (arg2 == NULL) SWIG_fail;
9676 temp2 = true;
9677 }
9678 {
9679 PyThreadState* __tstate = wxPyBeginAllowThreads();
9680 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9681
9682 wxPyEndAllowThreads(__tstate);
9683 if (PyErr_Occurred()) SWIG_fail;
9684 }
9685 {
9686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9687 }
9688 {
9689 if (temp2)
9690 delete arg2;
9691 }
9692 return resultobj;
9693 fail:
9694 {
9695 if (temp2)
9696 delete arg2;
9697 }
9698 return NULL;
9699 }
9700
9701
9702 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj;
9704 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9705 wxFileSystem *arg2 = 0 ;
9706 wxString *arg3 = 0 ;
9707 wxFSFile *result;
9708 bool temp3 = false ;
9709 PyObject * obj0 = 0 ;
9710 PyObject * obj1 = 0 ;
9711 PyObject * obj2 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "self",(char *) "fs",(char *) "location", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(1)) SWIG_fail;
9719 {
9720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9721 if (SWIG_arg_fail(2)) SWIG_fail;
9722 if (arg2 == NULL) {
9723 SWIG_null_ref("wxFileSystem");
9724 }
9725 if (SWIG_arg_fail(2)) SWIG_fail;
9726 }
9727 {
9728 arg3 = wxString_in_helper(obj2);
9729 if (arg3 == NULL) SWIG_fail;
9730 temp3 = true;
9731 }
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9735
9736 wxPyEndAllowThreads(__tstate);
9737 if (PyErr_Occurred()) SWIG_fail;
9738 }
9739 {
9740 resultobj = wxPyMake_wxObject(result, 1);
9741 }
9742 {
9743 if (temp3)
9744 delete arg3;
9745 }
9746 return resultobj;
9747 fail:
9748 {
9749 if (temp3)
9750 delete arg3;
9751 }
9752 return NULL;
9753 }
9754
9755
9756 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj;
9758 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9759 wxString *arg2 = 0 ;
9760 int arg3 = (int) 0 ;
9761 wxString result;
9762 bool temp2 = false ;
9763 PyObject * obj0 = 0 ;
9764 PyObject * obj1 = 0 ;
9765 PyObject * obj2 = 0 ;
9766 char *kwnames[] = {
9767 (char *) "self",(char *) "spec",(char *) "flags", NULL
9768 };
9769
9770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9772 if (SWIG_arg_fail(1)) SWIG_fail;
9773 {
9774 arg2 = wxString_in_helper(obj1);
9775 if (arg2 == NULL) SWIG_fail;
9776 temp2 = true;
9777 }
9778 if (obj2) {
9779 {
9780 arg3 = (int)(SWIG_As_int(obj2));
9781 if (SWIG_arg_fail(3)) SWIG_fail;
9782 }
9783 }
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9787
9788 wxPyEndAllowThreads(__tstate);
9789 if (PyErr_Occurred()) SWIG_fail;
9790 }
9791 {
9792 #if wxUSE_UNICODE
9793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9794 #else
9795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9796 #endif
9797 }
9798 {
9799 if (temp2)
9800 delete arg2;
9801 }
9802 return resultobj;
9803 fail:
9804 {
9805 if (temp2)
9806 delete arg2;
9807 }
9808 return NULL;
9809 }
9810
9811
9812 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9813 PyObject *resultobj;
9814 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9815 wxString result;
9816 PyObject * obj0 = 0 ;
9817 char *kwnames[] = {
9818 (char *) "self", NULL
9819 };
9820
9821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9823 if (SWIG_arg_fail(1)) SWIG_fail;
9824 {
9825 PyThreadState* __tstate = wxPyBeginAllowThreads();
9826 result = (arg1)->FindNext();
9827
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 {
9832 #if wxUSE_UNICODE
9833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9834 #else
9835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9836 #endif
9837 }
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9845 PyObject *obj;
9846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9847 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9848 Py_INCREF(obj);
9849 return Py_BuildValue((char *)"");
9850 }
9851 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj;
9853 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9854 wxString result;
9855 PyObject * obj0 = 0 ;
9856 char *kwnames[] = {
9857 (char *) "self", NULL
9858 };
9859
9860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9862 if (SWIG_arg_fail(1)) SWIG_fail;
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 result = (arg1)->GetName();
9866
9867 wxPyEndAllowThreads(__tstate);
9868 if (PyErr_Occurred()) SWIG_fail;
9869 }
9870 {
9871 #if wxUSE_UNICODE
9872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9873 #else
9874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9875 #endif
9876 }
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9884 PyObject *resultobj;
9885 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9886 wxString result;
9887 PyObject * obj0 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "self", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 result = (arg1)->GetExtension();
9898
9899 wxPyEndAllowThreads(__tstate);
9900 if (PyErr_Occurred()) SWIG_fail;
9901 }
9902 {
9903 #if wxUSE_UNICODE
9904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9905 #else
9906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9907 #endif
9908 }
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj;
9917 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9918 long result;
9919 PyObject * obj0 = 0 ;
9920 char *kwnames[] = {
9921 (char *) "self", NULL
9922 };
9923
9924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9926 if (SWIG_arg_fail(1)) SWIG_fail;
9927 {
9928 PyThreadState* __tstate = wxPyBeginAllowThreads();
9929 result = (long)(arg1)->GetType();
9930
9931 wxPyEndAllowThreads(__tstate);
9932 if (PyErr_Occurred()) SWIG_fail;
9933 }
9934 {
9935 resultobj = SWIG_From_long((long)(result));
9936 }
9937 return resultobj;
9938 fail:
9939 return NULL;
9940 }
9941
9942
9943 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9944 PyObject *resultobj;
9945 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9946 wxString result;
9947 PyObject * obj0 = 0 ;
9948 char *kwnames[] = {
9949 (char *) "self", NULL
9950 };
9951
9952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9954 if (SWIG_arg_fail(1)) SWIG_fail;
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = (arg1)->GetMimeType();
9958
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 #if wxUSE_UNICODE
9964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9965 #else
9966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9967 #endif
9968 }
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj;
9977 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9978 wxString *arg2 = 0 ;
9979 bool result;
9980 bool temp2 = false ;
9981 PyObject * obj0 = 0 ;
9982 PyObject * obj1 = 0 ;
9983 char *kwnames[] = {
9984 (char *) "self",(char *) "name", NULL
9985 };
9986
9987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9989 if (SWIG_arg_fail(1)) SWIG_fail;
9990 {
9991 arg2 = wxString_in_helper(obj1);
9992 if (arg2 == NULL) SWIG_fail;
9993 temp2 = true;
9994 }
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9998
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 {
10003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10004 }
10005 {
10006 if (temp2)
10007 delete arg2;
10008 }
10009 return resultobj;
10010 fail:
10011 {
10012 if (temp2)
10013 delete arg2;
10014 }
10015 return NULL;
10016 }
10017
10018
10019 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj;
10021 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10022 wxString *arg2 = 0 ;
10023 bool temp2 = false ;
10024 PyObject * obj0 = 0 ;
10025 PyObject * obj1 = 0 ;
10026 char *kwnames[] = {
10027 (char *) "self",(char *) "name", NULL
10028 };
10029
10030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10032 if (SWIG_arg_fail(1)) SWIG_fail;
10033 {
10034 arg2 = wxString_in_helper(obj1);
10035 if (arg2 == NULL) SWIG_fail;
10036 temp2 = true;
10037 }
10038 {
10039 PyThreadState* __tstate = wxPyBeginAllowThreads();
10040 (arg1)->SetName((wxString const &)*arg2);
10041
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 Py_INCREF(Py_None); resultobj = Py_None;
10046 {
10047 if (temp2)
10048 delete arg2;
10049 }
10050 return resultobj;
10051 fail:
10052 {
10053 if (temp2)
10054 delete arg2;
10055 }
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10063 wxString *arg2 = 0 ;
10064 bool temp2 = false ;
10065 PyObject * obj0 = 0 ;
10066 PyObject * obj1 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "self",(char *) "extension", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10073 if (SWIG_arg_fail(1)) SWIG_fail;
10074 {
10075 arg2 = wxString_in_helper(obj1);
10076 if (arg2 == NULL) SWIG_fail;
10077 temp2 = true;
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 (arg1)->SetExtension((wxString const &)*arg2);
10082
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 Py_INCREF(Py_None); resultobj = Py_None;
10087 {
10088 if (temp2)
10089 delete arg2;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp2)
10095 delete arg2;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj;
10103 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10104 long arg2 ;
10105 PyObject * obj0 = 0 ;
10106 PyObject * obj1 = 0 ;
10107 char *kwnames[] = {
10108 (char *) "self",(char *) "type", NULL
10109 };
10110
10111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10113 if (SWIG_arg_fail(1)) SWIG_fail;
10114 {
10115 arg2 = (long)(SWIG_As_long(obj1));
10116 if (SWIG_arg_fail(2)) SWIG_fail;
10117 }
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 (arg1)->SetType(arg2);
10121
10122 wxPyEndAllowThreads(__tstate);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 Py_INCREF(Py_None); resultobj = Py_None;
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10133 PyObject *resultobj;
10134 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10135 wxString *arg2 = 0 ;
10136 bool temp2 = false ;
10137 PyObject * obj0 = 0 ;
10138 PyObject * obj1 = 0 ;
10139 char *kwnames[] = {
10140 (char *) "self",(char *) "mimetype", NULL
10141 };
10142
10143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10145 if (SWIG_arg_fail(1)) SWIG_fail;
10146 {
10147 arg2 = wxString_in_helper(obj1);
10148 if (arg2 == NULL) SWIG_fail;
10149 temp2 = true;
10150 }
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 (arg1)->SetMimeType((wxString const &)*arg2);
10154
10155 wxPyEndAllowThreads(__tstate);
10156 if (PyErr_Occurred()) SWIG_fail;
10157 }
10158 Py_INCREF(Py_None); resultobj = Py_None;
10159 {
10160 if (temp2)
10161 delete arg2;
10162 }
10163 return resultobj;
10164 fail:
10165 {
10166 if (temp2)
10167 delete arg2;
10168 }
10169 return NULL;
10170 }
10171
10172
10173 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10174 PyObject *obj;
10175 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10176 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10177 Py_INCREF(obj);
10178 return Py_BuildValue((char *)"");
10179 }
10180 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10181 PyObject *resultobj;
10182 wxImageHistogram *result;
10183 char *kwnames[] = {
10184 NULL
10185 };
10186
10187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (wxImageHistogram *)new wxImageHistogram();
10191
10192 wxPyEndAllowThreads(__tstate);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj;
10204 unsigned char arg1 ;
10205 unsigned char arg2 ;
10206 unsigned char arg3 ;
10207 unsigned long result;
10208 PyObject * obj0 = 0 ;
10209 PyObject * obj1 = 0 ;
10210 PyObject * obj2 = 0 ;
10211 char *kwnames[] = {
10212 (char *) "r",(char *) "g",(char *) "b", NULL
10213 };
10214
10215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10216 {
10217 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10218 if (SWIG_arg_fail(1)) SWIG_fail;
10219 }
10220 {
10221 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10222 if (SWIG_arg_fail(2)) SWIG_fail;
10223 }
10224 {
10225 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10226 if (SWIG_arg_fail(3)) SWIG_fail;
10227 }
10228 {
10229 PyThreadState* __tstate = wxPyBeginAllowThreads();
10230 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10231
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 {
10236 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10237 }
10238 return resultobj;
10239 fail:
10240 return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj;
10246 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10247 unsigned char *arg2 = (unsigned char *) 0 ;
10248 unsigned char *arg3 = (unsigned char *) 0 ;
10249 unsigned char *arg4 = (unsigned char *) 0 ;
10250 unsigned char arg5 = (unsigned char) 1 ;
10251 unsigned char arg6 = (unsigned char) 0 ;
10252 unsigned char arg7 = (unsigned char) 0 ;
10253 bool result;
10254 unsigned char temp2 ;
10255 int res2 = 0 ;
10256 unsigned char temp3 ;
10257 int res3 = 0 ;
10258 unsigned char temp4 ;
10259 int res4 = 0 ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 PyObject * obj2 = 0 ;
10263 PyObject * obj3 = 0 ;
10264 char *kwnames[] = {
10265 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10266 };
10267
10268 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10269 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10270 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10273 if (SWIG_arg_fail(1)) SWIG_fail;
10274 if (obj1) {
10275 {
10276 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10277 if (SWIG_arg_fail(5)) SWIG_fail;
10278 }
10279 }
10280 if (obj2) {
10281 {
10282 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10283 if (SWIG_arg_fail(6)) SWIG_fail;
10284 }
10285 }
10286 if (obj3) {
10287 {
10288 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10289 if (SWIG_arg_fail(7)) SWIG_fail;
10290 }
10291 }
10292 {
10293 PyThreadState* __tstate = wxPyBeginAllowThreads();
10294 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10295
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 {
10300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10301 }
10302 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10303 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10304 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10305 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10306 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10307 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10308 return resultobj;
10309 fail:
10310 return NULL;
10311 }
10312
10313
10314 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10315 PyObject *obj;
10316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10317 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10318 Py_INCREF(obj);
10319 return Py_BuildValue((char *)"");
10320 }
10321 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj;
10323 wxString *arg1 = 0 ;
10324 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10325 int arg3 = (int) -1 ;
10326 wxImage *result;
10327 bool temp1 = false ;
10328 PyObject * obj0 = 0 ;
10329 PyObject * obj1 = 0 ;
10330 PyObject * obj2 = 0 ;
10331 char *kwnames[] = {
10332 (char *) "name",(char *) "type",(char *) "index", NULL
10333 };
10334
10335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10336 {
10337 arg1 = wxString_in_helper(obj0);
10338 if (arg1 == NULL) SWIG_fail;
10339 temp1 = true;
10340 }
10341 if (obj1) {
10342 {
10343 arg2 = (long)(SWIG_As_long(obj1));
10344 if (SWIG_arg_fail(2)) SWIG_fail;
10345 }
10346 }
10347 if (obj2) {
10348 {
10349 arg3 = (int)(SWIG_As_int(obj2));
10350 if (SWIG_arg_fail(3)) SWIG_fail;
10351 }
10352 }
10353 {
10354 PyThreadState* __tstate = wxPyBeginAllowThreads();
10355 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10356
10357 wxPyEndAllowThreads(__tstate);
10358 if (PyErr_Occurred()) SWIG_fail;
10359 }
10360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10361 {
10362 if (temp1)
10363 delete arg1;
10364 }
10365 return resultobj;
10366 fail:
10367 {
10368 if (temp1)
10369 delete arg1;
10370 }
10371 return NULL;
10372 }
10373
10374
10375 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj;
10377 wxImage *arg1 = (wxImage *) 0 ;
10378 PyObject * obj0 = 0 ;
10379 char *kwnames[] = {
10380 (char *) "self", NULL
10381 };
10382
10383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10385 if (SWIG_arg_fail(1)) SWIG_fail;
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 delete arg1;
10389
10390 wxPyEndAllowThreads(__tstate);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 Py_INCREF(Py_None); resultobj = Py_None;
10394 return resultobj;
10395 fail:
10396 return NULL;
10397 }
10398
10399
10400 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj;
10402 wxString *arg1 = 0 ;
10403 wxString *arg2 = 0 ;
10404 int arg3 = (int) -1 ;
10405 wxImage *result;
10406 bool temp1 = false ;
10407 bool temp2 = false ;
10408 PyObject * obj0 = 0 ;
10409 PyObject * obj1 = 0 ;
10410 PyObject * obj2 = 0 ;
10411 char *kwnames[] = {
10412 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10413 };
10414
10415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10416 {
10417 arg1 = wxString_in_helper(obj0);
10418 if (arg1 == NULL) SWIG_fail;
10419 temp1 = true;
10420 }
10421 {
10422 arg2 = wxString_in_helper(obj1);
10423 if (arg2 == NULL) SWIG_fail;
10424 temp2 = true;
10425 }
10426 if (obj2) {
10427 {
10428 arg3 = (int)(SWIG_As_int(obj2));
10429 if (SWIG_arg_fail(3)) SWIG_fail;
10430 }
10431 }
10432 {
10433 PyThreadState* __tstate = wxPyBeginAllowThreads();
10434 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10435
10436 wxPyEndAllowThreads(__tstate);
10437 if (PyErr_Occurred()) SWIG_fail;
10438 }
10439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10440 {
10441 if (temp1)
10442 delete arg1;
10443 }
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return resultobj;
10449 fail:
10450 {
10451 if (temp1)
10452 delete arg1;
10453 }
10454 {
10455 if (temp2)
10456 delete arg2;
10457 }
10458 return NULL;
10459 }
10460
10461
10462 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj;
10464 wxInputStream *arg1 = 0 ;
10465 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10466 int arg3 = (int) -1 ;
10467 wxImage *result;
10468 wxPyInputStream *temp1 ;
10469 bool created1 ;
10470 PyObject * obj0 = 0 ;
10471 PyObject * obj1 = 0 ;
10472 PyObject * obj2 = 0 ;
10473 char *kwnames[] = {
10474 (char *) "stream",(char *) "type",(char *) "index", NULL
10475 };
10476
10477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10478 {
10479 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10480 arg1 = temp1->m_wxis;
10481 created1 = false;
10482 } else {
10483 PyErr_Clear(); // clear the failure of the wxPyConvert above
10484 arg1 = wxPyCBInputStream_create(obj0, false);
10485 if (arg1 == NULL) {
10486 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10487 SWIG_fail;
10488 }
10489 created1 = true;
10490 }
10491 }
10492 if (obj1) {
10493 {
10494 arg2 = (long)(SWIG_As_long(obj1));
10495 if (SWIG_arg_fail(2)) SWIG_fail;
10496 }
10497 }
10498 if (obj2) {
10499 {
10500 arg3 = (int)(SWIG_As_int(obj2));
10501 if (SWIG_arg_fail(3)) SWIG_fail;
10502 }
10503 }
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10512 {
10513 if (created1)
10514 delete arg1;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (created1)
10520 delete arg1;
10521 }
10522 return NULL;
10523 }
10524
10525
10526 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10527 PyObject *resultobj;
10528 wxInputStream *arg1 = 0 ;
10529 wxString *arg2 = 0 ;
10530 int arg3 = (int) -1 ;
10531 wxImage *result;
10532 wxPyInputStream *temp1 ;
10533 bool created1 ;
10534 bool temp2 = false ;
10535 PyObject * obj0 = 0 ;
10536 PyObject * obj1 = 0 ;
10537 PyObject * obj2 = 0 ;
10538 char *kwnames[] = {
10539 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10540 };
10541
10542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10543 {
10544 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10545 arg1 = temp1->m_wxis;
10546 created1 = false;
10547 } else {
10548 PyErr_Clear(); // clear the failure of the wxPyConvert above
10549 arg1 = wxPyCBInputStream_create(obj0, false);
10550 if (arg1 == NULL) {
10551 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10552 SWIG_fail;
10553 }
10554 created1 = true;
10555 }
10556 }
10557 {
10558 arg2 = wxString_in_helper(obj1);
10559 if (arg2 == NULL) SWIG_fail;
10560 temp2 = true;
10561 }
10562 if (obj2) {
10563 {
10564 arg3 = (int)(SWIG_As_int(obj2));
10565 if (SWIG_arg_fail(3)) SWIG_fail;
10566 }
10567 }
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10571
10572 wxPyEndAllowThreads(__tstate);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10576 {
10577 if (created1)
10578 delete arg1;
10579 }
10580 {
10581 if (temp2)
10582 delete arg2;
10583 }
10584 return resultobj;
10585 fail:
10586 {
10587 if (created1)
10588 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_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10945 PyObject *resultobj;
10946 wxImage *arg1 = (wxImage *) 0 ;
10947 int arg2 ;
10948 int arg3 ;
10949 unsigned char arg4 ;
10950 unsigned char arg5 ;
10951 unsigned char arg6 ;
10952 PyObject * obj0 = 0 ;
10953 PyObject * obj1 = 0 ;
10954 PyObject * obj2 = 0 ;
10955 PyObject * obj3 = 0 ;
10956 PyObject * obj4 = 0 ;
10957 PyObject * obj5 = 0 ;
10958 char *kwnames[] = {
10959 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10960 };
10961
10962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10964 if (SWIG_arg_fail(1)) SWIG_fail;
10965 {
10966 arg2 = (int)(SWIG_As_int(obj1));
10967 if (SWIG_arg_fail(2)) SWIG_fail;
10968 }
10969 {
10970 arg3 = (int)(SWIG_As_int(obj2));
10971 if (SWIG_arg_fail(3)) SWIG_fail;
10972 }
10973 {
10974 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10975 if (SWIG_arg_fail(4)) SWIG_fail;
10976 }
10977 {
10978 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10979 if (SWIG_arg_fail(5)) SWIG_fail;
10980 }
10981 {
10982 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10983 if (SWIG_arg_fail(6)) SWIG_fail;
10984 }
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 Py_INCREF(Py_None); resultobj = Py_None;
10993 return resultobj;
10994 fail:
10995 return NULL;
10996 }
10997
10998
10999 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11000 PyObject *resultobj;
11001 wxImage *arg1 = (wxImage *) 0 ;
11002 int arg2 ;
11003 int arg3 ;
11004 unsigned char result;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 PyObject * obj2 = 0 ;
11008 char *kwnames[] = {
11009 (char *) "self",(char *) "x",(char *) "y", NULL
11010 };
11011
11012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11014 if (SWIG_arg_fail(1)) SWIG_fail;
11015 {
11016 arg2 = (int)(SWIG_As_int(obj1));
11017 if (SWIG_arg_fail(2)) SWIG_fail;
11018 }
11019 {
11020 arg3 = (int)(SWIG_As_int(obj2));
11021 if (SWIG_arg_fail(3)) SWIG_fail;
11022 }
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11026
11027 wxPyEndAllowThreads(__tstate);
11028 if (PyErr_Occurred()) SWIG_fail;
11029 }
11030 {
11031 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11032 }
11033 return resultobj;
11034 fail:
11035 return NULL;
11036 }
11037
11038
11039 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11040 PyObject *resultobj;
11041 wxImage *arg1 = (wxImage *) 0 ;
11042 int arg2 ;
11043 int arg3 ;
11044 unsigned char result;
11045 PyObject * obj0 = 0 ;
11046 PyObject * obj1 = 0 ;
11047 PyObject * obj2 = 0 ;
11048 char *kwnames[] = {
11049 (char *) "self",(char *) "x",(char *) "y", NULL
11050 };
11051
11052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11054 if (SWIG_arg_fail(1)) SWIG_fail;
11055 {
11056 arg2 = (int)(SWIG_As_int(obj1));
11057 if (SWIG_arg_fail(2)) SWIG_fail;
11058 }
11059 {
11060 arg3 = (int)(SWIG_As_int(obj2));
11061 if (SWIG_arg_fail(3)) SWIG_fail;
11062 }
11063 {
11064 PyThreadState* __tstate = wxPyBeginAllowThreads();
11065 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11066
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 {
11071 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11072 }
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11080 PyObject *resultobj;
11081 wxImage *arg1 = (wxImage *) 0 ;
11082 int arg2 ;
11083 int arg3 ;
11084 unsigned char result;
11085 PyObject * obj0 = 0 ;
11086 PyObject * obj1 = 0 ;
11087 PyObject * obj2 = 0 ;
11088 char *kwnames[] = {
11089 (char *) "self",(char *) "x",(char *) "y", NULL
11090 };
11091
11092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11094 if (SWIG_arg_fail(1)) SWIG_fail;
11095 {
11096 arg2 = (int)(SWIG_As_int(obj1));
11097 if (SWIG_arg_fail(2)) SWIG_fail;
11098 }
11099 {
11100 arg3 = (int)(SWIG_As_int(obj2));
11101 if (SWIG_arg_fail(3)) SWIG_fail;
11102 }
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11106
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 {
11111 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11112 }
11113 return resultobj;
11114 fail:
11115 return NULL;
11116 }
11117
11118
11119 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11120 PyObject *resultobj;
11121 wxImage *arg1 = (wxImage *) 0 ;
11122 int arg2 ;
11123 int arg3 ;
11124 unsigned char arg4 ;
11125 PyObject * obj0 = 0 ;
11126 PyObject * obj1 = 0 ;
11127 PyObject * obj2 = 0 ;
11128 PyObject * obj3 = 0 ;
11129 char *kwnames[] = {
11130 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11131 };
11132
11133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11135 if (SWIG_arg_fail(1)) SWIG_fail;
11136 {
11137 arg2 = (int)(SWIG_As_int(obj1));
11138 if (SWIG_arg_fail(2)) SWIG_fail;
11139 }
11140 {
11141 arg3 = (int)(SWIG_As_int(obj2));
11142 if (SWIG_arg_fail(3)) SWIG_fail;
11143 }
11144 {
11145 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11146 if (SWIG_arg_fail(4)) SWIG_fail;
11147 }
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 (arg1)->SetAlpha(arg2,arg3,arg4);
11151
11152 wxPyEndAllowThreads(__tstate);
11153 if (PyErr_Occurred()) SWIG_fail;
11154 }
11155 Py_INCREF(Py_None); resultobj = Py_None;
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11163 PyObject *resultobj;
11164 wxImage *arg1 = (wxImage *) 0 ;
11165 int arg2 ;
11166 int arg3 ;
11167 unsigned char result;
11168 PyObject * obj0 = 0 ;
11169 PyObject * obj1 = 0 ;
11170 PyObject * obj2 = 0 ;
11171 char *kwnames[] = {
11172 (char *) "self",(char *) "x",(char *) "y", NULL
11173 };
11174
11175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11177 if (SWIG_arg_fail(1)) SWIG_fail;
11178 {
11179 arg2 = (int)(SWIG_As_int(obj1));
11180 if (SWIG_arg_fail(2)) SWIG_fail;
11181 }
11182 {
11183 arg3 = (int)(SWIG_As_int(obj2));
11184 if (SWIG_arg_fail(3)) SWIG_fail;
11185 }
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11189
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11203 PyObject *resultobj;
11204 wxImage *arg1 = (wxImage *) 0 ;
11205 bool result;
11206 PyObject * obj0 = 0 ;
11207 char *kwnames[] = {
11208 (char *) "self", NULL
11209 };
11210
11211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11213 if (SWIG_arg_fail(1)) SWIG_fail;
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (bool)(arg1)->HasAlpha();
11217
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 {
11222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11223 }
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj;
11232 wxImage *arg1 = (wxImage *) 0 ;
11233 PyObject * obj0 = 0 ;
11234 char *kwnames[] = {
11235 (char *) "self", NULL
11236 };
11237
11238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11240 if (SWIG_arg_fail(1)) SWIG_fail;
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 (arg1)->InitAlpha();
11244
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 Py_INCREF(Py_None); resultobj = Py_None;
11249 return resultobj;
11250 fail:
11251 return NULL;
11252 }
11253
11254
11255 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11256 PyObject *resultobj;
11257 wxImage *arg1 = (wxImage *) 0 ;
11258 byte *arg2 = (byte *) 0 ;
11259 byte *arg3 = (byte *) 0 ;
11260 byte *arg4 = (byte *) 0 ;
11261 byte arg5 = (byte) 0 ;
11262 byte arg6 = (byte) 0 ;
11263 byte arg7 = (byte) 0 ;
11264 bool result;
11265 byte temp2 ;
11266 int res2 = 0 ;
11267 byte temp3 ;
11268 int res3 = 0 ;
11269 byte temp4 ;
11270 int res4 = 0 ;
11271 PyObject * obj0 = 0 ;
11272 PyObject * obj1 = 0 ;
11273 PyObject * obj2 = 0 ;
11274 PyObject * obj3 = 0 ;
11275 char *kwnames[] = {
11276 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11277 };
11278
11279 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11280 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11281 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11284 if (SWIG_arg_fail(1)) SWIG_fail;
11285 if (obj1) {
11286 {
11287 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11288 if (SWIG_arg_fail(5)) SWIG_fail;
11289 }
11290 }
11291 if (obj2) {
11292 {
11293 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11294 if (SWIG_arg_fail(6)) SWIG_fail;
11295 }
11296 }
11297 if (obj3) {
11298 {
11299 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11300 if (SWIG_arg_fail(7)) SWIG_fail;
11301 }
11302 }
11303 {
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11306
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 {
11311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11312 }
11313 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11314 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11315 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11316 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11317 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11318 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11319 return resultobj;
11320 fail:
11321 return NULL;
11322 }
11323
11324
11325 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11326 PyObject *resultobj;
11327 wxImage *arg1 = (wxImage *) 0 ;
11328 byte arg2 = (byte) 128 ;
11329 bool result;
11330 PyObject * obj0 = 0 ;
11331 PyObject * obj1 = 0 ;
11332 char *kwnames[] = {
11333 (char *) "self",(char *) "threshold", NULL
11334 };
11335
11336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11338 if (SWIG_arg_fail(1)) SWIG_fail;
11339 if (obj1) {
11340 {
11341 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11342 if (SWIG_arg_fail(2)) SWIG_fail;
11343 }
11344 }
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11348
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 {
11353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11354 }
11355 return resultobj;
11356 fail:
11357 return NULL;
11358 }
11359
11360
11361 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11362 PyObject *resultobj;
11363 wxImage *arg1 = (wxImage *) 0 ;
11364 unsigned char arg2 ;
11365 unsigned char arg3 ;
11366 unsigned char arg4 ;
11367 bool result;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 PyObject * obj3 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 {
11380 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 {
11384 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11385 if (SWIG_arg_fail(3)) SWIG_fail;
11386 }
11387 {
11388 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11389 if (SWIG_arg_fail(4)) SWIG_fail;
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxImage *arg1 = (wxImage *) 0 ;
11410 wxImage *arg2 = 0 ;
11411 byte arg3 ;
11412 byte arg4 ;
11413 byte arg5 ;
11414 bool result;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 PyObject * obj3 = 0 ;
11419 PyObject * obj4 = 0 ;
11420 char *kwnames[] = {
11421 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11422 };
11423
11424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11426 if (SWIG_arg_fail(1)) SWIG_fail;
11427 {
11428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11429 if (SWIG_arg_fail(2)) SWIG_fail;
11430 if (arg2 == NULL) {
11431 SWIG_null_ref("wxImage");
11432 }
11433 if (SWIG_arg_fail(2)) SWIG_fail;
11434 }
11435 {
11436 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11437 if (SWIG_arg_fail(3)) SWIG_fail;
11438 }
11439 {
11440 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11441 if (SWIG_arg_fail(4)) SWIG_fail;
11442 }
11443 {
11444 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11445 if (SWIG_arg_fail(5)) SWIG_fail;
11446 }
11447 {
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11450
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 {
11455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11456 }
11457 return resultobj;
11458 fail:
11459 return NULL;
11460 }
11461
11462
11463 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj;
11465 wxString *arg1 = 0 ;
11466 bool result;
11467 bool temp1 = false ;
11468 PyObject * obj0 = 0 ;
11469 char *kwnames[] = {
11470 (char *) "name", NULL
11471 };
11472
11473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11474 {
11475 arg1 = wxString_in_helper(obj0);
11476 if (arg1 == NULL) SWIG_fail;
11477 temp1 = true;
11478 }
11479 {
11480 PyThreadState* __tstate = wxPyBeginAllowThreads();
11481 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11482
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 {
11487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11488 }
11489 {
11490 if (temp1)
11491 delete arg1;
11492 }
11493 return resultobj;
11494 fail:
11495 {
11496 if (temp1)
11497 delete arg1;
11498 }
11499 return NULL;
11500 }
11501
11502
11503 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxString *arg1 = 0 ;
11506 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11507 int result;
11508 bool temp1 = false ;
11509 PyObject * obj0 = 0 ;
11510 PyObject * obj1 = 0 ;
11511 char *kwnames[] = {
11512 (char *) "name",(char *) "type", NULL
11513 };
11514
11515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11516 {
11517 arg1 = wxString_in_helper(obj0);
11518 if (arg1 == NULL) SWIG_fail;
11519 temp1 = true;
11520 }
11521 if (obj1) {
11522 {
11523 arg2 = (long)(SWIG_As_long(obj1));
11524 if (SWIG_arg_fail(2)) SWIG_fail;
11525 }
11526 }
11527 {
11528 PyThreadState* __tstate = wxPyBeginAllowThreads();
11529 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11530
11531 wxPyEndAllowThreads(__tstate);
11532 if (PyErr_Occurred()) SWIG_fail;
11533 }
11534 {
11535 resultobj = SWIG_From_int((int)(result));
11536 }
11537 {
11538 if (temp1)
11539 delete arg1;
11540 }
11541 return resultobj;
11542 fail:
11543 {
11544 if (temp1)
11545 delete arg1;
11546 }
11547 return NULL;
11548 }
11549
11550
11551 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11552 PyObject *resultobj;
11553 wxImage *arg1 = (wxImage *) 0 ;
11554 wxString *arg2 = 0 ;
11555 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11556 int arg4 = (int) -1 ;
11557 bool result;
11558 bool temp2 = false ;
11559 PyObject * obj0 = 0 ;
11560 PyObject * obj1 = 0 ;
11561 PyObject * obj2 = 0 ;
11562 PyObject * obj3 = 0 ;
11563 char *kwnames[] = {
11564 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11565 };
11566
11567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11569 if (SWIG_arg_fail(1)) SWIG_fail;
11570 {
11571 arg2 = wxString_in_helper(obj1);
11572 if (arg2 == NULL) SWIG_fail;
11573 temp2 = true;
11574 }
11575 if (obj2) {
11576 {
11577 arg3 = (long)(SWIG_As_long(obj2));
11578 if (SWIG_arg_fail(3)) SWIG_fail;
11579 }
11580 }
11581 if (obj3) {
11582 {
11583 arg4 = (int)(SWIG_As_int(obj3));
11584 if (SWIG_arg_fail(4)) SWIG_fail;
11585 }
11586 }
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11590
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 {
11595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11596 }
11597 {
11598 if (temp2)
11599 delete arg2;
11600 }
11601 return resultobj;
11602 fail:
11603 {
11604 if (temp2)
11605 delete arg2;
11606 }
11607 return NULL;
11608 }
11609
11610
11611 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11612 PyObject *resultobj;
11613 wxImage *arg1 = (wxImage *) 0 ;
11614 wxString *arg2 = 0 ;
11615 wxString *arg3 = 0 ;
11616 int arg4 = (int) -1 ;
11617 bool result;
11618 bool temp2 = false ;
11619 bool temp3 = false ;
11620 PyObject * obj0 = 0 ;
11621 PyObject * obj1 = 0 ;
11622 PyObject * obj2 = 0 ;
11623 PyObject * obj3 = 0 ;
11624 char *kwnames[] = {
11625 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11626 };
11627
11628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11630 if (SWIG_arg_fail(1)) SWIG_fail;
11631 {
11632 arg2 = wxString_in_helper(obj1);
11633 if (arg2 == NULL) SWIG_fail;
11634 temp2 = true;
11635 }
11636 {
11637 arg3 = wxString_in_helper(obj2);
11638 if (arg3 == NULL) SWIG_fail;
11639 temp3 = true;
11640 }
11641 if (obj3) {
11642 {
11643 arg4 = (int)(SWIG_As_int(obj3));
11644 if (SWIG_arg_fail(4)) SWIG_fail;
11645 }
11646 }
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11650
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 {
11655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11656 }
11657 {
11658 if (temp2)
11659 delete arg2;
11660 }
11661 {
11662 if (temp3)
11663 delete arg3;
11664 }
11665 return resultobj;
11666 fail:
11667 {
11668 if (temp2)
11669 delete arg2;
11670 }
11671 {
11672 if (temp3)
11673 delete arg3;
11674 }
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxImage *arg1 = (wxImage *) 0 ;
11682 wxString *arg2 = 0 ;
11683 int arg3 ;
11684 bool result;
11685 bool temp2 = false ;
11686 PyObject * obj0 = 0 ;
11687 PyObject * obj1 = 0 ;
11688 PyObject * obj2 = 0 ;
11689 char *kwnames[] = {
11690 (char *) "self",(char *) "name",(char *) "type", NULL
11691 };
11692
11693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11695 if (SWIG_arg_fail(1)) SWIG_fail;
11696 {
11697 arg2 = wxString_in_helper(obj1);
11698 if (arg2 == NULL) SWIG_fail;
11699 temp2 = true;
11700 }
11701 {
11702 arg3 = (int)(SWIG_As_int(obj2));
11703 if (SWIG_arg_fail(3)) SWIG_fail;
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11708
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 {
11713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11714 }
11715 {
11716 if (temp2)
11717 delete arg2;
11718 }
11719 return resultobj;
11720 fail:
11721 {
11722 if (temp2)
11723 delete arg2;
11724 }
11725 return NULL;
11726 }
11727
11728
11729 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11730 PyObject *resultobj;
11731 wxImage *arg1 = (wxImage *) 0 ;
11732 wxString *arg2 = 0 ;
11733 wxString *arg3 = 0 ;
11734 bool result;
11735 bool temp2 = false ;
11736 bool temp3 = false ;
11737 PyObject * obj0 = 0 ;
11738 PyObject * obj1 = 0 ;
11739 PyObject * obj2 = 0 ;
11740 char *kwnames[] = {
11741 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11742 };
11743
11744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11746 if (SWIG_arg_fail(1)) SWIG_fail;
11747 {
11748 arg2 = wxString_in_helper(obj1);
11749 if (arg2 == NULL) SWIG_fail;
11750 temp2 = true;
11751 }
11752 {
11753 arg3 = wxString_in_helper(obj2);
11754 if (arg3 == NULL) SWIG_fail;
11755 temp3 = true;
11756 }
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11760
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 {
11765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11766 }
11767 {
11768 if (temp2)
11769 delete arg2;
11770 }
11771 {
11772 if (temp3)
11773 delete arg3;
11774 }
11775 return resultobj;
11776 fail:
11777 {
11778 if (temp2)
11779 delete arg2;
11780 }
11781 {
11782 if (temp3)
11783 delete arg3;
11784 }
11785 return NULL;
11786 }
11787
11788
11789 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11790 PyObject *resultobj;
11791 wxInputStream *arg1 = 0 ;
11792 bool result;
11793 wxPyInputStream *temp1 ;
11794 bool created1 ;
11795 PyObject * obj0 = 0 ;
11796 char *kwnames[] = {
11797 (char *) "stream", NULL
11798 };
11799
11800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11801 {
11802 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11803 arg1 = temp1->m_wxis;
11804 created1 = false;
11805 } else {
11806 PyErr_Clear(); // clear the failure of the wxPyConvert above
11807 arg1 = wxPyCBInputStream_create(obj0, false);
11808 if (arg1 == NULL) {
11809 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11810 SWIG_fail;
11811 }
11812 created1 = true;
11813 }
11814 }
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (bool)wxImage::CanRead(*arg1);
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11824 }
11825 {
11826 if (created1)
11827 delete arg1;
11828 }
11829 return resultobj;
11830 fail:
11831 {
11832 if (created1)
11833 delete arg1;
11834 }
11835 return NULL;
11836 }
11837
11838
11839 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11840 PyObject *resultobj;
11841 wxImage *arg1 = (wxImage *) 0 ;
11842 wxInputStream *arg2 = 0 ;
11843 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11844 int arg4 = (int) -1 ;
11845 bool result;
11846 wxPyInputStream *temp2 ;
11847 bool created2 ;
11848 PyObject * obj0 = 0 ;
11849 PyObject * obj1 = 0 ;
11850 PyObject * obj2 = 0 ;
11851 PyObject * obj3 = 0 ;
11852 char *kwnames[] = {
11853 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11854 };
11855
11856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11858 if (SWIG_arg_fail(1)) SWIG_fail;
11859 {
11860 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11861 arg2 = temp2->m_wxis;
11862 created2 = false;
11863 } else {
11864 PyErr_Clear(); // clear the failure of the wxPyConvert above
11865 arg2 = wxPyCBInputStream_create(obj1, false);
11866 if (arg2 == NULL) {
11867 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11868 SWIG_fail;
11869 }
11870 created2 = true;
11871 }
11872 }
11873 if (obj2) {
11874 {
11875 arg3 = (long)(SWIG_As_long(obj2));
11876 if (SWIG_arg_fail(3)) SWIG_fail;
11877 }
11878 }
11879 if (obj3) {
11880 {
11881 arg4 = (int)(SWIG_As_int(obj3));
11882 if (SWIG_arg_fail(4)) SWIG_fail;
11883 }
11884 }
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11888
11889 wxPyEndAllowThreads(__tstate);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 {
11893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11894 }
11895 {
11896 if (created2)
11897 delete arg2;
11898 }
11899 return resultobj;
11900 fail:
11901 {
11902 if (created2)
11903 delete arg2;
11904 }
11905 return NULL;
11906 }
11907
11908
11909 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj;
11911 wxImage *arg1 = (wxImage *) 0 ;
11912 wxInputStream *arg2 = 0 ;
11913 wxString *arg3 = 0 ;
11914 int arg4 = (int) -1 ;
11915 bool result;
11916 wxPyInputStream *temp2 ;
11917 bool created2 ;
11918 bool temp3 = false ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 PyObject * obj2 = 0 ;
11922 PyObject * obj3 = 0 ;
11923 char *kwnames[] = {
11924 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11925 };
11926
11927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11929 if (SWIG_arg_fail(1)) SWIG_fail;
11930 {
11931 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11932 arg2 = temp2->m_wxis;
11933 created2 = false;
11934 } else {
11935 PyErr_Clear(); // clear the failure of the wxPyConvert above
11936 arg2 = wxPyCBInputStream_create(obj1, false);
11937 if (arg2 == NULL) {
11938 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11939 SWIG_fail;
11940 }
11941 created2 = true;
11942 }
11943 }
11944 {
11945 arg3 = wxString_in_helper(obj2);
11946 if (arg3 == NULL) SWIG_fail;
11947 temp3 = true;
11948 }
11949 if (obj3) {
11950 {
11951 arg4 = (int)(SWIG_As_int(obj3));
11952 if (SWIG_arg_fail(4)) SWIG_fail;
11953 }
11954 }
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11958
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 {
11963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11964 }
11965 {
11966 if (created2)
11967 delete arg2;
11968 }
11969 {
11970 if (temp3)
11971 delete arg3;
11972 }
11973 return resultobj;
11974 fail:
11975 {
11976 if (created2)
11977 delete arg2;
11978 }
11979 {
11980 if (temp3)
11981 delete arg3;
11982 }
11983 return NULL;
11984 }
11985
11986
11987 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj;
11989 wxImage *arg1 = (wxImage *) 0 ;
11990 bool result;
11991 PyObject * obj0 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 result = (bool)(arg1)->Ok();
12002
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 {
12007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12008 }
12009 return resultobj;
12010 fail:
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxImage *arg1 = (wxImage *) 0 ;
12018 int result;
12019 PyObject * obj0 = 0 ;
12020 char *kwnames[] = {
12021 (char *) "self", NULL
12022 };
12023
12024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12026 if (SWIG_arg_fail(1)) SWIG_fail;
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (int)(arg1)->GetWidth();
12030
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 {
12035 resultobj = SWIG_From_int((int)(result));
12036 }
12037 return resultobj;
12038 fail:
12039 return NULL;
12040 }
12041
12042
12043 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12044 PyObject *resultobj;
12045 wxImage *arg1 = (wxImage *) 0 ;
12046 int result;
12047 PyObject * obj0 = 0 ;
12048 char *kwnames[] = {
12049 (char *) "self", NULL
12050 };
12051
12052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12054 if (SWIG_arg_fail(1)) SWIG_fail;
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (int)(arg1)->GetHeight();
12058
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 {
12063 resultobj = SWIG_From_int((int)(result));
12064 }
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxImage *arg1 = (wxImage *) 0 ;
12074 wxSize result;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = wxImage_GetSize(arg1);
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 {
12091 wxSize * resultptr;
12092 resultptr = new wxSize((wxSize &)(result));
12093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12094 }
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj;
12103 wxImage *arg1 = (wxImage *) 0 ;
12104 wxRect *arg2 = 0 ;
12105 SwigValueWrapper<wxImage > result;
12106 wxRect temp2 ;
12107 PyObject * obj0 = 0 ;
12108 PyObject * obj1 = 0 ;
12109 char *kwnames[] = {
12110 (char *) "self",(char *) "rect", NULL
12111 };
12112
12113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12115 if (SWIG_arg_fail(1)) SWIG_fail;
12116 {
12117 arg2 = &temp2;
12118 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12119 }
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12123
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 wxImage * resultptr;
12129 resultptr = new wxImage((wxImage &)(result));
12130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12131 }
12132 return resultobj;
12133 fail:
12134 return NULL;
12135 }
12136
12137
12138 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12139 PyObject *resultobj;
12140 wxImage *arg1 = (wxImage *) 0 ;
12141 SwigValueWrapper<wxImage > result;
12142 PyObject * obj0 = 0 ;
12143 char *kwnames[] = {
12144 (char *) "self", NULL
12145 };
12146
12147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12149 if (SWIG_arg_fail(1)) SWIG_fail;
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 result = (arg1)->Copy();
12153
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 {
12158 wxImage * resultptr;
12159 resultptr = new wxImage((wxImage &)(result));
12160 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12161 }
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj;
12170 wxImage *arg1 = (wxImage *) 0 ;
12171 wxImage *arg2 = 0 ;
12172 int arg3 ;
12173 int arg4 ;
12174 PyObject * obj0 = 0 ;
12175 PyObject * obj1 = 0 ;
12176 PyObject * obj2 = 0 ;
12177 PyObject * obj3 = 0 ;
12178 char *kwnames[] = {
12179 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12180 };
12181
12182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12184 if (SWIG_arg_fail(1)) SWIG_fail;
12185 {
12186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12187 if (SWIG_arg_fail(2)) SWIG_fail;
12188 if (arg2 == NULL) {
12189 SWIG_null_ref("wxImage");
12190 }
12191 if (SWIG_arg_fail(2)) SWIG_fail;
12192 }
12193 {
12194 arg3 = (int)(SWIG_As_int(obj2));
12195 if (SWIG_arg_fail(3)) SWIG_fail;
12196 }
12197 {
12198 arg4 = (int)(SWIG_As_int(obj3));
12199 if (SWIG_arg_fail(4)) SWIG_fail;
12200 }
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 Py_INCREF(Py_None); resultobj = Py_None;
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj;
12217 wxImage *arg1 = (wxImage *) 0 ;
12218 PyObject *result;
12219 PyObject * obj0 = 0 ;
12220 char *kwnames[] = {
12221 (char *) "self", NULL
12222 };
12223
12224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (PyObject *)wxImage_GetData(arg1);
12230
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 resultobj = result;
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj;
12243 wxImage *arg1 = (wxImage *) 0 ;
12244 PyObject *arg2 = (PyObject *) 0 ;
12245 PyObject * obj0 = 0 ;
12246 PyObject * obj1 = 0 ;
12247 char *kwnames[] = {
12248 (char *) "self",(char *) "data", NULL
12249 };
12250
12251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12253 if (SWIG_arg_fail(1)) SWIG_fail;
12254 arg2 = obj1;
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 wxImage_SetData(arg1,arg2);
12258
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 Py_INCREF(Py_None); resultobj = Py_None;
12263 return resultobj;
12264 fail:
12265 return NULL;
12266 }
12267
12268
12269 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12270 PyObject *resultobj;
12271 wxImage *arg1 = (wxImage *) 0 ;
12272 PyObject *result;
12273 PyObject * obj0 = 0 ;
12274 char *kwnames[] = {
12275 (char *) "self", NULL
12276 };
12277
12278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12280 if (SWIG_arg_fail(1)) SWIG_fail;
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12284
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 resultobj = result;
12289 return resultobj;
12290 fail:
12291 return NULL;
12292 }
12293
12294
12295 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12296 PyObject *resultobj;
12297 wxImage *arg1 = (wxImage *) 0 ;
12298 PyObject *arg2 = (PyObject *) 0 ;
12299 PyObject * obj0 = 0 ;
12300 PyObject * obj1 = 0 ;
12301 char *kwnames[] = {
12302 (char *) "self",(char *) "data", NULL
12303 };
12304
12305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12307 if (SWIG_arg_fail(1)) SWIG_fail;
12308 arg2 = obj1;
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 wxImage_SetDataBuffer(arg1,arg2);
12312
12313 wxPyEndAllowThreads(__tstate);
12314 if (PyErr_Occurred()) SWIG_fail;
12315 }
12316 Py_INCREF(Py_None); resultobj = Py_None;
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj;
12325 wxImage *arg1 = (wxImage *) 0 ;
12326 PyObject *result;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (PyObject *)wxImage_GetAlphaData(arg1);
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 resultobj = result;
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj;
12351 wxImage *arg1 = (wxImage *) 0 ;
12352 PyObject *arg2 = (PyObject *) 0 ;
12353 PyObject * obj0 = 0 ;
12354 PyObject * obj1 = 0 ;
12355 char *kwnames[] = {
12356 (char *) "self",(char *) "data", NULL
12357 };
12358
12359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12361 if (SWIG_arg_fail(1)) SWIG_fail;
12362 arg2 = obj1;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 wxImage_SetAlphaData(arg1,arg2);
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 Py_INCREF(Py_None); resultobj = Py_None;
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj;
12379 wxImage *arg1 = (wxImage *) 0 ;
12380 PyObject *result;
12381 PyObject * obj0 = 0 ;
12382 char *kwnames[] = {
12383 (char *) "self", NULL
12384 };
12385
12386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12388 if (SWIG_arg_fail(1)) SWIG_fail;
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12392
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 resultobj = result;
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj;
12405 wxImage *arg1 = (wxImage *) 0 ;
12406 PyObject *arg2 = (PyObject *) 0 ;
12407 PyObject * obj0 = 0 ;
12408 PyObject * obj1 = 0 ;
12409 char *kwnames[] = {
12410 (char *) "self",(char *) "data", NULL
12411 };
12412
12413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12415 if (SWIG_arg_fail(1)) SWIG_fail;
12416 arg2 = obj1;
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 wxImage_SetAlphaBuffer(arg1,arg2);
12420
12421 wxPyEndAllowThreads(__tstate);
12422 if (PyErr_Occurred()) SWIG_fail;
12423 }
12424 Py_INCREF(Py_None); resultobj = Py_None;
12425 return resultobj;
12426 fail:
12427 return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12432 PyObject *resultobj;
12433 wxImage *arg1 = (wxImage *) 0 ;
12434 unsigned char arg2 ;
12435 unsigned char arg3 ;
12436 unsigned char arg4 ;
12437 PyObject * obj0 = 0 ;
12438 PyObject * obj1 = 0 ;
12439 PyObject * obj2 = 0 ;
12440 PyObject * obj3 = 0 ;
12441 char *kwnames[] = {
12442 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12443 };
12444
12445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12447 if (SWIG_arg_fail(1)) SWIG_fail;
12448 {
12449 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12450 if (SWIG_arg_fail(2)) SWIG_fail;
12451 }
12452 {
12453 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12454 if (SWIG_arg_fail(3)) SWIG_fail;
12455 }
12456 {
12457 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12458 if (SWIG_arg_fail(4)) SWIG_fail;
12459 }
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 (arg1)->SetMaskColour(arg2,arg3,arg4);
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 Py_INCREF(Py_None); resultobj = Py_None;
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj;
12476 wxImage *arg1 = (wxImage *) 0 ;
12477 unsigned char result;
12478 PyObject * obj0 = 0 ;
12479 char *kwnames[] = {
12480 (char *) "self", NULL
12481 };
12482
12483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12485 if (SWIG_arg_fail(1)) SWIG_fail;
12486 {
12487 PyThreadState* __tstate = wxPyBeginAllowThreads();
12488 result = (unsigned char)(arg1)->GetMaskRed();
12489
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 {
12494 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12495 }
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj;
12504 wxImage *arg1 = (wxImage *) 0 ;
12505 unsigned char result;
12506 PyObject * obj0 = 0 ;
12507 char *kwnames[] = {
12508 (char *) "self", NULL
12509 };
12510
12511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",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 = (unsigned char)(arg1)->GetMaskGreen();
12517
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 {
12522 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12523 }
12524 return resultobj;
12525 fail:
12526 return NULL;
12527 }
12528
12529
12530 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj;
12532 wxImage *arg1 = (wxImage *) 0 ;
12533 unsigned char result;
12534 PyObject * obj0 = 0 ;
12535 char *kwnames[] = {
12536 (char *) "self", NULL
12537 };
12538
12539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12541 if (SWIG_arg_fail(1)) SWIG_fail;
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 result = (unsigned char)(arg1)->GetMaskBlue();
12545
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 {
12550 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12551 }
12552 return resultobj;
12553 fail:
12554 return NULL;
12555 }
12556
12557
12558 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12559 PyObject *resultobj;
12560 wxImage *arg1 = (wxImage *) 0 ;
12561 bool arg2 = (bool) true ;
12562 PyObject * obj0 = 0 ;
12563 PyObject * obj1 = 0 ;
12564 char *kwnames[] = {
12565 (char *) "self",(char *) "mask", NULL
12566 };
12567
12568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12570 if (SWIG_arg_fail(1)) SWIG_fail;
12571 if (obj1) {
12572 {
12573 arg2 = (bool)(SWIG_As_bool(obj1));
12574 if (SWIG_arg_fail(2)) SWIG_fail;
12575 }
12576 }
12577 {
12578 PyThreadState* __tstate = wxPyBeginAllowThreads();
12579 (arg1)->SetMask(arg2);
12580
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 Py_INCREF(Py_None); resultobj = Py_None;
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj;
12593 wxImage *arg1 = (wxImage *) 0 ;
12594 bool result;
12595 PyObject * obj0 = 0 ;
12596 char *kwnames[] = {
12597 (char *) "self", NULL
12598 };
12599
12600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12602 if (SWIG_arg_fail(1)) SWIG_fail;
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 result = (bool)(arg1)->HasMask();
12606
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 {
12611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12612 }
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj;
12621 wxImage *arg1 = (wxImage *) 0 ;
12622 double arg2 ;
12623 wxPoint *arg3 = 0 ;
12624 bool arg4 = (bool) true ;
12625 wxPoint *arg5 = (wxPoint *) NULL ;
12626 SwigValueWrapper<wxImage > result;
12627 wxPoint temp3 ;
12628 PyObject * obj0 = 0 ;
12629 PyObject * obj1 = 0 ;
12630 PyObject * obj2 = 0 ;
12631 PyObject * obj3 = 0 ;
12632 PyObject * obj4 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 {
12641 arg2 = (double)(SWIG_As_double(obj1));
12642 if (SWIG_arg_fail(2)) SWIG_fail;
12643 }
12644 {
12645 arg3 = &temp3;
12646 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12647 }
12648 if (obj3) {
12649 {
12650 arg4 = (bool)(SWIG_As_bool(obj3));
12651 if (SWIG_arg_fail(4)) SWIG_fail;
12652 }
12653 }
12654 if (obj4) {
12655 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12656 if (SWIG_arg_fail(5)) SWIG_fail;
12657 }
12658 {
12659 PyThreadState* __tstate = wxPyBeginAllowThreads();
12660 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12661
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 {
12666 wxImage * resultptr;
12667 resultptr = new wxImage((wxImage &)(result));
12668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12669 }
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12677 PyObject *resultobj;
12678 wxImage *arg1 = (wxImage *) 0 ;
12679 bool arg2 = (bool) true ;
12680 SwigValueWrapper<wxImage > result;
12681 PyObject * obj0 = 0 ;
12682 PyObject * obj1 = 0 ;
12683 char *kwnames[] = {
12684 (char *) "self",(char *) "clockwise", NULL
12685 };
12686
12687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12689 if (SWIG_arg_fail(1)) SWIG_fail;
12690 if (obj1) {
12691 {
12692 arg2 = (bool)(SWIG_As_bool(obj1));
12693 if (SWIG_arg_fail(2)) SWIG_fail;
12694 }
12695 }
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 result = (arg1)->Rotate90(arg2);
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 {
12704 wxImage * resultptr;
12705 resultptr = new wxImage((wxImage &)(result));
12706 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12707 }
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj;
12716 wxImage *arg1 = (wxImage *) 0 ;
12717 bool arg2 = (bool) true ;
12718 SwigValueWrapper<wxImage > result;
12719 PyObject * obj0 = 0 ;
12720 PyObject * obj1 = 0 ;
12721 char *kwnames[] = {
12722 (char *) "self",(char *) "horizontally", NULL
12723 };
12724
12725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(1)) SWIG_fail;
12728 if (obj1) {
12729 {
12730 arg2 = (bool)(SWIG_As_bool(obj1));
12731 if (SWIG_arg_fail(2)) SWIG_fail;
12732 }
12733 }
12734 {
12735 PyThreadState* __tstate = wxPyBeginAllowThreads();
12736 result = (arg1)->Mirror(arg2);
12737
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 wxImage * resultptr;
12743 resultptr = new wxImage((wxImage &)(result));
12744 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj;
12754 wxImage *arg1 = (wxImage *) 0 ;
12755 unsigned char arg2 ;
12756 unsigned char arg3 ;
12757 unsigned char arg4 ;
12758 unsigned char arg5 ;
12759 unsigned char arg6 ;
12760 unsigned char arg7 ;
12761 PyObject * obj0 = 0 ;
12762 PyObject * obj1 = 0 ;
12763 PyObject * obj2 = 0 ;
12764 PyObject * obj3 = 0 ;
12765 PyObject * obj4 = 0 ;
12766 PyObject * obj5 = 0 ;
12767 PyObject * obj6 = 0 ;
12768 char *kwnames[] = {
12769 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12770 };
12771
12772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12774 if (SWIG_arg_fail(1)) SWIG_fail;
12775 {
12776 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12777 if (SWIG_arg_fail(2)) SWIG_fail;
12778 }
12779 {
12780 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12781 if (SWIG_arg_fail(3)) SWIG_fail;
12782 }
12783 {
12784 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12785 if (SWIG_arg_fail(4)) SWIG_fail;
12786 }
12787 {
12788 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12789 if (SWIG_arg_fail(5)) SWIG_fail;
12790 }
12791 {
12792 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12793 if (SWIG_arg_fail(6)) SWIG_fail;
12794 }
12795 {
12796 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12797 if (SWIG_arg_fail(7)) SWIG_fail;
12798 }
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
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_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 unsigned char arg2 ;
12817 unsigned char arg3 ;
12818 unsigned char arg4 ;
12819 SwigValueWrapper<wxImage > result;
12820 PyObject * obj0 = 0 ;
12821 PyObject * obj1 = 0 ;
12822 PyObject * obj2 = 0 ;
12823 PyObject * obj3 = 0 ;
12824 char *kwnames[] = {
12825 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12826 };
12827
12828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12830 if (SWIG_arg_fail(1)) SWIG_fail;
12831 {
12832 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12833 if (SWIG_arg_fail(2)) SWIG_fail;
12834 }
12835 {
12836 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12837 if (SWIG_arg_fail(3)) SWIG_fail;
12838 }
12839 {
12840 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12841 if (SWIG_arg_fail(4)) SWIG_fail;
12842 }
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12846
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 {
12851 wxImage * resultptr;
12852 resultptr = new wxImage((wxImage &)(result));
12853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12854 }
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxImage *arg1 = (wxImage *) 0 ;
12864 wxString *arg2 = 0 ;
12865 wxString *arg3 = 0 ;
12866 bool temp2 = false ;
12867 bool temp3 = false ;
12868 PyObject * obj0 = 0 ;
12869 PyObject * obj1 = 0 ;
12870 PyObject * obj2 = 0 ;
12871 char *kwnames[] = {
12872 (char *) "self",(char *) "name",(char *) "value", NULL
12873 };
12874
12875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12877 if (SWIG_arg_fail(1)) SWIG_fail;
12878 {
12879 arg2 = wxString_in_helper(obj1);
12880 if (arg2 == NULL) SWIG_fail;
12881 temp2 = true;
12882 }
12883 {
12884 arg3 = wxString_in_helper(obj2);
12885 if (arg3 == NULL) SWIG_fail;
12886 temp3 = true;
12887 }
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12891
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 Py_INCREF(Py_None); resultobj = Py_None;
12896 {
12897 if (temp2)
12898 delete arg2;
12899 }
12900 {
12901 if (temp3)
12902 delete arg3;
12903 }
12904 return resultobj;
12905 fail:
12906 {
12907 if (temp2)
12908 delete arg2;
12909 }
12910 {
12911 if (temp3)
12912 delete arg3;
12913 }
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxImage *arg1 = (wxImage *) 0 ;
12921 wxString *arg2 = 0 ;
12922 int arg3 ;
12923 bool temp2 = false ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 PyObject * obj2 = 0 ;
12927 char *kwnames[] = {
12928 (char *) "self",(char *) "name",(char *) "value", NULL
12929 };
12930
12931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12933 if (SWIG_arg_fail(1)) SWIG_fail;
12934 {
12935 arg2 = wxString_in_helper(obj1);
12936 if (arg2 == NULL) SWIG_fail;
12937 temp2 = true;
12938 }
12939 {
12940 arg3 = (int)(SWIG_As_int(obj2));
12941 if (SWIG_arg_fail(3)) SWIG_fail;
12942 }
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 (arg1)->SetOption((wxString const &)*arg2,arg3);
12946
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 Py_INCREF(Py_None); resultobj = Py_None;
12951 {
12952 if (temp2)
12953 delete arg2;
12954 }
12955 return resultobj;
12956 fail:
12957 {
12958 if (temp2)
12959 delete arg2;
12960 }
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxImage *arg1 = (wxImage *) 0 ;
12968 wxString *arg2 = 0 ;
12969 wxString result;
12970 bool temp2 = false ;
12971 PyObject * obj0 = 0 ;
12972 PyObject * obj1 = 0 ;
12973 char *kwnames[] = {
12974 (char *) "self",(char *) "name", NULL
12975 };
12976
12977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12979 if (SWIG_arg_fail(1)) SWIG_fail;
12980 {
12981 arg2 = wxString_in_helper(obj1);
12982 if (arg2 == NULL) SWIG_fail;
12983 temp2 = true;
12984 }
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12988
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 {
12993 #if wxUSE_UNICODE
12994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12995 #else
12996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12997 #endif
12998 }
12999 {
13000 if (temp2)
13001 delete arg2;
13002 }
13003 return resultobj;
13004 fail:
13005 {
13006 if (temp2)
13007 delete arg2;
13008 }
13009 return NULL;
13010 }
13011
13012
13013 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13014 PyObject *resultobj;
13015 wxImage *arg1 = (wxImage *) 0 ;
13016 wxString *arg2 = 0 ;
13017 int result;
13018 bool temp2 = false ;
13019 PyObject * obj0 = 0 ;
13020 PyObject * obj1 = 0 ;
13021 char *kwnames[] = {
13022 (char *) "self",(char *) "name", NULL
13023 };
13024
13025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13027 if (SWIG_arg_fail(1)) SWIG_fail;
13028 {
13029 arg2 = wxString_in_helper(obj1);
13030 if (arg2 == NULL) SWIG_fail;
13031 temp2 = true;
13032 }
13033 {
13034 PyThreadState* __tstate = wxPyBeginAllowThreads();
13035 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13036
13037 wxPyEndAllowThreads(__tstate);
13038 if (PyErr_Occurred()) SWIG_fail;
13039 }
13040 {
13041 resultobj = SWIG_From_int((int)(result));
13042 }
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return resultobj;
13048 fail:
13049 {
13050 if (temp2)
13051 delete arg2;
13052 }
13053 return NULL;
13054 }
13055
13056
13057 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj;
13059 wxImage *arg1 = (wxImage *) 0 ;
13060 wxString *arg2 = 0 ;
13061 bool result;
13062 bool temp2 = false ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 char *kwnames[] = {
13066 (char *) "self",(char *) "name", NULL
13067 };
13068
13069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13071 if (SWIG_arg_fail(1)) SWIG_fail;
13072 {
13073 arg2 = wxString_in_helper(obj1);
13074 if (arg2 == NULL) SWIG_fail;
13075 temp2 = true;
13076 }
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13080
13081 wxPyEndAllowThreads(__tstate);
13082 if (PyErr_Occurred()) SWIG_fail;
13083 }
13084 {
13085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13086 }
13087 {
13088 if (temp2)
13089 delete arg2;
13090 }
13091 return resultobj;
13092 fail:
13093 {
13094 if (temp2)
13095 delete arg2;
13096 }
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxImage *arg1 = (wxImage *) 0 ;
13104 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13105 unsigned long result;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 char *kwnames[] = {
13109 (char *) "self",(char *) "stopafter", NULL
13110 };
13111
13112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13114 if (SWIG_arg_fail(1)) SWIG_fail;
13115 if (obj1) {
13116 {
13117 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13118 if (SWIG_arg_fail(2)) SWIG_fail;
13119 }
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (unsigned long)(arg1)->CountColours(arg2);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13130 }
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj;
13139 wxImage *arg1 = (wxImage *) 0 ;
13140 wxImageHistogram *arg2 = 0 ;
13141 unsigned long result;
13142 PyObject * obj0 = 0 ;
13143 PyObject * obj1 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self",(char *) "h", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13150 if (SWIG_arg_fail(1)) SWIG_fail;
13151 {
13152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13153 if (SWIG_arg_fail(2)) SWIG_fail;
13154 if (arg2 == NULL) {
13155 SWIG_null_ref("wxImageHistogram");
13156 }
13157 if (SWIG_arg_fail(2)) SWIG_fail;
13158 }
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 {
13167 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13168 }
13169 return resultobj;
13170 fail:
13171 return NULL;
13172 }
13173
13174
13175 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj;
13177 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13178 PyObject * obj0 = 0 ;
13179 char *kwnames[] = {
13180 (char *) "handler", NULL
13181 };
13182
13183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13185 if (SWIG_arg_fail(1)) SWIG_fail;
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 wxImage::AddHandler(arg1);
13189
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 Py_INCREF(Py_None); resultobj = Py_None;
13194 return resultobj;
13195 fail:
13196 return NULL;
13197 }
13198
13199
13200 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13201 PyObject *resultobj;
13202 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13203 PyObject * obj0 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "handler", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 PyThreadState* __tstate = wxPyBeginAllowThreads();
13213 wxImage::InsertHandler(arg1);
13214
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 Py_INCREF(Py_None); resultobj = Py_None;
13219 return resultobj;
13220 fail:
13221 return NULL;
13222 }
13223
13224
13225 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13226 PyObject *resultobj;
13227 wxString *arg1 = 0 ;
13228 bool result;
13229 bool temp1 = false ;
13230 PyObject * obj0 = 0 ;
13231 char *kwnames[] = {
13232 (char *) "name", NULL
13233 };
13234
13235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13236 {
13237 arg1 = wxString_in_helper(obj0);
13238 if (arg1 == NULL) SWIG_fail;
13239 temp1 = true;
13240 }
13241 {
13242 PyThreadState* __tstate = wxPyBeginAllowThreads();
13243 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13244
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 {
13249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13250 }
13251 {
13252 if (temp1)
13253 delete arg1;
13254 }
13255 return resultobj;
13256 fail:
13257 {
13258 if (temp1)
13259 delete arg1;
13260 }
13261 return NULL;
13262 }
13263
13264
13265 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13266 PyObject *resultobj;
13267 wxString result;
13268 char *kwnames[] = {
13269 NULL
13270 };
13271
13272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = wxImage::GetImageExtWildcard();
13276
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 {
13281 #if wxUSE_UNICODE
13282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13283 #else
13284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13285 #endif
13286 }
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj;
13295 wxImage *arg1 = (wxImage *) 0 ;
13296 int arg2 = (int) -1 ;
13297 wxBitmap result;
13298 PyObject * obj0 = 0 ;
13299 PyObject * obj1 = 0 ;
13300 char *kwnames[] = {
13301 (char *) "self",(char *) "depth", NULL
13302 };
13303
13304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13306 if (SWIG_arg_fail(1)) SWIG_fail;
13307 if (obj1) {
13308 {
13309 arg2 = (int)(SWIG_As_int(obj1));
13310 if (SWIG_arg_fail(2)) SWIG_fail;
13311 }
13312 }
13313 {
13314 if (!wxPyCheckForApp()) SWIG_fail;
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = wxImage_ConvertToBitmap(arg1,arg2);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 {
13322 wxBitmap * resultptr;
13323 resultptr = new wxBitmap((wxBitmap &)(result));
13324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13325 }
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj;
13334 wxImage *arg1 = (wxImage *) 0 ;
13335 unsigned char arg2 ;
13336 unsigned char arg3 ;
13337 unsigned char arg4 ;
13338 wxBitmap result;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 PyObject * obj2 = 0 ;
13342 PyObject * obj3 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13349 if (SWIG_arg_fail(1)) SWIG_fail;
13350 {
13351 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13352 if (SWIG_arg_fail(2)) SWIG_fail;
13353 }
13354 {
13355 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13356 if (SWIG_arg_fail(3)) SWIG_fail;
13357 }
13358 {
13359 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13360 if (SWIG_arg_fail(4)) SWIG_fail;
13361 }
13362 {
13363 if (!wxPyCheckForApp()) SWIG_fail;
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13366
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 {
13371 wxBitmap * resultptr;
13372 resultptr = new wxBitmap((wxBitmap &)(result));
13373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13374 }
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13382 PyObject *obj;
13383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13384 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13385 Py_INCREF(obj);
13386 return Py_BuildValue((char *)"");
13387 }
13388 static int _wrap_NullImage_set(PyObject *) {
13389 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13390 return 1;
13391 }
13392
13393
13394 static PyObject *_wrap_NullImage_get(void) {
13395 PyObject *pyobj;
13396
13397 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13398 return pyobj;
13399 }
13400
13401
13402 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13403 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13404 return 1;
13405 }
13406
13407
13408 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13409 PyObject *pyobj;
13410
13411 {
13412 #if wxUSE_UNICODE
13413 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13414 #else
13415 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13416 #endif
13417 }
13418 return pyobj;
13419 }
13420
13421
13422 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13423 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13424 return 1;
13425 }
13426
13427
13428 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13429 PyObject *pyobj;
13430
13431 {
13432 #if wxUSE_UNICODE
13433 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13434 #else
13435 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13436 #endif
13437 }
13438 return pyobj;
13439 }
13440
13441
13442 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13443 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13444 return 1;
13445 }
13446
13447
13448 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13449 PyObject *pyobj;
13450
13451 {
13452 #if wxUSE_UNICODE
13453 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13454 #else
13455 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13456 #endif
13457 }
13458 return pyobj;
13459 }
13460
13461
13462 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13463 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13464 return 1;
13465 }
13466
13467
13468 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13469 PyObject *pyobj;
13470
13471 {
13472 #if wxUSE_UNICODE
13473 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13474 #else
13475 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13476 #endif
13477 }
13478 return pyobj;
13479 }
13480
13481
13482 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13483 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13484 return 1;
13485 }
13486
13487
13488 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13489 PyObject *pyobj;
13490
13491 {
13492 #if wxUSE_UNICODE
13493 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13494 #else
13495 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13496 #endif
13497 }
13498 return pyobj;
13499 }
13500
13501
13502 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13503 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13504 return 1;
13505 }
13506
13507
13508 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13509 PyObject *pyobj;
13510
13511 {
13512 #if wxUSE_UNICODE
13513 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13514 #else
13515 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13516 #endif
13517 }
13518 return pyobj;
13519 }
13520
13521
13522 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13523 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13524 return 1;
13525 }
13526
13527
13528 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13529 PyObject *pyobj;
13530
13531 {
13532 #if wxUSE_UNICODE
13533 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13534 #else
13535 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13536 #endif
13537 }
13538 return pyobj;
13539 }
13540
13541
13542 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13543 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13544 return 1;
13545 }
13546
13547
13548 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13549 PyObject *pyobj;
13550
13551 {
13552 #if wxUSE_UNICODE
13553 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13554 #else
13555 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13556 #endif
13557 }
13558 return pyobj;
13559 }
13560
13561
13562 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13563 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13564 return 1;
13565 }
13566
13567
13568 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13569 PyObject *pyobj;
13570
13571 {
13572 #if wxUSE_UNICODE
13573 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13574 #else
13575 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13576 #endif
13577 }
13578 return pyobj;
13579 }
13580
13581
13582 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13583 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13584 return 1;
13585 }
13586
13587
13588 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13589 PyObject *pyobj;
13590
13591 {
13592 #if wxUSE_UNICODE
13593 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13594 #else
13595 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13596 #endif
13597 }
13598 return pyobj;
13599 }
13600
13601
13602 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13603 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13604 return 1;
13605 }
13606
13607
13608 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13609 PyObject *pyobj;
13610
13611 {
13612 #if wxUSE_UNICODE
13613 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13614 #else
13615 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13616 #endif
13617 }
13618 return pyobj;
13619 }
13620
13621
13622 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13623 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13624 return 1;
13625 }
13626
13627
13628 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13629 PyObject *pyobj;
13630
13631 {
13632 #if wxUSE_UNICODE
13633 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13634 #else
13635 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13636 #endif
13637 }
13638 return pyobj;
13639 }
13640
13641
13642 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13643 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13644 return 1;
13645 }
13646
13647
13648 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13649 PyObject *pyobj;
13650
13651 {
13652 #if wxUSE_UNICODE
13653 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13654 #else
13655 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13656 #endif
13657 }
13658 return pyobj;
13659 }
13660
13661
13662 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj;
13664 wxBMPHandler *result;
13665 char *kwnames[] = {
13666 NULL
13667 };
13668
13669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13670 {
13671 PyThreadState* __tstate = wxPyBeginAllowThreads();
13672 result = (wxBMPHandler *)new wxBMPHandler();
13673
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13685 PyObject *obj;
13686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13687 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13688 Py_INCREF(obj);
13689 return Py_BuildValue((char *)"");
13690 }
13691 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13692 PyObject *resultobj;
13693 wxICOHandler *result;
13694 char *kwnames[] = {
13695 NULL
13696 };
13697
13698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (wxICOHandler *)new wxICOHandler();
13702
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13707 return resultobj;
13708 fail:
13709 return NULL;
13710 }
13711
13712
13713 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13714 PyObject *obj;
13715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13716 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13717 Py_INCREF(obj);
13718 return Py_BuildValue((char *)"");
13719 }
13720 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj;
13722 wxCURHandler *result;
13723 char *kwnames[] = {
13724 NULL
13725 };
13726
13727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 result = (wxCURHandler *)new wxCURHandler();
13731
13732 wxPyEndAllowThreads(__tstate);
13733 if (PyErr_Occurred()) SWIG_fail;
13734 }
13735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13736 return resultobj;
13737 fail:
13738 return NULL;
13739 }
13740
13741
13742 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13743 PyObject *obj;
13744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13745 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13746 Py_INCREF(obj);
13747 return Py_BuildValue((char *)"");
13748 }
13749 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13750 PyObject *resultobj;
13751 wxANIHandler *result;
13752 char *kwnames[] = {
13753 NULL
13754 };
13755
13756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 result = (wxANIHandler *)new wxANIHandler();
13760
13761 wxPyEndAllowThreads(__tstate);
13762 if (PyErr_Occurred()) SWIG_fail;
13763 }
13764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13765 return resultobj;
13766 fail:
13767 return NULL;
13768 }
13769
13770
13771 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13772 PyObject *obj;
13773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13774 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13775 Py_INCREF(obj);
13776 return Py_BuildValue((char *)"");
13777 }
13778 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj;
13780 wxPNGHandler *result;
13781 char *kwnames[] = {
13782 NULL
13783 };
13784
13785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13786 {
13787 PyThreadState* __tstate = wxPyBeginAllowThreads();
13788 result = (wxPNGHandler *)new wxPNGHandler();
13789
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13801 PyObject *obj;
13802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13803 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13804 Py_INCREF(obj);
13805 return Py_BuildValue((char *)"");
13806 }
13807 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13808 PyObject *resultobj;
13809 wxGIFHandler *result;
13810 char *kwnames[] = {
13811 NULL
13812 };
13813
13814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 result = (wxGIFHandler *)new wxGIFHandler();
13818
13819 wxPyEndAllowThreads(__tstate);
13820 if (PyErr_Occurred()) SWIG_fail;
13821 }
13822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13830 PyObject *obj;
13831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13832 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13833 Py_INCREF(obj);
13834 return Py_BuildValue((char *)"");
13835 }
13836 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13837 PyObject *resultobj;
13838 wxPCXHandler *result;
13839 char *kwnames[] = {
13840 NULL
13841 };
13842
13843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 result = (wxPCXHandler *)new wxPCXHandler();
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13859 PyObject *obj;
13860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13861 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13862 Py_INCREF(obj);
13863 return Py_BuildValue((char *)"");
13864 }
13865 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13866 PyObject *resultobj;
13867 wxJPEGHandler *result;
13868 char *kwnames[] = {
13869 NULL
13870 };
13871
13872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13873 {
13874 PyThreadState* __tstate = wxPyBeginAllowThreads();
13875 result = (wxJPEGHandler *)new wxJPEGHandler();
13876
13877 wxPyEndAllowThreads(__tstate);
13878 if (PyErr_Occurred()) SWIG_fail;
13879 }
13880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13881 return resultobj;
13882 fail:
13883 return NULL;
13884 }
13885
13886
13887 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13888 PyObject *obj;
13889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13890 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13891 Py_INCREF(obj);
13892 return Py_BuildValue((char *)"");
13893 }
13894 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13895 PyObject *resultobj;
13896 wxPNMHandler *result;
13897 char *kwnames[] = {
13898 NULL
13899 };
13900
13901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 result = (wxPNMHandler *)new wxPNMHandler();
13905
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13910 return resultobj;
13911 fail:
13912 return NULL;
13913 }
13914
13915
13916 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13917 PyObject *obj;
13918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13919 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13920 Py_INCREF(obj);
13921 return Py_BuildValue((char *)"");
13922 }
13923 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13924 PyObject *resultobj;
13925 wxXPMHandler *result;
13926 char *kwnames[] = {
13927 NULL
13928 };
13929
13930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 result = (wxXPMHandler *)new wxXPMHandler();
13934
13935 wxPyEndAllowThreads(__tstate);
13936 if (PyErr_Occurred()) SWIG_fail;
13937 }
13938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13939 return resultobj;
13940 fail:
13941 return NULL;
13942 }
13943
13944
13945 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13946 PyObject *obj;
13947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13948 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13949 Py_INCREF(obj);
13950 return Py_BuildValue((char *)"");
13951 }
13952 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13953 PyObject *resultobj;
13954 wxTIFFHandler *result;
13955 char *kwnames[] = {
13956 NULL
13957 };
13958
13959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13960 {
13961 PyThreadState* __tstate = wxPyBeginAllowThreads();
13962 result = (wxTIFFHandler *)new wxTIFFHandler();
13963
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13975 PyObject *obj;
13976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13977 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13978 Py_INCREF(obj);
13979 return Py_BuildValue((char *)"");
13980 }
13981 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13982 PyObject *resultobj;
13983 wxImage *arg1 = 0 ;
13984 wxImage *arg2 = 0 ;
13985 int arg3 = (int) 236 ;
13986 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13987 bool result;
13988 PyObject * obj0 = 0 ;
13989 PyObject * obj1 = 0 ;
13990 PyObject * obj2 = 0 ;
13991 PyObject * obj3 = 0 ;
13992 char *kwnames[] = {
13993 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13994 };
13995
13996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13997 {
13998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13999 if (SWIG_arg_fail(1)) SWIG_fail;
14000 if (arg1 == NULL) {
14001 SWIG_null_ref("wxImage");
14002 }
14003 if (SWIG_arg_fail(1)) SWIG_fail;
14004 }
14005 {
14006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14007 if (SWIG_arg_fail(2)) SWIG_fail;
14008 if (arg2 == NULL) {
14009 SWIG_null_ref("wxImage");
14010 }
14011 if (SWIG_arg_fail(2)) SWIG_fail;
14012 }
14013 if (obj2) {
14014 {
14015 arg3 = (int)(SWIG_As_int(obj2));
14016 if (SWIG_arg_fail(3)) SWIG_fail;
14017 }
14018 }
14019 if (obj3) {
14020 {
14021 arg4 = (int)(SWIG_As_int(obj3));
14022 if (SWIG_arg_fail(4)) SWIG_fail;
14023 }
14024 }
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14028
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 {
14033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14034 }
14035 return resultobj;
14036 fail:
14037 return NULL;
14038 }
14039
14040
14041 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14042 PyObject *obj;
14043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14044 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14045 Py_INCREF(obj);
14046 return Py_BuildValue((char *)"");
14047 }
14048 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj;
14050 wxEvtHandler *result;
14051 char *kwnames[] = {
14052 NULL
14053 };
14054
14055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14056 {
14057 PyThreadState* __tstate = wxPyBeginAllowThreads();
14058 result = (wxEvtHandler *)new wxEvtHandler();
14059
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj;
14072 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14073 wxEvtHandler *result;
14074 PyObject * obj0 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(1)) SWIG_fail;
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 {
14090 resultobj = wxPyMake_wxObject(result, 0);
14091 }
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj;
14100 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14101 wxEvtHandler *result;
14102 PyObject * obj0 = 0 ;
14103 char *kwnames[] = {
14104 (char *) "self", NULL
14105 };
14106
14107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14109 if (SWIG_arg_fail(1)) SWIG_fail;
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14113
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 {
14118 resultobj = wxPyMake_wxObject(result, 0);
14119 }
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14127 PyObject *resultobj;
14128 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14129 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14130 PyObject * obj0 = 0 ;
14131 PyObject * obj1 = 0 ;
14132 char *kwnames[] = {
14133 (char *) "self",(char *) "handler", NULL
14134 };
14135
14136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14138 if (SWIG_arg_fail(1)) SWIG_fail;
14139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14140 if (SWIG_arg_fail(2)) SWIG_fail;
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 (arg1)->SetNextHandler(arg2);
14144
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 Py_INCREF(Py_None); resultobj = Py_None;
14149 return resultobj;
14150 fail:
14151 return NULL;
14152 }
14153
14154
14155 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj;
14157 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14158 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14159 PyObject * obj0 = 0 ;
14160 PyObject * obj1 = 0 ;
14161 char *kwnames[] = {
14162 (char *) "self",(char *) "handler", NULL
14163 };
14164
14165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14167 if (SWIG_arg_fail(1)) SWIG_fail;
14168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14169 if (SWIG_arg_fail(2)) SWIG_fail;
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 (arg1)->SetPreviousHandler(arg2);
14173
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 Py_INCREF(Py_None); resultobj = Py_None;
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14187 bool result;
14188 PyObject * obj0 = 0 ;
14189 char *kwnames[] = {
14190 (char *) "self", NULL
14191 };
14192
14193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(1)) SWIG_fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 result = (bool)(arg1)->GetEvtHandlerEnabled();
14199
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14205 }
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj;
14214 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14215 bool arg2 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 char *kwnames[] = {
14219 (char *) "self",(char *) "enabled", NULL
14220 };
14221
14222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14224 if (SWIG_arg_fail(1)) SWIG_fail;
14225 {
14226 arg2 = (bool)(SWIG_As_bool(obj1));
14227 if (SWIG_arg_fail(2)) SWIG_fail;
14228 }
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 (arg1)->SetEvtHandlerEnabled(arg2);
14232
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 Py_INCREF(Py_None); resultobj = Py_None;
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14246 wxEvent *arg2 = 0 ;
14247 bool result;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 char *kwnames[] = {
14251 (char *) "self",(char *) "event", NULL
14252 };
14253
14254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14256 if (SWIG_arg_fail(1)) SWIG_fail;
14257 {
14258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14259 if (SWIG_arg_fail(2)) SWIG_fail;
14260 if (arg2 == NULL) {
14261 SWIG_null_ref("wxEvent");
14262 }
14263 if (SWIG_arg_fail(2)) SWIG_fail;
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (bool)(arg1)->ProcessEvent(*arg2);
14268
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 {
14273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14274 }
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj;
14283 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14284 wxEvent *arg2 = 0 ;
14285 PyObject * obj0 = 0 ;
14286 PyObject * obj1 = 0 ;
14287 char *kwnames[] = {
14288 (char *) "self",(char *) "event", NULL
14289 };
14290
14291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14293 if (SWIG_arg_fail(1)) SWIG_fail;
14294 {
14295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14296 if (SWIG_arg_fail(2)) SWIG_fail;
14297 if (arg2 == NULL) {
14298 SWIG_null_ref("wxEvent");
14299 }
14300 if (SWIG_arg_fail(2)) SWIG_fail;
14301 }
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 (arg1)->AddPendingEvent(*arg2);
14305
14306 wxPyEndAllowThreads(__tstate);
14307 if (PyErr_Occurred()) SWIG_fail;
14308 }
14309 Py_INCREF(Py_None); resultobj = Py_None;
14310 return resultobj;
14311 fail:
14312 return NULL;
14313 }
14314
14315
14316 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj;
14318 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14319 PyObject * obj0 = 0 ;
14320 char *kwnames[] = {
14321 (char *) "self", NULL
14322 };
14323
14324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14326 if (SWIG_arg_fail(1)) SWIG_fail;
14327 {
14328 PyThreadState* __tstate = wxPyBeginAllowThreads();
14329 (arg1)->ProcessPendingEvents();
14330
14331 wxPyEndAllowThreads(__tstate);
14332 if (PyErr_Occurred()) SWIG_fail;
14333 }
14334 Py_INCREF(Py_None); resultobj = Py_None;
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14344 int arg2 ;
14345 int arg3 ;
14346 int arg4 ;
14347 PyObject *arg5 = (PyObject *) 0 ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 PyObject * obj2 = 0 ;
14351 PyObject * obj3 = 0 ;
14352 PyObject * obj4 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 arg2 = (int)(SWIG_As_int(obj1));
14362 if (SWIG_arg_fail(2)) SWIG_fail;
14363 }
14364 {
14365 arg3 = (int)(SWIG_As_int(obj2));
14366 if (SWIG_arg_fail(3)) SWIG_fail;
14367 }
14368 {
14369 arg4 = (int)(SWIG_As_int(obj3));
14370 if (SWIG_arg_fail(4)) SWIG_fail;
14371 }
14372 arg5 = obj4;
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14376
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 Py_INCREF(Py_None); resultobj = Py_None;
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj;
14389 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14390 int arg2 ;
14391 int arg3 = (int) -1 ;
14392 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14393 bool result;
14394 PyObject * obj0 = 0 ;
14395 PyObject * obj1 = 0 ;
14396 PyObject * obj2 = 0 ;
14397 PyObject * obj3 = 0 ;
14398 char *kwnames[] = {
14399 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14400 };
14401
14402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14404 if (SWIG_arg_fail(1)) SWIG_fail;
14405 {
14406 arg2 = (int)(SWIG_As_int(obj1));
14407 if (SWIG_arg_fail(2)) SWIG_fail;
14408 }
14409 if (obj2) {
14410 {
14411 arg3 = (int)(SWIG_As_int(obj2));
14412 if (SWIG_arg_fail(3)) SWIG_fail;
14413 }
14414 }
14415 if (obj3) {
14416 {
14417 arg4 = (wxEventType)(SWIG_As_int(obj3));
14418 if (SWIG_arg_fail(4)) SWIG_fail;
14419 }
14420 }
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14424
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 {
14429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14430 }
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj;
14439 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14440 PyObject *arg2 = (PyObject *) 0 ;
14441 bool arg3 = (bool) true ;
14442 PyObject * obj0 = 0 ;
14443 PyObject * obj1 = 0 ;
14444 PyObject * obj2 = 0 ;
14445 char *kwnames[] = {
14446 (char *) "self",(char *) "_self",(char *) "incref", NULL
14447 };
14448
14449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14451 if (SWIG_arg_fail(1)) SWIG_fail;
14452 arg2 = obj1;
14453 if (obj2) {
14454 {
14455 arg3 = (bool)(SWIG_As_bool(obj2));
14456 if (SWIG_arg_fail(3)) SWIG_fail;
14457 }
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14462
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 Py_INCREF(Py_None); resultobj = Py_None;
14467 return resultobj;
14468 fail:
14469 return NULL;
14470 }
14471
14472
14473 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14474 PyObject *obj;
14475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14476 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14477 Py_INCREF(obj);
14478 return Py_BuildValue((char *)"");
14479 }
14480 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj;
14482 wxEventType result;
14483 char *kwnames[] = {
14484 NULL
14485 };
14486
14487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 result = (wxEventType)wxNewEventType();
14491
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 {
14496 resultobj = SWIG_From_int((int)(result));
14497 }
14498 return resultobj;
14499 fail:
14500 return NULL;
14501 }
14502
14503
14504 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14505 PyObject *resultobj;
14506 wxEvent *arg1 = (wxEvent *) 0 ;
14507 PyObject * obj0 = 0 ;
14508 char *kwnames[] = {
14509 (char *) "self", NULL
14510 };
14511
14512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14514 if (SWIG_arg_fail(1)) SWIG_fail;
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 delete arg1;
14518
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 Py_INCREF(Py_None); resultobj = Py_None;
14523 return resultobj;
14524 fail:
14525 return NULL;
14526 }
14527
14528
14529 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14530 PyObject *resultobj;
14531 wxEvent *arg1 = (wxEvent *) 0 ;
14532 wxEventType arg2 ;
14533 PyObject * obj0 = 0 ;
14534 PyObject * obj1 = 0 ;
14535 char *kwnames[] = {
14536 (char *) "self",(char *) "typ", NULL
14537 };
14538
14539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14541 if (SWIG_arg_fail(1)) SWIG_fail;
14542 {
14543 arg2 = (wxEventType)(SWIG_As_int(obj1));
14544 if (SWIG_arg_fail(2)) SWIG_fail;
14545 }
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 (arg1)->SetEventType(arg2);
14549
14550 wxPyEndAllowThreads(__tstate);
14551 if (PyErr_Occurred()) SWIG_fail;
14552 }
14553 Py_INCREF(Py_None); resultobj = Py_None;
14554 return resultobj;
14555 fail:
14556 return NULL;
14557 }
14558
14559
14560 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14561 PyObject *resultobj;
14562 wxEvent *arg1 = (wxEvent *) 0 ;
14563 wxEventType result;
14564 PyObject * obj0 = 0 ;
14565 char *kwnames[] = {
14566 (char *) "self", NULL
14567 };
14568
14569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14571 if (SWIG_arg_fail(1)) SWIG_fail;
14572 {
14573 PyThreadState* __tstate = wxPyBeginAllowThreads();
14574 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14575
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 {
14580 resultobj = SWIG_From_int((int)(result));
14581 }
14582 return resultobj;
14583 fail:
14584 return NULL;
14585 }
14586
14587
14588 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14589 PyObject *resultobj;
14590 wxEvent *arg1 = (wxEvent *) 0 ;
14591 wxObject *result;
14592 PyObject * obj0 = 0 ;
14593 char *kwnames[] = {
14594 (char *) "self", NULL
14595 };
14596
14597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14599 if (SWIG_arg_fail(1)) SWIG_fail;
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14603
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 {
14608 resultobj = wxPyMake_wxObject(result, 0);
14609 }
14610 return resultobj;
14611 fail:
14612 return NULL;
14613 }
14614
14615
14616 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj;
14618 wxEvent *arg1 = (wxEvent *) 0 ;
14619 wxObject *arg2 = (wxObject *) 0 ;
14620 PyObject * obj0 = 0 ;
14621 PyObject * obj1 = 0 ;
14622 char *kwnames[] = {
14623 (char *) "self",(char *) "obj", NULL
14624 };
14625
14626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14628 if (SWIG_arg_fail(1)) SWIG_fail;
14629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14630 if (SWIG_arg_fail(2)) SWIG_fail;
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 (arg1)->SetEventObject(arg2);
14634
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 Py_INCREF(Py_None); resultobj = Py_None;
14639 return resultobj;
14640 fail:
14641 return NULL;
14642 }
14643
14644
14645 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14646 PyObject *resultobj;
14647 wxEvent *arg1 = (wxEvent *) 0 ;
14648 long result;
14649 PyObject * obj0 = 0 ;
14650 char *kwnames[] = {
14651 (char *) "self", NULL
14652 };
14653
14654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14656 if (SWIG_arg_fail(1)) SWIG_fail;
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14660
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 {
14665 resultobj = SWIG_From_long((long)(result));
14666 }
14667 return resultobj;
14668 fail:
14669 return NULL;
14670 }
14671
14672
14673 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14674 PyObject *resultobj;
14675 wxEvent *arg1 = (wxEvent *) 0 ;
14676 long arg2 = (long) 0 ;
14677 PyObject * obj0 = 0 ;
14678 PyObject * obj1 = 0 ;
14679 char *kwnames[] = {
14680 (char *) "self",(char *) "ts", NULL
14681 };
14682
14683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14685 if (SWIG_arg_fail(1)) SWIG_fail;
14686 if (obj1) {
14687 {
14688 arg2 = (long)(SWIG_As_long(obj1));
14689 if (SWIG_arg_fail(2)) SWIG_fail;
14690 }
14691 }
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 (arg1)->SetTimestamp(arg2);
14695
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 Py_INCREF(Py_None); resultobj = Py_None;
14700 return resultobj;
14701 fail:
14702 return NULL;
14703 }
14704
14705
14706 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14707 PyObject *resultobj;
14708 wxEvent *arg1 = (wxEvent *) 0 ;
14709 int result;
14710 PyObject * obj0 = 0 ;
14711 char *kwnames[] = {
14712 (char *) "self", NULL
14713 };
14714
14715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14717 if (SWIG_arg_fail(1)) SWIG_fail;
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (int)((wxEvent const *)arg1)->GetId();
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 {
14726 resultobj = SWIG_From_int((int)(result));
14727 }
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj;
14736 wxEvent *arg1 = (wxEvent *) 0 ;
14737 int arg2 ;
14738 PyObject * obj0 = 0 ;
14739 PyObject * obj1 = 0 ;
14740 char *kwnames[] = {
14741 (char *) "self",(char *) "Id", NULL
14742 };
14743
14744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14746 if (SWIG_arg_fail(1)) SWIG_fail;
14747 {
14748 arg2 = (int)(SWIG_As_int(obj1));
14749 if (SWIG_arg_fail(2)) SWIG_fail;
14750 }
14751 {
14752 PyThreadState* __tstate = wxPyBeginAllowThreads();
14753 (arg1)->SetId(arg2);
14754
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 Py_INCREF(Py_None); resultobj = Py_None;
14759 return resultobj;
14760 fail:
14761 return NULL;
14762 }
14763
14764
14765 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14766 PyObject *resultobj;
14767 wxEvent *arg1 = (wxEvent *) 0 ;
14768 bool result;
14769 PyObject * obj0 = 0 ;
14770 char *kwnames[] = {
14771 (char *) "self", NULL
14772 };
14773
14774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",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 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 {
14785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14786 }
14787 return resultobj;
14788 fail:
14789 return NULL;
14790 }
14791
14792
14793 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14794 PyObject *resultobj;
14795 wxEvent *arg1 = (wxEvent *) 0 ;
14796 bool arg2 = (bool) true ;
14797 PyObject * obj0 = 0 ;
14798 PyObject * obj1 = 0 ;
14799 char *kwnames[] = {
14800 (char *) "self",(char *) "skip", NULL
14801 };
14802
14803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14805 if (SWIG_arg_fail(1)) SWIG_fail;
14806 if (obj1) {
14807 {
14808 arg2 = (bool)(SWIG_As_bool(obj1));
14809 if (SWIG_arg_fail(2)) SWIG_fail;
14810 }
14811 }
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 (arg1)->Skip(arg2);
14815
14816 wxPyEndAllowThreads(__tstate);
14817 if (PyErr_Occurred()) SWIG_fail;
14818 }
14819 Py_INCREF(Py_None); resultobj = Py_None;
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj;
14828 wxEvent *arg1 = (wxEvent *) 0 ;
14829 bool result;
14830 PyObject * obj0 = 0 ;
14831 char *kwnames[] = {
14832 (char *) "self", NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14837 if (SWIG_arg_fail(1)) SWIG_fail;
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14841
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 {
14846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14847 }
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj;
14856 wxEvent *arg1 = (wxEvent *) 0 ;
14857 bool result;
14858 PyObject * obj0 = 0 ;
14859 char *kwnames[] = {
14860 (char *) "self", NULL
14861 };
14862
14863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14865 if (SWIG_arg_fail(1)) SWIG_fail;
14866 {
14867 PyThreadState* __tstate = wxPyBeginAllowThreads();
14868 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14869
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 {
14874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14875 }
14876 return resultobj;
14877 fail:
14878 return NULL;
14879 }
14880
14881
14882 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14883 PyObject *resultobj;
14884 wxEvent *arg1 = (wxEvent *) 0 ;
14885 int result;
14886 PyObject * obj0 = 0 ;
14887 char *kwnames[] = {
14888 (char *) "self", NULL
14889 };
14890
14891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14893 if (SWIG_arg_fail(1)) SWIG_fail;
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (int)(arg1)->StopPropagation();
14897
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 {
14902 resultobj = SWIG_From_int((int)(result));
14903 }
14904 return resultobj;
14905 fail:
14906 return NULL;
14907 }
14908
14909
14910 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14911 PyObject *resultobj;
14912 wxEvent *arg1 = (wxEvent *) 0 ;
14913 int arg2 ;
14914 PyObject * obj0 = 0 ;
14915 PyObject * obj1 = 0 ;
14916 char *kwnames[] = {
14917 (char *) "self",(char *) "propagationLevel", NULL
14918 };
14919
14920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14922 if (SWIG_arg_fail(1)) SWIG_fail;
14923 {
14924 arg2 = (int)(SWIG_As_int(obj1));
14925 if (SWIG_arg_fail(2)) SWIG_fail;
14926 }
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 (arg1)->ResumePropagation(arg2);
14930
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 Py_INCREF(Py_None); resultobj = Py_None;
14935 return resultobj;
14936 fail:
14937 return NULL;
14938 }
14939
14940
14941 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14942 PyObject *resultobj;
14943 wxEvent *arg1 = (wxEvent *) 0 ;
14944 wxEvent *result;
14945 PyObject * obj0 = 0 ;
14946 char *kwnames[] = {
14947 (char *) "self", NULL
14948 };
14949
14950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14952 if (SWIG_arg_fail(1)) SWIG_fail;
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 result = (wxEvent *)(arg1)->Clone();
14956
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14968 PyObject *obj;
14969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14970 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14971 Py_INCREF(obj);
14972 return Py_BuildValue((char *)"");
14973 }
14974 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj;
14976 wxEvent *arg1 = 0 ;
14977 wxPropagationDisabler *result;
14978 PyObject * obj0 = 0 ;
14979 char *kwnames[] = {
14980 (char *) "event", NULL
14981 };
14982
14983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14984 {
14985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14986 if (SWIG_arg_fail(1)) SWIG_fail;
14987 if (arg1 == NULL) {
14988 SWIG_null_ref("wxEvent");
14989 }
14990 if (SWIG_arg_fail(1)) SWIG_fail;
14991 }
14992 {
14993 PyThreadState* __tstate = wxPyBeginAllowThreads();
14994 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14995
14996 wxPyEndAllowThreads(__tstate);
14997 if (PyErr_Occurred()) SWIG_fail;
14998 }
14999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15000 return resultobj;
15001 fail:
15002 return NULL;
15003 }
15004
15005
15006 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15007 PyObject *resultobj;
15008 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15009 PyObject * obj0 = 0 ;
15010 char *kwnames[] = {
15011 (char *) "self", NULL
15012 };
15013
15014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15016 if (SWIG_arg_fail(1)) SWIG_fail;
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 delete arg1;
15020
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 Py_INCREF(Py_None); resultobj = Py_None;
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15032 PyObject *obj;
15033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15034 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15035 Py_INCREF(obj);
15036 return Py_BuildValue((char *)"");
15037 }
15038 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15039 PyObject *resultobj;
15040 wxEvent *arg1 = 0 ;
15041 wxPropagateOnce *result;
15042 PyObject * obj0 = 0 ;
15043 char *kwnames[] = {
15044 (char *) "event", NULL
15045 };
15046
15047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15048 {
15049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15050 if (SWIG_arg_fail(1)) SWIG_fail;
15051 if (arg1 == NULL) {
15052 SWIG_null_ref("wxEvent");
15053 }
15054 if (SWIG_arg_fail(1)) SWIG_fail;
15055 }
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15059
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15071 PyObject *resultobj;
15072 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15073 PyObject * obj0 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 delete arg1;
15084
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 Py_INCREF(Py_None); resultobj = Py_None;
15089 return resultobj;
15090 fail:
15091 return NULL;
15092 }
15093
15094
15095 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15096 PyObject *obj;
15097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15098 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15099 Py_INCREF(obj);
15100 return Py_BuildValue((char *)"");
15101 }
15102 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15103 PyObject *resultobj;
15104 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15105 int arg2 = (int) 0 ;
15106 wxCommandEvent *result;
15107 PyObject * obj0 = 0 ;
15108 PyObject * obj1 = 0 ;
15109 char *kwnames[] = {
15110 (char *) "commandType",(char *) "winid", NULL
15111 };
15112
15113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15114 if (obj0) {
15115 {
15116 arg1 = (wxEventType)(SWIG_As_int(obj0));
15117 if (SWIG_arg_fail(1)) SWIG_fail;
15118 }
15119 }
15120 if (obj1) {
15121 {
15122 arg2 = (int)(SWIG_As_int(obj1));
15123 if (SWIG_arg_fail(2)) SWIG_fail;
15124 }
15125 }
15126 {
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15129
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj;
15142 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15143 int result;
15144 PyObject * obj0 = 0 ;
15145 char *kwnames[] = {
15146 (char *) "self", NULL
15147 };
15148
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15151 if (SWIG_arg_fail(1)) SWIG_fail;
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15155
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 {
15160 resultobj = SWIG_From_int((int)(result));
15161 }
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj;
15170 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15171 wxString *arg2 = 0 ;
15172 bool temp2 = false ;
15173 PyObject * obj0 = 0 ;
15174 PyObject * obj1 = 0 ;
15175 char *kwnames[] = {
15176 (char *) "self",(char *) "s", NULL
15177 };
15178
15179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15181 if (SWIG_arg_fail(1)) SWIG_fail;
15182 {
15183 arg2 = wxString_in_helper(obj1);
15184 if (arg2 == NULL) SWIG_fail;
15185 temp2 = true;
15186 }
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 (arg1)->SetString((wxString const &)*arg2);
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 Py_INCREF(Py_None); resultobj = Py_None;
15195 {
15196 if (temp2)
15197 delete arg2;
15198 }
15199 return resultobj;
15200 fail:
15201 {
15202 if (temp2)
15203 delete arg2;
15204 }
15205 return NULL;
15206 }
15207
15208
15209 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15210 PyObject *resultobj;
15211 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15212 wxString result;
15213 PyObject * obj0 = 0 ;
15214 char *kwnames[] = {
15215 (char *) "self", NULL
15216 };
15217
15218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15220 if (SWIG_arg_fail(1)) SWIG_fail;
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 result = ((wxCommandEvent const *)arg1)->GetString();
15224
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 {
15229 #if wxUSE_UNICODE
15230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15231 #else
15232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15233 #endif
15234 }
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15242 PyObject *resultobj;
15243 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15244 bool result;
15245 PyObject * obj0 = 0 ;
15246 char *kwnames[] = {
15247 (char *) "self", NULL
15248 };
15249
15250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 {
15261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15262 }
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15270 PyObject *resultobj;
15271 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15272 bool result;
15273 PyObject * obj0 = 0 ;
15274 char *kwnames[] = {
15275 (char *) "self", NULL
15276 };
15277
15278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15280 if (SWIG_arg_fail(1)) SWIG_fail;
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15284
15285 wxPyEndAllowThreads(__tstate);
15286 if (PyErr_Occurred()) SWIG_fail;
15287 }
15288 {
15289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15290 }
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15298 PyObject *resultobj;
15299 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15300 long arg2 ;
15301 PyObject * obj0 = 0 ;
15302 PyObject * obj1 = 0 ;
15303 char *kwnames[] = {
15304 (char *) "self",(char *) "extraLong", NULL
15305 };
15306
15307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15309 if (SWIG_arg_fail(1)) SWIG_fail;
15310 {
15311 arg2 = (long)(SWIG_As_long(obj1));
15312 if (SWIG_arg_fail(2)) SWIG_fail;
15313 }
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 (arg1)->SetExtraLong(arg2);
15317
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 Py_INCREF(Py_None); resultobj = Py_None;
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15329 PyObject *resultobj;
15330 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15331 long result;
15332 PyObject * obj0 = 0 ;
15333 char *kwnames[] = {
15334 (char *) "self", NULL
15335 };
15336
15337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15339 if (SWIG_arg_fail(1)) SWIG_fail;
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15343
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 {
15348 resultobj = SWIG_From_long((long)(result));
15349 }
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15357 PyObject *resultobj;
15358 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15359 int arg2 ;
15360 PyObject * obj0 = 0 ;
15361 PyObject * obj1 = 0 ;
15362 char *kwnames[] = {
15363 (char *) "self",(char *) "i", NULL
15364 };
15365
15366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15368 if (SWIG_arg_fail(1)) SWIG_fail;
15369 {
15370 arg2 = (int)(SWIG_As_int(obj1));
15371 if (SWIG_arg_fail(2)) SWIG_fail;
15372 }
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 (arg1)->SetInt(arg2);
15376
15377 wxPyEndAllowThreads(__tstate);
15378 if (PyErr_Occurred()) SWIG_fail;
15379 }
15380 Py_INCREF(Py_None); resultobj = Py_None;
15381 return resultobj;
15382 fail:
15383 return NULL;
15384 }
15385
15386
15387 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15388 PyObject *resultobj;
15389 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15390 long result;
15391 PyObject * obj0 = 0 ;
15392 char *kwnames[] = {
15393 (char *) "self", NULL
15394 };
15395
15396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(1)) SWIG_fail;
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 {
15407 resultobj = SWIG_From_long((long)(result));
15408 }
15409 return resultobj;
15410 fail:
15411 return NULL;
15412 }
15413
15414
15415 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15416 PyObject *resultobj;
15417 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15418 wxEvent *result;
15419 PyObject * obj0 = 0 ;
15420 char *kwnames[] = {
15421 (char *) "self", NULL
15422 };
15423
15424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15426 if (SWIG_arg_fail(1)) SWIG_fail;
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15430
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15442 PyObject *obj;
15443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15444 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15445 Py_INCREF(obj);
15446 return Py_BuildValue((char *)"");
15447 }
15448 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15449 PyObject *resultobj;
15450 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15451 int arg2 = (int) 0 ;
15452 wxNotifyEvent *result;
15453 PyObject * obj0 = 0 ;
15454 PyObject * obj1 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "commandType",(char *) "winid", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15460 if (obj0) {
15461 {
15462 arg1 = (wxEventType)(SWIG_As_int(obj0));
15463 if (SWIG_arg_fail(1)) SWIG_fail;
15464 }
15465 }
15466 if (obj1) {
15467 {
15468 arg2 = (int)(SWIG_As_int(obj1));
15469 if (SWIG_arg_fail(2)) SWIG_fail;
15470 }
15471 }
15472 {
15473 PyThreadState* __tstate = wxPyBeginAllowThreads();
15474 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15475
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj;
15488 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15489 PyObject * obj0 = 0 ;
15490 char *kwnames[] = {
15491 (char *) "self", NULL
15492 };
15493
15494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15496 if (SWIG_arg_fail(1)) SWIG_fail;
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 (arg1)->Veto();
15500
15501 wxPyEndAllowThreads(__tstate);
15502 if (PyErr_Occurred()) SWIG_fail;
15503 }
15504 Py_INCREF(Py_None); resultobj = Py_None;
15505 return resultobj;
15506 fail:
15507 return NULL;
15508 }
15509
15510
15511 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15512 PyObject *resultobj;
15513 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15514 PyObject * obj0 = 0 ;
15515 char *kwnames[] = {
15516 (char *) "self", NULL
15517 };
15518
15519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15521 if (SWIG_arg_fail(1)) SWIG_fail;
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 (arg1)->Allow();
15525
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 Py_INCREF(Py_None); resultobj = Py_None;
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj;
15538 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15539 bool result;
15540 PyObject * obj0 = 0 ;
15541 char *kwnames[] = {
15542 (char *) "self", NULL
15543 };
15544
15545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 result = (bool)(arg1)->IsAllowed();
15551
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 {
15556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15557 }
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15565 PyObject *obj;
15566 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15567 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15568 Py_INCREF(obj);
15569 return Py_BuildValue((char *)"");
15570 }
15571 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15572 PyObject *resultobj;
15573 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15574 int arg2 = (int) 0 ;
15575 int arg3 = (int) 0 ;
15576 int arg4 = (int) 0 ;
15577 wxScrollEvent *result;
15578 PyObject * obj0 = 0 ;
15579 PyObject * obj1 = 0 ;
15580 PyObject * obj2 = 0 ;
15581 PyObject * obj3 = 0 ;
15582 char *kwnames[] = {
15583 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15584 };
15585
15586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15587 if (obj0) {
15588 {
15589 arg1 = (wxEventType)(SWIG_As_int(obj0));
15590 if (SWIG_arg_fail(1)) SWIG_fail;
15591 }
15592 }
15593 if (obj1) {
15594 {
15595 arg2 = (int)(SWIG_As_int(obj1));
15596 if (SWIG_arg_fail(2)) SWIG_fail;
15597 }
15598 }
15599 if (obj2) {
15600 {
15601 arg3 = (int)(SWIG_As_int(obj2));
15602 if (SWIG_arg_fail(3)) SWIG_fail;
15603 }
15604 }
15605 if (obj3) {
15606 {
15607 arg4 = (int)(SWIG_As_int(obj3));
15608 if (SWIG_arg_fail(4)) SWIG_fail;
15609 }
15610 }
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15614
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15619 return resultobj;
15620 fail:
15621 return NULL;
15622 }
15623
15624
15625 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15626 PyObject *resultobj;
15627 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15628 int result;
15629 PyObject * obj0 = 0 ;
15630 char *kwnames[] = {
15631 (char *) "self", NULL
15632 };
15633
15634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15636 if (SWIG_arg_fail(1)) SWIG_fail;
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15640
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 {
15645 resultobj = SWIG_From_int((int)(result));
15646 }
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15654 PyObject *resultobj;
15655 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15656 int result;
15657 PyObject * obj0 = 0 ;
15658 char *kwnames[] = {
15659 (char *) "self", NULL
15660 };
15661
15662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15664 if (SWIG_arg_fail(1)) SWIG_fail;
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15668
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 {
15673 resultobj = SWIG_From_int((int)(result));
15674 }
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj;
15683 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15684 int arg2 ;
15685 PyObject * obj0 = 0 ;
15686 PyObject * obj1 = 0 ;
15687 char *kwnames[] = {
15688 (char *) "self",(char *) "orient", NULL
15689 };
15690
15691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15693 if (SWIG_arg_fail(1)) SWIG_fail;
15694 {
15695 arg2 = (int)(SWIG_As_int(obj1));
15696 if (SWIG_arg_fail(2)) SWIG_fail;
15697 }
15698 {
15699 PyThreadState* __tstate = wxPyBeginAllowThreads();
15700 (arg1)->SetOrientation(arg2);
15701
15702 wxPyEndAllowThreads(__tstate);
15703 if (PyErr_Occurred()) SWIG_fail;
15704 }
15705 Py_INCREF(Py_None); resultobj = Py_None;
15706 return resultobj;
15707 fail:
15708 return NULL;
15709 }
15710
15711
15712 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15713 PyObject *resultobj;
15714 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15715 int arg2 ;
15716 PyObject * obj0 = 0 ;
15717 PyObject * obj1 = 0 ;
15718 char *kwnames[] = {
15719 (char *) "self",(char *) "pos", NULL
15720 };
15721
15722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15724 if (SWIG_arg_fail(1)) SWIG_fail;
15725 {
15726 arg2 = (int)(SWIG_As_int(obj1));
15727 if (SWIG_arg_fail(2)) SWIG_fail;
15728 }
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 (arg1)->SetPosition(arg2);
15732
15733 wxPyEndAllowThreads(__tstate);
15734 if (PyErr_Occurred()) SWIG_fail;
15735 }
15736 Py_INCREF(Py_None); resultobj = Py_None;
15737 return resultobj;
15738 fail:
15739 return NULL;
15740 }
15741
15742
15743 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15744 PyObject *obj;
15745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15746 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15747 Py_INCREF(obj);
15748 return Py_BuildValue((char *)"");
15749 }
15750 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15751 PyObject *resultobj;
15752 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15753 int arg2 = (int) 0 ;
15754 int arg3 = (int) 0 ;
15755 wxScrollWinEvent *result;
15756 PyObject * obj0 = 0 ;
15757 PyObject * obj1 = 0 ;
15758 PyObject * obj2 = 0 ;
15759 char *kwnames[] = {
15760 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15761 };
15762
15763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15764 if (obj0) {
15765 {
15766 arg1 = (wxEventType)(SWIG_As_int(obj0));
15767 if (SWIG_arg_fail(1)) SWIG_fail;
15768 }
15769 }
15770 if (obj1) {
15771 {
15772 arg2 = (int)(SWIG_As_int(obj1));
15773 if (SWIG_arg_fail(2)) SWIG_fail;
15774 }
15775 }
15776 if (obj2) {
15777 {
15778 arg3 = (int)(SWIG_As_int(obj2));
15779 if (SWIG_arg_fail(3)) SWIG_fail;
15780 }
15781 }
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15785
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15797 PyObject *resultobj;
15798 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15799 int result;
15800 PyObject * obj0 = 0 ;
15801 char *kwnames[] = {
15802 (char *) "self", NULL
15803 };
15804
15805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15807 if (SWIG_arg_fail(1)) SWIG_fail;
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15811
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 {
15816 resultobj = SWIG_From_int((int)(result));
15817 }
15818 return resultobj;
15819 fail:
15820 return NULL;
15821 }
15822
15823
15824 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15825 PyObject *resultobj;
15826 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15827 int result;
15828 PyObject * obj0 = 0 ;
15829 char *kwnames[] = {
15830 (char *) "self", NULL
15831 };
15832
15833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15835 if (SWIG_arg_fail(1)) SWIG_fail;
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15839
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 {
15844 resultobj = SWIG_From_int((int)(result));
15845 }
15846 return resultobj;
15847 fail:
15848 return NULL;
15849 }
15850
15851
15852 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15853 PyObject *resultobj;
15854 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15855 int arg2 ;
15856 PyObject * obj0 = 0 ;
15857 PyObject * obj1 = 0 ;
15858 char *kwnames[] = {
15859 (char *) "self",(char *) "orient", NULL
15860 };
15861
15862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15864 if (SWIG_arg_fail(1)) SWIG_fail;
15865 {
15866 arg2 = (int)(SWIG_As_int(obj1));
15867 if (SWIG_arg_fail(2)) SWIG_fail;
15868 }
15869 {
15870 PyThreadState* __tstate = wxPyBeginAllowThreads();
15871 (arg1)->SetOrientation(arg2);
15872
15873 wxPyEndAllowThreads(__tstate);
15874 if (PyErr_Occurred()) SWIG_fail;
15875 }
15876 Py_INCREF(Py_None); resultobj = Py_None;
15877 return resultobj;
15878 fail:
15879 return NULL;
15880 }
15881
15882
15883 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15884 PyObject *resultobj;
15885 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15886 int arg2 ;
15887 PyObject * obj0 = 0 ;
15888 PyObject * obj1 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "self",(char *) "pos", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15895 if (SWIG_arg_fail(1)) SWIG_fail;
15896 {
15897 arg2 = (int)(SWIG_As_int(obj1));
15898 if (SWIG_arg_fail(2)) SWIG_fail;
15899 }
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 (arg1)->SetPosition(arg2);
15903
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 Py_INCREF(Py_None); resultobj = Py_None;
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15915 PyObject *obj;
15916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15917 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15918 Py_INCREF(obj);
15919 return Py_BuildValue((char *)"");
15920 }
15921 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15922 PyObject *resultobj;
15923 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15924 wxMouseEvent *result;
15925 PyObject * obj0 = 0 ;
15926 char *kwnames[] = {
15927 (char *) "mouseType", NULL
15928 };
15929
15930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15931 if (obj0) {
15932 {
15933 arg1 = (wxEventType)(SWIG_As_int(obj0));
15934 if (SWIG_arg_fail(1)) SWIG_fail;
15935 }
15936 }
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15940
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 {
15945 resultobj = wxPyMake_wxObject(result, 1);
15946 }
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15954 PyObject *resultobj;
15955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15956 bool result;
15957 PyObject * obj0 = 0 ;
15958 char *kwnames[] = {
15959 (char *) "self", NULL
15960 };
15961
15962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15964 if (SWIG_arg_fail(1)) SWIG_fail;
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15968
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 {
15973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15974 }
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15982 PyObject *resultobj;
15983 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15984 int arg2 = (int) wxMOUSE_BTN_ANY ;
15985 bool result;
15986 PyObject * obj0 = 0 ;
15987 PyObject * obj1 = 0 ;
15988 char *kwnames[] = {
15989 (char *) "self",(char *) "but", NULL
15990 };
15991
15992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15994 if (SWIG_arg_fail(1)) SWIG_fail;
15995 if (obj1) {
15996 {
15997 arg2 = (int)(SWIG_As_int(obj1));
15998 if (SWIG_arg_fail(2)) SWIG_fail;
15999 }
16000 }
16001 {
16002 PyThreadState* __tstate = wxPyBeginAllowThreads();
16003 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16004
16005 wxPyEndAllowThreads(__tstate);
16006 if (PyErr_Occurred()) SWIG_fail;
16007 }
16008 {
16009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16010 }
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16018 PyObject *resultobj;
16019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16020 int arg2 = (int) wxMOUSE_BTN_ANY ;
16021 bool result;
16022 PyObject * obj0 = 0 ;
16023 PyObject * obj1 = 0 ;
16024 char *kwnames[] = {
16025 (char *) "self",(char *) "but", NULL
16026 };
16027
16028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16030 if (SWIG_arg_fail(1)) SWIG_fail;
16031 if (obj1) {
16032 {
16033 arg2 = (int)(SWIG_As_int(obj1));
16034 if (SWIG_arg_fail(2)) SWIG_fail;
16035 }
16036 }
16037 {
16038 PyThreadState* __tstate = wxPyBeginAllowThreads();
16039 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16040
16041 wxPyEndAllowThreads(__tstate);
16042 if (PyErr_Occurred()) SWIG_fail;
16043 }
16044 {
16045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16046 }
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj;
16055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16056 int arg2 = (int) wxMOUSE_BTN_ANY ;
16057 bool result;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 char *kwnames[] = {
16061 (char *) "self",(char *) "but", NULL
16062 };
16063
16064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 if (obj1) {
16068 {
16069 arg2 = (int)(SWIG_As_int(obj1));
16070 if (SWIG_arg_fail(2)) SWIG_fail;
16071 }
16072 }
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16076
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 {
16081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16082 }
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16090 PyObject *resultobj;
16091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16092 int arg2 ;
16093 bool result;
16094 PyObject * obj0 = 0 ;
16095 PyObject * obj1 = 0 ;
16096 char *kwnames[] = {
16097 (char *) "self",(char *) "but", NULL
16098 };
16099
16100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16102 if (SWIG_arg_fail(1)) SWIG_fail;
16103 {
16104 arg2 = (int)(SWIG_As_int(obj1));
16105 if (SWIG_arg_fail(2)) SWIG_fail;
16106 }
16107 {
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16110
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 {
16115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16116 }
16117 return resultobj;
16118 fail:
16119 return NULL;
16120 }
16121
16122
16123 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj;
16125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16126 int arg2 ;
16127 bool result;
16128 PyObject * obj0 = 0 ;
16129 PyObject * obj1 = 0 ;
16130 char *kwnames[] = {
16131 (char *) "self",(char *) "but", NULL
16132 };
16133
16134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16136 if (SWIG_arg_fail(1)) SWIG_fail;
16137 {
16138 arg2 = (int)(SWIG_As_int(obj1));
16139 if (SWIG_arg_fail(2)) SWIG_fail;
16140 }
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16144
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 {
16149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16150 }
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj;
16159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16160 int result;
16161 PyObject * obj0 = 0 ;
16162 char *kwnames[] = {
16163 (char *) "self", NULL
16164 };
16165
16166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16168 if (SWIG_arg_fail(1)) SWIG_fail;
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16172
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 {
16177 resultobj = SWIG_From_int((int)(result));
16178 }
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16186 PyObject *resultobj;
16187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16188 bool result;
16189 PyObject * obj0 = 0 ;
16190 char *kwnames[] = {
16191 (char *) "self", NULL
16192 };
16193
16194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16196 if (SWIG_arg_fail(1)) SWIG_fail;
16197 {
16198 PyThreadState* __tstate = wxPyBeginAllowThreads();
16199 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16200
16201 wxPyEndAllowThreads(__tstate);
16202 if (PyErr_Occurred()) SWIG_fail;
16203 }
16204 {
16205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16206 }
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16214 PyObject *resultobj;
16215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16216 bool result;
16217 PyObject * obj0 = 0 ;
16218 char *kwnames[] = {
16219 (char *) "self", NULL
16220 };
16221
16222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16224 if (SWIG_arg_fail(1)) SWIG_fail;
16225 {
16226 PyThreadState* __tstate = wxPyBeginAllowThreads();
16227 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16228
16229 wxPyEndAllowThreads(__tstate);
16230 if (PyErr_Occurred()) SWIG_fail;
16231 }
16232 {
16233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16234 }
16235 return resultobj;
16236 fail:
16237 return NULL;
16238 }
16239
16240
16241 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16242 PyObject *resultobj;
16243 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16244 bool result;
16245 PyObject * obj0 = 0 ;
16246 char *kwnames[] = {
16247 (char *) "self", NULL
16248 };
16249
16250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16252 if (SWIG_arg_fail(1)) SWIG_fail;
16253 {
16254 PyThreadState* __tstate = wxPyBeginAllowThreads();
16255 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16256
16257 wxPyEndAllowThreads(__tstate);
16258 if (PyErr_Occurred()) SWIG_fail;
16259 }
16260 {
16261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16262 }
16263 return resultobj;
16264 fail:
16265 return NULL;
16266 }
16267
16268
16269 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16270 PyObject *resultobj;
16271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16272 bool result;
16273 PyObject * obj0 = 0 ;
16274 char *kwnames[] = {
16275 (char *) "self", NULL
16276 };
16277
16278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16280 if (SWIG_arg_fail(1)) SWIG_fail;
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16284
16285 wxPyEndAllowThreads(__tstate);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 }
16288 {
16289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16290 }
16291 return resultobj;
16292 fail:
16293 return NULL;
16294 }
16295
16296
16297 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16298 PyObject *resultobj;
16299 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16300 bool result;
16301 PyObject * obj0 = 0 ;
16302 char *kwnames[] = {
16303 (char *) "self", NULL
16304 };
16305
16306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16308 if (SWIG_arg_fail(1)) SWIG_fail;
16309 {
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16312
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 {
16317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16318 }
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj;
16327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16328 bool result;
16329 PyObject * obj0 = 0 ;
16330 char *kwnames[] = {
16331 (char *) "self", NULL
16332 };
16333
16334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16336 if (SWIG_arg_fail(1)) SWIG_fail;
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16340
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 {
16345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16346 }
16347 return resultobj;
16348 fail:
16349 return NULL;
16350 }
16351
16352
16353 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16354 PyObject *resultobj;
16355 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16356 bool result;
16357 PyObject * obj0 = 0 ;
16358 char *kwnames[] = {
16359 (char *) "self", NULL
16360 };
16361
16362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16368
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 {
16373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16374 }
16375 return resultobj;
16376 fail:
16377 return NULL;
16378 }
16379
16380
16381 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16382 PyObject *resultobj;
16383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16384 bool result;
16385 PyObject * obj0 = 0 ;
16386 char *kwnames[] = {
16387 (char *) "self", NULL
16388 };
16389
16390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16392 if (SWIG_arg_fail(1)) SWIG_fail;
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16396
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 {
16401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16402 }
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16410 PyObject *resultobj;
16411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16412 bool result;
16413 PyObject * obj0 = 0 ;
16414 char *kwnames[] = {
16415 (char *) "self", NULL
16416 };
16417
16418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16420 if (SWIG_arg_fail(1)) SWIG_fail;
16421 {
16422 PyThreadState* __tstate = wxPyBeginAllowThreads();
16423 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16424
16425 wxPyEndAllowThreads(__tstate);
16426 if (PyErr_Occurred()) SWIG_fail;
16427 }
16428 {
16429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16430 }
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj;
16439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16440 bool result;
16441 PyObject * obj0 = 0 ;
16442 char *kwnames[] = {
16443 (char *) "self", NULL
16444 };
16445
16446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16448 if (SWIG_arg_fail(1)) SWIG_fail;
16449 {
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16452
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 {
16457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16458 }
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj;
16467 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16468 bool result;
16469 PyObject * obj0 = 0 ;
16470 char *kwnames[] = {
16471 (char *) "self", NULL
16472 };
16473
16474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16476 if (SWIG_arg_fail(1)) SWIG_fail;
16477 {
16478 PyThreadState* __tstate = wxPyBeginAllowThreads();
16479 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16480
16481 wxPyEndAllowThreads(__tstate);
16482 if (PyErr_Occurred()) SWIG_fail;
16483 }
16484 {
16485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16486 }
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16494 PyObject *resultobj;
16495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16496 bool result;
16497 PyObject * obj0 = 0 ;
16498 char *kwnames[] = {
16499 (char *) "self", NULL
16500 };
16501
16502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16504 if (SWIG_arg_fail(1)) SWIG_fail;
16505 {
16506 PyThreadState* __tstate = wxPyBeginAllowThreads();
16507 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16508
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 {
16513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16514 }
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj;
16523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16524 bool result;
16525 PyObject * obj0 = 0 ;
16526 char *kwnames[] = {
16527 (char *) "self", NULL
16528 };
16529
16530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16532 if (SWIG_arg_fail(1)) SWIG_fail;
16533 {
16534 PyThreadState* __tstate = wxPyBeginAllowThreads();
16535 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16536
16537 wxPyEndAllowThreads(__tstate);
16538 if (PyErr_Occurred()) SWIG_fail;
16539 }
16540 {
16541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16542 }
16543 return resultobj;
16544 fail:
16545 return NULL;
16546 }
16547
16548
16549 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16550 PyObject *resultobj;
16551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16552 bool result;
16553 PyObject * obj0 = 0 ;
16554 char *kwnames[] = {
16555 (char *) "self", NULL
16556 };
16557
16558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16560 if (SWIG_arg_fail(1)) SWIG_fail;
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16564
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 {
16569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16570 }
16571 return resultobj;
16572 fail:
16573 return NULL;
16574 }
16575
16576
16577 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16578 PyObject *resultobj;
16579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16580 bool result;
16581 PyObject * obj0 = 0 ;
16582 char *kwnames[] = {
16583 (char *) "self", NULL
16584 };
16585
16586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16588 if (SWIG_arg_fail(1)) SWIG_fail;
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 result = (bool)(arg1)->LeftIsDown();
16592
16593 wxPyEndAllowThreads(__tstate);
16594 if (PyErr_Occurred()) SWIG_fail;
16595 }
16596 {
16597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16598 }
16599 return resultobj;
16600 fail:
16601 return NULL;
16602 }
16603
16604
16605 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj;
16607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16608 bool result;
16609 PyObject * obj0 = 0 ;
16610 char *kwnames[] = {
16611 (char *) "self", NULL
16612 };
16613
16614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16616 if (SWIG_arg_fail(1)) SWIG_fail;
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 result = (bool)(arg1)->MiddleIsDown();
16620
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 {
16625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16626 }
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj;
16635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16636 bool result;
16637 PyObject * obj0 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (bool)(arg1)->RightIsDown();
16648
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 {
16653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16654 }
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj;
16663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16664 bool result;
16665 PyObject * obj0 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "self", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16672 if (SWIG_arg_fail(1)) SWIG_fail;
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16676
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16682 }
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj;
16691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16692 bool result;
16693 PyObject * obj0 = 0 ;
16694 char *kwnames[] = {
16695 (char *) "self", NULL
16696 };
16697
16698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16700 if (SWIG_arg_fail(1)) SWIG_fail;
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16704
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 {
16709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16710 }
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj;
16719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16720 bool result;
16721 PyObject * obj0 = 0 ;
16722 char *kwnames[] = {
16723 (char *) "self", NULL
16724 };
16725
16726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16728 if (SWIG_arg_fail(1)) SWIG_fail;
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16732
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 {
16737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj;
16747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16748 bool result;
16749 PyObject * obj0 = 0 ;
16750 char *kwnames[] = {
16751 (char *) "self", NULL
16752 };
16753
16754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16756 if (SWIG_arg_fail(1)) SWIG_fail;
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16760
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 {
16765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16766 }
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16776 wxPoint result;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 result = (arg1)->GetPosition();
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 {
16793 wxPoint * resultptr;
16794 resultptr = new wxPoint((wxPoint &)(result));
16795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16796 }
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj;
16805 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16806 long *arg2 = (long *) 0 ;
16807 long *arg3 = (long *) 0 ;
16808 long temp2 ;
16809 int res2 = 0 ;
16810 long temp3 ;
16811 int res3 = 0 ;
16812 PyObject * obj0 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self", NULL
16815 };
16816
16817 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16818 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(1)) SWIG_fail;
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 (arg1)->GetPosition(arg2,arg3);
16825
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 Py_INCREF(Py_None); resultobj = Py_None;
16830 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16831 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16832 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16833 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16843 wxDC *arg2 = 0 ;
16844 wxPoint result;
16845 PyObject * obj0 = 0 ;
16846 PyObject * obj1 = 0 ;
16847 char *kwnames[] = {
16848 (char *) "self",(char *) "dc", NULL
16849 };
16850
16851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16853 if (SWIG_arg_fail(1)) SWIG_fail;
16854 {
16855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16856 if (SWIG_arg_fail(2)) SWIG_fail;
16857 if (arg2 == NULL) {
16858 SWIG_null_ref("wxDC");
16859 }
16860 if (SWIG_arg_fail(2)) SWIG_fail;
16861 }
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16865
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 {
16870 wxPoint * resultptr;
16871 resultptr = new wxPoint((wxPoint &)(result));
16872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16873 }
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj;
16882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16883 int result;
16884 PyObject * obj0 = 0 ;
16885 char *kwnames[] = {
16886 (char *) "self", NULL
16887 };
16888
16889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16891 if (SWIG_arg_fail(1)) SWIG_fail;
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 result = (int)((wxMouseEvent const *)arg1)->GetX();
16895
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 {
16900 resultobj = SWIG_From_int((int)(result));
16901 }
16902 return resultobj;
16903 fail:
16904 return NULL;
16905 }
16906
16907
16908 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj;
16910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16911 int result;
16912 PyObject * obj0 = 0 ;
16913 char *kwnames[] = {
16914 (char *) "self", NULL
16915 };
16916
16917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16919 if (SWIG_arg_fail(1)) SWIG_fail;
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (int)((wxMouseEvent const *)arg1)->GetY();
16923
16924 wxPyEndAllowThreads(__tstate);
16925 if (PyErr_Occurred()) SWIG_fail;
16926 }
16927 {
16928 resultobj = SWIG_From_int((int)(result));
16929 }
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16937 PyObject *resultobj;
16938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16939 int result;
16940 PyObject * obj0 = 0 ;
16941 char *kwnames[] = {
16942 (char *) "self", NULL
16943 };
16944
16945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16947 if (SWIG_arg_fail(1)) SWIG_fail;
16948 {
16949 PyThreadState* __tstate = wxPyBeginAllowThreads();
16950 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16951
16952 wxPyEndAllowThreads(__tstate);
16953 if (PyErr_Occurred()) SWIG_fail;
16954 }
16955 {
16956 resultobj = SWIG_From_int((int)(result));
16957 }
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj;
16966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16967 int result;
16968 PyObject * obj0 = 0 ;
16969 char *kwnames[] = {
16970 (char *) "self", NULL
16971 };
16972
16973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16975 if (SWIG_arg_fail(1)) SWIG_fail;
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16979
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 {
16984 resultobj = SWIG_From_int((int)(result));
16985 }
16986 return resultobj;
16987 fail:
16988 return NULL;
16989 }
16990
16991
16992 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16993 PyObject *resultobj;
16994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16995 int result;
16996 PyObject * obj0 = 0 ;
16997 char *kwnames[] = {
16998 (char *) "self", NULL
16999 };
17000
17001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17003 if (SWIG_arg_fail(1)) SWIG_fail;
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17007
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 {
17012 resultobj = SWIG_From_int((int)(result));
17013 }
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj;
17022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17023 bool result;
17024 PyObject * obj0 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17035
17036 wxPyEndAllowThreads(__tstate);
17037 if (PyErr_Occurred()) SWIG_fail;
17038 }
17039 {
17040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17041 }
17042 return resultobj;
17043 fail:
17044 return NULL;
17045 }
17046
17047
17048 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17049 PyObject *resultobj;
17050 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17051 int arg2 ;
17052 PyObject * obj0 = 0 ;
17053 PyObject * obj1 = 0 ;
17054 char *kwnames[] = {
17055 (char *) "self",(char *) "m_x", NULL
17056 };
17057
17058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17060 if (SWIG_arg_fail(1)) SWIG_fail;
17061 {
17062 arg2 = (int)(SWIG_As_int(obj1));
17063 if (SWIG_arg_fail(2)) SWIG_fail;
17064 }
17065 if (arg1) (arg1)->m_x = arg2;
17066
17067 Py_INCREF(Py_None); resultobj = Py_None;
17068 return resultobj;
17069 fail:
17070 return NULL;
17071 }
17072
17073
17074 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17075 PyObject *resultobj;
17076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17077 int result;
17078 PyObject * obj0 = 0 ;
17079 char *kwnames[] = {
17080 (char *) "self", NULL
17081 };
17082
17083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17085 if (SWIG_arg_fail(1)) SWIG_fail;
17086 result = (int) ((arg1)->m_x);
17087
17088 {
17089 resultobj = SWIG_From_int((int)(result));
17090 }
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj;
17099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17100 int arg2 ;
17101 PyObject * obj0 = 0 ;
17102 PyObject * obj1 = 0 ;
17103 char *kwnames[] = {
17104 (char *) "self",(char *) "m_y", NULL
17105 };
17106
17107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 arg2 = (int)(SWIG_As_int(obj1));
17112 if (SWIG_arg_fail(2)) SWIG_fail;
17113 }
17114 if (arg1) (arg1)->m_y = arg2;
17115
17116 Py_INCREF(Py_None); resultobj = Py_None;
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj;
17125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17126 int result;
17127 PyObject * obj0 = 0 ;
17128 char *kwnames[] = {
17129 (char *) "self", NULL
17130 };
17131
17132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17134 if (SWIG_arg_fail(1)) SWIG_fail;
17135 result = (int) ((arg1)->m_y);
17136
17137 {
17138 resultobj = SWIG_From_int((int)(result));
17139 }
17140 return resultobj;
17141 fail:
17142 return NULL;
17143 }
17144
17145
17146 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17147 PyObject *resultobj;
17148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17149 bool arg2 ;
17150 PyObject * obj0 = 0 ;
17151 PyObject * obj1 = 0 ;
17152 char *kwnames[] = {
17153 (char *) "self",(char *) "m_leftDown", NULL
17154 };
17155
17156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17158 if (SWIG_arg_fail(1)) SWIG_fail;
17159 {
17160 arg2 = (bool)(SWIG_As_bool(obj1));
17161 if (SWIG_arg_fail(2)) SWIG_fail;
17162 }
17163 if (arg1) (arg1)->m_leftDown = arg2;
17164
17165 Py_INCREF(Py_None); resultobj = Py_None;
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17175 bool result;
17176 PyObject * obj0 = 0 ;
17177 char *kwnames[] = {
17178 (char *) "self", NULL
17179 };
17180
17181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17183 if (SWIG_arg_fail(1)) SWIG_fail;
17184 result = (bool) ((arg1)->m_leftDown);
17185
17186 {
17187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17188 }
17189 return resultobj;
17190 fail:
17191 return NULL;
17192 }
17193
17194
17195 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17196 PyObject *resultobj;
17197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17198 bool arg2 ;
17199 PyObject * obj0 = 0 ;
17200 PyObject * obj1 = 0 ;
17201 char *kwnames[] = {
17202 (char *) "self",(char *) "m_middleDown", NULL
17203 };
17204
17205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17207 if (SWIG_arg_fail(1)) SWIG_fail;
17208 {
17209 arg2 = (bool)(SWIG_As_bool(obj1));
17210 if (SWIG_arg_fail(2)) SWIG_fail;
17211 }
17212 if (arg1) (arg1)->m_middleDown = arg2;
17213
17214 Py_INCREF(Py_None); resultobj = Py_None;
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17224 bool result;
17225 PyObject * obj0 = 0 ;
17226 char *kwnames[] = {
17227 (char *) "self", NULL
17228 };
17229
17230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17232 if (SWIG_arg_fail(1)) SWIG_fail;
17233 result = (bool) ((arg1)->m_middleDown);
17234
17235 {
17236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17237 }
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17245 PyObject *resultobj;
17246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17247 bool arg2 ;
17248 PyObject * obj0 = 0 ;
17249 PyObject * obj1 = 0 ;
17250 char *kwnames[] = {
17251 (char *) "self",(char *) "m_rightDown", NULL
17252 };
17253
17254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17256 if (SWIG_arg_fail(1)) SWIG_fail;
17257 {
17258 arg2 = (bool)(SWIG_As_bool(obj1));
17259 if (SWIG_arg_fail(2)) SWIG_fail;
17260 }
17261 if (arg1) (arg1)->m_rightDown = arg2;
17262
17263 Py_INCREF(Py_None); resultobj = Py_None;
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17273 bool result;
17274 PyObject * obj0 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "self", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 result = (bool) ((arg1)->m_rightDown);
17283
17284 {
17285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17286 }
17287 return resultobj;
17288 fail:
17289 return NULL;
17290 }
17291
17292
17293 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17294 PyObject *resultobj;
17295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17296 bool arg2 ;
17297 PyObject * obj0 = 0 ;
17298 PyObject * obj1 = 0 ;
17299 char *kwnames[] = {
17300 (char *) "self",(char *) "m_controlDown", NULL
17301 };
17302
17303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17305 if (SWIG_arg_fail(1)) SWIG_fail;
17306 {
17307 arg2 = (bool)(SWIG_As_bool(obj1));
17308 if (SWIG_arg_fail(2)) SWIG_fail;
17309 }
17310 if (arg1) (arg1)->m_controlDown = arg2;
17311
17312 Py_INCREF(Py_None); resultobj = Py_None;
17313 return resultobj;
17314 fail:
17315 return NULL;
17316 }
17317
17318
17319 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17320 PyObject *resultobj;
17321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17322 bool result;
17323 PyObject * obj0 = 0 ;
17324 char *kwnames[] = {
17325 (char *) "self", NULL
17326 };
17327
17328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17330 if (SWIG_arg_fail(1)) SWIG_fail;
17331 result = (bool) ((arg1)->m_controlDown);
17332
17333 {
17334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17335 }
17336 return resultobj;
17337 fail:
17338 return NULL;
17339 }
17340
17341
17342 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17343 PyObject *resultobj;
17344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17345 bool arg2 ;
17346 PyObject * obj0 = 0 ;
17347 PyObject * obj1 = 0 ;
17348 char *kwnames[] = {
17349 (char *) "self",(char *) "m_shiftDown", NULL
17350 };
17351
17352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17354 if (SWIG_arg_fail(1)) SWIG_fail;
17355 {
17356 arg2 = (bool)(SWIG_As_bool(obj1));
17357 if (SWIG_arg_fail(2)) SWIG_fail;
17358 }
17359 if (arg1) (arg1)->m_shiftDown = arg2;
17360
17361 Py_INCREF(Py_None); resultobj = Py_None;
17362 return resultobj;
17363 fail:
17364 return NULL;
17365 }
17366
17367
17368 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17369 PyObject *resultobj;
17370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17371 bool result;
17372 PyObject * obj0 = 0 ;
17373 char *kwnames[] = {
17374 (char *) "self", NULL
17375 };
17376
17377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17379 if (SWIG_arg_fail(1)) SWIG_fail;
17380 result = (bool) ((arg1)->m_shiftDown);
17381
17382 {
17383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17384 }
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj;
17393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17394 bool arg2 ;
17395 PyObject * obj0 = 0 ;
17396 PyObject * obj1 = 0 ;
17397 char *kwnames[] = {
17398 (char *) "self",(char *) "m_altDown", NULL
17399 };
17400
17401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17403 if (SWIG_arg_fail(1)) SWIG_fail;
17404 {
17405 arg2 = (bool)(SWIG_As_bool(obj1));
17406 if (SWIG_arg_fail(2)) SWIG_fail;
17407 }
17408 if (arg1) (arg1)->m_altDown = arg2;
17409
17410 Py_INCREF(Py_None); resultobj = Py_None;
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17420 bool result;
17421 PyObject * obj0 = 0 ;
17422 char *kwnames[] = {
17423 (char *) "self", NULL
17424 };
17425
17426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17428 if (SWIG_arg_fail(1)) SWIG_fail;
17429 result = (bool) ((arg1)->m_altDown);
17430
17431 {
17432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17433 }
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj;
17442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17443 bool arg2 ;
17444 PyObject * obj0 = 0 ;
17445 PyObject * obj1 = 0 ;
17446 char *kwnames[] = {
17447 (char *) "self",(char *) "m_metaDown", NULL
17448 };
17449
17450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17452 if (SWIG_arg_fail(1)) SWIG_fail;
17453 {
17454 arg2 = (bool)(SWIG_As_bool(obj1));
17455 if (SWIG_arg_fail(2)) SWIG_fail;
17456 }
17457 if (arg1) (arg1)->m_metaDown = arg2;
17458
17459 Py_INCREF(Py_None); resultobj = Py_None;
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17467 PyObject *resultobj;
17468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17469 bool result;
17470 PyObject * obj0 = 0 ;
17471 char *kwnames[] = {
17472 (char *) "self", NULL
17473 };
17474
17475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17477 if (SWIG_arg_fail(1)) SWIG_fail;
17478 result = (bool) ((arg1)->m_metaDown);
17479
17480 {
17481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17482 }
17483 return resultobj;
17484 fail:
17485 return NULL;
17486 }
17487
17488
17489 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17490 PyObject *resultobj;
17491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17492 int arg2 ;
17493 PyObject * obj0 = 0 ;
17494 PyObject * obj1 = 0 ;
17495 char *kwnames[] = {
17496 (char *) "self",(char *) "m_wheelRotation", NULL
17497 };
17498
17499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17501 if (SWIG_arg_fail(1)) SWIG_fail;
17502 {
17503 arg2 = (int)(SWIG_As_int(obj1));
17504 if (SWIG_arg_fail(2)) SWIG_fail;
17505 }
17506 if (arg1) (arg1)->m_wheelRotation = arg2;
17507
17508 Py_INCREF(Py_None); resultobj = Py_None;
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj;
17517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17518 int result;
17519 PyObject * obj0 = 0 ;
17520 char *kwnames[] = {
17521 (char *) "self", NULL
17522 };
17523
17524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17526 if (SWIG_arg_fail(1)) SWIG_fail;
17527 result = (int) ((arg1)->m_wheelRotation);
17528
17529 {
17530 resultobj = SWIG_From_int((int)(result));
17531 }
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17539 PyObject *resultobj;
17540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17541 int arg2 ;
17542 PyObject * obj0 = 0 ;
17543 PyObject * obj1 = 0 ;
17544 char *kwnames[] = {
17545 (char *) "self",(char *) "m_wheelDelta", NULL
17546 };
17547
17548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17550 if (SWIG_arg_fail(1)) SWIG_fail;
17551 {
17552 arg2 = (int)(SWIG_As_int(obj1));
17553 if (SWIG_arg_fail(2)) SWIG_fail;
17554 }
17555 if (arg1) (arg1)->m_wheelDelta = arg2;
17556
17557 Py_INCREF(Py_None); resultobj = Py_None;
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17567 int result;
17568 PyObject * obj0 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 result = (int) ((arg1)->m_wheelDelta);
17577
17578 {
17579 resultobj = SWIG_From_int((int)(result));
17580 }
17581 return resultobj;
17582 fail:
17583 return NULL;
17584 }
17585
17586
17587 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17588 PyObject *resultobj;
17589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17590 int arg2 ;
17591 PyObject * obj0 = 0 ;
17592 PyObject * obj1 = 0 ;
17593 char *kwnames[] = {
17594 (char *) "self",(char *) "m_linesPerAction", NULL
17595 };
17596
17597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17599 if (SWIG_arg_fail(1)) SWIG_fail;
17600 {
17601 arg2 = (int)(SWIG_As_int(obj1));
17602 if (SWIG_arg_fail(2)) SWIG_fail;
17603 }
17604 if (arg1) (arg1)->m_linesPerAction = arg2;
17605
17606 Py_INCREF(Py_None); resultobj = Py_None;
17607 return resultobj;
17608 fail:
17609 return NULL;
17610 }
17611
17612
17613 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj;
17615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17616 int result;
17617 PyObject * obj0 = 0 ;
17618 char *kwnames[] = {
17619 (char *) "self", NULL
17620 };
17621
17622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17624 if (SWIG_arg_fail(1)) SWIG_fail;
17625 result = (int) ((arg1)->m_linesPerAction);
17626
17627 {
17628 resultobj = SWIG_From_int((int)(result));
17629 }
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17637 PyObject *obj;
17638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17639 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17640 Py_INCREF(obj);
17641 return Py_BuildValue((char *)"");
17642 }
17643 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17644 PyObject *resultobj;
17645 int arg1 = (int) 0 ;
17646 int arg2 = (int) 0 ;
17647 wxSetCursorEvent *result;
17648 PyObject * obj0 = 0 ;
17649 PyObject * obj1 = 0 ;
17650 char *kwnames[] = {
17651 (char *) "x",(char *) "y", NULL
17652 };
17653
17654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17655 if (obj0) {
17656 {
17657 arg1 = (int)(SWIG_As_int(obj0));
17658 if (SWIG_arg_fail(1)) SWIG_fail;
17659 }
17660 }
17661 if (obj1) {
17662 {
17663 arg2 = (int)(SWIG_As_int(obj1));
17664 if (SWIG_arg_fail(2)) SWIG_fail;
17665 }
17666 }
17667 {
17668 PyThreadState* __tstate = wxPyBeginAllowThreads();
17669 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17670
17671 wxPyEndAllowThreads(__tstate);
17672 if (PyErr_Occurred()) SWIG_fail;
17673 }
17674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj;
17683 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17684 int result;
17685 PyObject * obj0 = 0 ;
17686 char *kwnames[] = {
17687 (char *) "self", NULL
17688 };
17689
17690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(1)) SWIG_fail;
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 {
17701 resultobj = SWIG_From_int((int)(result));
17702 }
17703 return resultobj;
17704 fail:
17705 return NULL;
17706 }
17707
17708
17709 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj;
17711 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17712 int result;
17713 PyObject * obj0 = 0 ;
17714 char *kwnames[] = {
17715 (char *) "self", NULL
17716 };
17717
17718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17720 if (SWIG_arg_fail(1)) SWIG_fail;
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17724
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 {
17729 resultobj = SWIG_From_int((int)(result));
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj;
17739 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17740 wxCursor *arg2 = 0 ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 char *kwnames[] = {
17744 (char *) "self",(char *) "cursor", NULL
17745 };
17746
17747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17749 if (SWIG_arg_fail(1)) SWIG_fail;
17750 {
17751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17752 if (SWIG_arg_fail(2)) SWIG_fail;
17753 if (arg2 == NULL) {
17754 SWIG_null_ref("wxCursor");
17755 }
17756 if (SWIG_arg_fail(2)) SWIG_fail;
17757 }
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 (arg1)->SetCursor((wxCursor const &)*arg2);
17761
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 Py_INCREF(Py_None); resultobj = Py_None;
17766 return resultobj;
17767 fail:
17768 return NULL;
17769 }
17770
17771
17772 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17773 PyObject *resultobj;
17774 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17775 wxCursor *result;
17776 PyObject * obj0 = 0 ;
17777 char *kwnames[] = {
17778 (char *) "self", NULL
17779 };
17780
17781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17783 if (SWIG_arg_fail(1)) SWIG_fail;
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 {
17787 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17788 result = (wxCursor *) &_result_ref;
17789 }
17790
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 {
17795 wxCursor* resultptr = new wxCursor(*result);
17796 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17797 }
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj;
17806 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17807 bool result;
17808 PyObject * obj0 = 0 ;
17809 char *kwnames[] = {
17810 (char *) "self", NULL
17811 };
17812
17813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17815 if (SWIG_arg_fail(1)) SWIG_fail;
17816 {
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17819
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17825 }
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17833 PyObject *obj;
17834 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17835 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17836 Py_INCREF(obj);
17837 return Py_BuildValue((char *)"");
17838 }
17839 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17840 PyObject *resultobj;
17841 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17842 wxKeyEvent *result;
17843 PyObject * obj0 = 0 ;
17844 char *kwnames[] = {
17845 (char *) "keyType", NULL
17846 };
17847
17848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17849 if (obj0) {
17850 {
17851 arg1 = (wxEventType)(SWIG_As_int(obj0));
17852 if (SWIG_arg_fail(1)) SWIG_fail;
17853 }
17854 }
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17863 return resultobj;
17864 fail:
17865 return NULL;
17866 }
17867
17868
17869 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17870 PyObject *resultobj;
17871 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17872 bool result;
17873 PyObject * obj0 = 0 ;
17874 char *kwnames[] = {
17875 (char *) "self", NULL
17876 };
17877
17878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17880 if (SWIG_arg_fail(1)) SWIG_fail;
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17890 }
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17898 PyObject *resultobj;
17899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17900 bool result;
17901 PyObject * obj0 = 0 ;
17902 char *kwnames[] = {
17903 (char *) "self", NULL
17904 };
17905
17906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17908 if (SWIG_arg_fail(1)) SWIG_fail;
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17912
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 {
17917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17918 }
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj;
17927 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17928 bool result;
17929 PyObject * obj0 = 0 ;
17930 char *kwnames[] = {
17931 (char *) "self", NULL
17932 };
17933
17934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17936 if (SWIG_arg_fail(1)) SWIG_fail;
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17940
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 {
17945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17946 }
17947 return resultobj;
17948 fail:
17949 return NULL;
17950 }
17951
17952
17953 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17954 PyObject *resultobj;
17955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17956 bool result;
17957 PyObject * obj0 = 0 ;
17958 char *kwnames[] = {
17959 (char *) "self", NULL
17960 };
17961
17962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17964 if (SWIG_arg_fail(1)) SWIG_fail;
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17968
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 {
17973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17974 }
17975 return resultobj;
17976 fail:
17977 return NULL;
17978 }
17979
17980
17981 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17982 PyObject *resultobj;
17983 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17984 bool result;
17985 PyObject * obj0 = 0 ;
17986 char *kwnames[] = {
17987 (char *) "self", NULL
17988 };
17989
17990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17992 if (SWIG_arg_fail(1)) SWIG_fail;
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17996
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 {
18001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18002 }
18003 return resultobj;
18004 fail:
18005 return NULL;
18006 }
18007
18008
18009 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18010 PyObject *resultobj;
18011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18012 bool result;
18013 PyObject * obj0 = 0 ;
18014 char *kwnames[] = {
18015 (char *) "self", NULL
18016 };
18017
18018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18020 if (SWIG_arg_fail(1)) SWIG_fail;
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18024
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 {
18029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18030 }
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj;
18039 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18040 int result;
18041 PyObject * obj0 = 0 ;
18042 char *kwnames[] = {
18043 (char *) "self", NULL
18044 };
18045
18046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18048 if (SWIG_arg_fail(1)) SWIG_fail;
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 resultobj = SWIG_From_int((int)(result));
18058 }
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj;
18067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18068 int result;
18069 PyObject * obj0 = 0 ;
18070 char *kwnames[] = {
18071 (char *) "self", NULL
18072 };
18073
18074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18076 if (SWIG_arg_fail(1)) SWIG_fail;
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18080
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 {
18085 resultobj = SWIG_From_int((int)(result));
18086 }
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj;
18095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18096 unsigned int result;
18097 PyObject * obj0 = 0 ;
18098 char *kwnames[] = {
18099 (char *) "self", NULL
18100 };
18101
18102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18104 if (SWIG_arg_fail(1)) SWIG_fail;
18105 {
18106 PyThreadState* __tstate = wxPyBeginAllowThreads();
18107 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18108
18109 wxPyEndAllowThreads(__tstate);
18110 if (PyErr_Occurred()) SWIG_fail;
18111 }
18112 {
18113 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18114 }
18115 return resultobj;
18116 fail:
18117 return NULL;
18118 }
18119
18120
18121 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18122 PyObject *resultobj;
18123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18124 unsigned int result;
18125 PyObject * obj0 = 0 ;
18126 char *kwnames[] = {
18127 (char *) "self", NULL
18128 };
18129
18130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18132 if (SWIG_arg_fail(1)) SWIG_fail;
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18136
18137 wxPyEndAllowThreads(__tstate);
18138 if (PyErr_Occurred()) SWIG_fail;
18139 }
18140 {
18141 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18142 }
18143 return resultobj;
18144 fail:
18145 return NULL;
18146 }
18147
18148
18149 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18150 PyObject *resultobj;
18151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18152 wxPoint result;
18153 PyObject * obj0 = 0 ;
18154 char *kwnames[] = {
18155 (char *) "self", NULL
18156 };
18157
18158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18160 if (SWIG_arg_fail(1)) SWIG_fail;
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (arg1)->GetPosition();
18164
18165 wxPyEndAllowThreads(__tstate);
18166 if (PyErr_Occurred()) SWIG_fail;
18167 }
18168 {
18169 wxPoint * resultptr;
18170 resultptr = new wxPoint((wxPoint &)(result));
18171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18172 }
18173 return resultobj;
18174 fail:
18175 return NULL;
18176 }
18177
18178
18179 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18180 PyObject *resultobj;
18181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18182 long *arg2 = (long *) 0 ;
18183 long *arg3 = (long *) 0 ;
18184 long temp2 ;
18185 int res2 = 0 ;
18186 long temp3 ;
18187 int res3 = 0 ;
18188 PyObject * obj0 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self", NULL
18191 };
18192
18193 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18194 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 (arg1)->GetPosition(arg2,arg3);
18201
18202 wxPyEndAllowThreads(__tstate);
18203 if (PyErr_Occurred()) SWIG_fail;
18204 }
18205 Py_INCREF(Py_None); resultobj = Py_None;
18206 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18207 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18208 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18209 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18210 return resultobj;
18211 fail:
18212 return NULL;
18213 }
18214
18215
18216 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18217 PyObject *resultobj;
18218 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18219 int result;
18220 PyObject * obj0 = 0 ;
18221 char *kwnames[] = {
18222 (char *) "self", NULL
18223 };
18224
18225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18227 if (SWIG_arg_fail(1)) SWIG_fail;
18228 {
18229 PyThreadState* __tstate = wxPyBeginAllowThreads();
18230 result = (int)((wxKeyEvent const *)arg1)->GetX();
18231
18232 wxPyEndAllowThreads(__tstate);
18233 if (PyErr_Occurred()) SWIG_fail;
18234 }
18235 {
18236 resultobj = SWIG_From_int((int)(result));
18237 }
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj;
18246 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18247 int result;
18248 PyObject * obj0 = 0 ;
18249 char *kwnames[] = {
18250 (char *) "self", NULL
18251 };
18252
18253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18255 if (SWIG_arg_fail(1)) SWIG_fail;
18256 {
18257 PyThreadState* __tstate = wxPyBeginAllowThreads();
18258 result = (int)((wxKeyEvent const *)arg1)->GetY();
18259
18260 wxPyEndAllowThreads(__tstate);
18261 if (PyErr_Occurred()) SWIG_fail;
18262 }
18263 {
18264 resultobj = SWIG_From_int((int)(result));
18265 }
18266 return resultobj;
18267 fail:
18268 return NULL;
18269 }
18270
18271
18272 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18273 PyObject *resultobj;
18274 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18275 int arg2 ;
18276 PyObject * obj0 = 0 ;
18277 PyObject * obj1 = 0 ;
18278 char *kwnames[] = {
18279 (char *) "self",(char *) "m_x", NULL
18280 };
18281
18282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18284 if (SWIG_arg_fail(1)) SWIG_fail;
18285 {
18286 arg2 = (int)(SWIG_As_int(obj1));
18287 if (SWIG_arg_fail(2)) SWIG_fail;
18288 }
18289 if (arg1) (arg1)->m_x = arg2;
18290
18291 Py_INCREF(Py_None); resultobj = Py_None;
18292 return resultobj;
18293 fail:
18294 return NULL;
18295 }
18296
18297
18298 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj;
18300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18301 int result;
18302 PyObject * obj0 = 0 ;
18303 char *kwnames[] = {
18304 (char *) "self", NULL
18305 };
18306
18307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18309 if (SWIG_arg_fail(1)) SWIG_fail;
18310 result = (int) ((arg1)->m_x);
18311
18312 {
18313 resultobj = SWIG_From_int((int)(result));
18314 }
18315 return resultobj;
18316 fail:
18317 return NULL;
18318 }
18319
18320
18321 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18322 PyObject *resultobj;
18323 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18324 int arg2 ;
18325 PyObject * obj0 = 0 ;
18326 PyObject * obj1 = 0 ;
18327 char *kwnames[] = {
18328 (char *) "self",(char *) "m_y", NULL
18329 };
18330
18331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18333 if (SWIG_arg_fail(1)) SWIG_fail;
18334 {
18335 arg2 = (int)(SWIG_As_int(obj1));
18336 if (SWIG_arg_fail(2)) SWIG_fail;
18337 }
18338 if (arg1) (arg1)->m_y = arg2;
18339
18340 Py_INCREF(Py_None); resultobj = Py_None;
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj;
18349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18350 int result;
18351 PyObject * obj0 = 0 ;
18352 char *kwnames[] = {
18353 (char *) "self", NULL
18354 };
18355
18356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18358 if (SWIG_arg_fail(1)) SWIG_fail;
18359 result = (int) ((arg1)->m_y);
18360
18361 {
18362 resultobj = SWIG_From_int((int)(result));
18363 }
18364 return resultobj;
18365 fail:
18366 return NULL;
18367 }
18368
18369
18370 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18371 PyObject *resultobj;
18372 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18373 long arg2 ;
18374 PyObject * obj0 = 0 ;
18375 PyObject * obj1 = 0 ;
18376 char *kwnames[] = {
18377 (char *) "self",(char *) "m_keyCode", NULL
18378 };
18379
18380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18382 if (SWIG_arg_fail(1)) SWIG_fail;
18383 {
18384 arg2 = (long)(SWIG_As_long(obj1));
18385 if (SWIG_arg_fail(2)) SWIG_fail;
18386 }
18387 if (arg1) (arg1)->m_keyCode = arg2;
18388
18389 Py_INCREF(Py_None); resultobj = Py_None;
18390 return resultobj;
18391 fail:
18392 return NULL;
18393 }
18394
18395
18396 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18397 PyObject *resultobj;
18398 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18399 long result;
18400 PyObject * obj0 = 0 ;
18401 char *kwnames[] = {
18402 (char *) "self", NULL
18403 };
18404
18405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18407 if (SWIG_arg_fail(1)) SWIG_fail;
18408 result = (long) ((arg1)->m_keyCode);
18409
18410 {
18411 resultobj = SWIG_From_long((long)(result));
18412 }
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj;
18421 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18422 bool arg2 ;
18423 PyObject * obj0 = 0 ;
18424 PyObject * obj1 = 0 ;
18425 char *kwnames[] = {
18426 (char *) "self",(char *) "m_controlDown", NULL
18427 };
18428
18429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18431 if (SWIG_arg_fail(1)) SWIG_fail;
18432 {
18433 arg2 = (bool)(SWIG_As_bool(obj1));
18434 if (SWIG_arg_fail(2)) SWIG_fail;
18435 }
18436 if (arg1) (arg1)->m_controlDown = arg2;
18437
18438 Py_INCREF(Py_None); resultobj = Py_None;
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18446 PyObject *resultobj;
18447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18448 bool result;
18449 PyObject * obj0 = 0 ;
18450 char *kwnames[] = {
18451 (char *) "self", NULL
18452 };
18453
18454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18456 if (SWIG_arg_fail(1)) SWIG_fail;
18457 result = (bool) ((arg1)->m_controlDown);
18458
18459 {
18460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18461 }
18462 return resultobj;
18463 fail:
18464 return NULL;
18465 }
18466
18467
18468 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj;
18470 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18471 bool arg2 ;
18472 PyObject * obj0 = 0 ;
18473 PyObject * obj1 = 0 ;
18474 char *kwnames[] = {
18475 (char *) "self",(char *) "m_shiftDown", NULL
18476 };
18477
18478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18480 if (SWIG_arg_fail(1)) SWIG_fail;
18481 {
18482 arg2 = (bool)(SWIG_As_bool(obj1));
18483 if (SWIG_arg_fail(2)) SWIG_fail;
18484 }
18485 if (arg1) (arg1)->m_shiftDown = arg2;
18486
18487 Py_INCREF(Py_None); resultobj = Py_None;
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj;
18496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18497 bool result;
18498 PyObject * obj0 = 0 ;
18499 char *kwnames[] = {
18500 (char *) "self", NULL
18501 };
18502
18503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18505 if (SWIG_arg_fail(1)) SWIG_fail;
18506 result = (bool) ((arg1)->m_shiftDown);
18507
18508 {
18509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18510 }
18511 return resultobj;
18512 fail:
18513 return NULL;
18514 }
18515
18516
18517 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj;
18519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18520 bool arg2 ;
18521 PyObject * obj0 = 0 ;
18522 PyObject * obj1 = 0 ;
18523 char *kwnames[] = {
18524 (char *) "self",(char *) "m_altDown", NULL
18525 };
18526
18527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18529 if (SWIG_arg_fail(1)) SWIG_fail;
18530 {
18531 arg2 = (bool)(SWIG_As_bool(obj1));
18532 if (SWIG_arg_fail(2)) SWIG_fail;
18533 }
18534 if (arg1) (arg1)->m_altDown = arg2;
18535
18536 Py_INCREF(Py_None); resultobj = Py_None;
18537 return resultobj;
18538 fail:
18539 return NULL;
18540 }
18541
18542
18543 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj;
18545 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18546 bool result;
18547 PyObject * obj0 = 0 ;
18548 char *kwnames[] = {
18549 (char *) "self", NULL
18550 };
18551
18552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18554 if (SWIG_arg_fail(1)) SWIG_fail;
18555 result = (bool) ((arg1)->m_altDown);
18556
18557 {
18558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18559 }
18560 return resultobj;
18561 fail:
18562 return NULL;
18563 }
18564
18565
18566 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18567 PyObject *resultobj;
18568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18569 bool arg2 ;
18570 PyObject * obj0 = 0 ;
18571 PyObject * obj1 = 0 ;
18572 char *kwnames[] = {
18573 (char *) "self",(char *) "m_metaDown", NULL
18574 };
18575
18576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18578 if (SWIG_arg_fail(1)) SWIG_fail;
18579 {
18580 arg2 = (bool)(SWIG_As_bool(obj1));
18581 if (SWIG_arg_fail(2)) SWIG_fail;
18582 }
18583 if (arg1) (arg1)->m_metaDown = arg2;
18584
18585 Py_INCREF(Py_None); resultobj = Py_None;
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj;
18594 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18595 bool result;
18596 PyObject * obj0 = 0 ;
18597 char *kwnames[] = {
18598 (char *) "self", NULL
18599 };
18600
18601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18603 if (SWIG_arg_fail(1)) SWIG_fail;
18604 result = (bool) ((arg1)->m_metaDown);
18605
18606 {
18607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18608 }
18609 return resultobj;
18610 fail:
18611 return NULL;
18612 }
18613
18614
18615 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18616 PyObject *resultobj;
18617 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18618 bool arg2 ;
18619 PyObject * obj0 = 0 ;
18620 PyObject * obj1 = 0 ;
18621 char *kwnames[] = {
18622 (char *) "self",(char *) "m_scanCode", NULL
18623 };
18624
18625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18627 if (SWIG_arg_fail(1)) SWIG_fail;
18628 {
18629 arg2 = (bool)(SWIG_As_bool(obj1));
18630 if (SWIG_arg_fail(2)) SWIG_fail;
18631 }
18632 if (arg1) (arg1)->m_scanCode = arg2;
18633
18634 Py_INCREF(Py_None); resultobj = Py_None;
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18644 bool result;
18645 PyObject * obj0 = 0 ;
18646 char *kwnames[] = {
18647 (char *) "self", NULL
18648 };
18649
18650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18652 if (SWIG_arg_fail(1)) SWIG_fail;
18653 result = (bool) ((arg1)->m_scanCode);
18654
18655 {
18656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18657 }
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18665 PyObject *resultobj;
18666 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18667 unsigned int arg2 ;
18668 PyObject * obj0 = 0 ;
18669 PyObject * obj1 = 0 ;
18670 char *kwnames[] = {
18671 (char *) "self",(char *) "m_rawCode", NULL
18672 };
18673
18674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18676 if (SWIG_arg_fail(1)) SWIG_fail;
18677 {
18678 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18679 if (SWIG_arg_fail(2)) SWIG_fail;
18680 }
18681 if (arg1) (arg1)->m_rawCode = arg2;
18682
18683 Py_INCREF(Py_None); resultobj = Py_None;
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj;
18692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18693 unsigned int result;
18694 PyObject * obj0 = 0 ;
18695 char *kwnames[] = {
18696 (char *) "self", NULL
18697 };
18698
18699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18701 if (SWIG_arg_fail(1)) SWIG_fail;
18702 result = (unsigned int) ((arg1)->m_rawCode);
18703
18704 {
18705 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18706 }
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18714 PyObject *resultobj;
18715 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18716 unsigned int arg2 ;
18717 PyObject * obj0 = 0 ;
18718 PyObject * obj1 = 0 ;
18719 char *kwnames[] = {
18720 (char *) "self",(char *) "m_rawFlags", NULL
18721 };
18722
18723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18725 if (SWIG_arg_fail(1)) SWIG_fail;
18726 {
18727 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18728 if (SWIG_arg_fail(2)) SWIG_fail;
18729 }
18730 if (arg1) (arg1)->m_rawFlags = arg2;
18731
18732 Py_INCREF(Py_None); resultobj = Py_None;
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj;
18741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18742 unsigned int result;
18743 PyObject * obj0 = 0 ;
18744 char *kwnames[] = {
18745 (char *) "self", NULL
18746 };
18747
18748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18750 if (SWIG_arg_fail(1)) SWIG_fail;
18751 result = (unsigned int) ((arg1)->m_rawFlags);
18752
18753 {
18754 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18755 }
18756 return resultobj;
18757 fail:
18758 return NULL;
18759 }
18760
18761
18762 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18763 PyObject *obj;
18764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18765 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18766 Py_INCREF(obj);
18767 return Py_BuildValue((char *)"");
18768 }
18769 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18770 PyObject *resultobj;
18771 wxSize const &arg1_defvalue = wxDefaultSize ;
18772 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18773 int arg2 = (int) 0 ;
18774 wxSizeEvent *result;
18775 wxSize temp1 ;
18776 PyObject * obj0 = 0 ;
18777 PyObject * obj1 = 0 ;
18778 char *kwnames[] = {
18779 (char *) "sz",(char *) "winid", NULL
18780 };
18781
18782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18783 if (obj0) {
18784 {
18785 arg1 = &temp1;
18786 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18787 }
18788 }
18789 if (obj1) {
18790 {
18791 arg2 = (int)(SWIG_As_int(obj1));
18792 if (SWIG_arg_fail(2)) SWIG_fail;
18793 }
18794 }
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18798
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18810 PyObject *resultobj;
18811 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18812 wxSize result;
18813 PyObject * obj0 = 0 ;
18814 char *kwnames[] = {
18815 (char *) "self", NULL
18816 };
18817
18818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18820 if (SWIG_arg_fail(1)) SWIG_fail;
18821 {
18822 PyThreadState* __tstate = wxPyBeginAllowThreads();
18823 result = ((wxSizeEvent const *)arg1)->GetSize();
18824
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 {
18829 wxSize * resultptr;
18830 resultptr = new wxSize((wxSize &)(result));
18831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18832 }
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj;
18841 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18842 wxRect result;
18843 PyObject * obj0 = 0 ;
18844 char *kwnames[] = {
18845 (char *) "self", NULL
18846 };
18847
18848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18850 if (SWIG_arg_fail(1)) SWIG_fail;
18851 {
18852 PyThreadState* __tstate = wxPyBeginAllowThreads();
18853 result = ((wxSizeEvent const *)arg1)->GetRect();
18854
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 {
18859 wxRect * resultptr;
18860 resultptr = new wxRect((wxRect &)(result));
18861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18862 }
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj;
18871 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18872 wxRect arg2 ;
18873 PyObject * obj0 = 0 ;
18874 PyObject * obj1 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self",(char *) "rect", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 {
18883 wxRect * argp;
18884 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18885 if (SWIG_arg_fail(2)) SWIG_fail;
18886 if (argp == NULL) {
18887 SWIG_null_ref("wxRect");
18888 }
18889 if (SWIG_arg_fail(2)) SWIG_fail;
18890 arg2 = *argp;
18891 }
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 (arg1)->SetRect(arg2);
18895
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 Py_INCREF(Py_None); resultobj = Py_None;
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj;
18908 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18909 wxSize arg2 ;
18910 PyObject * obj0 = 0 ;
18911 PyObject * obj1 = 0 ;
18912 char *kwnames[] = {
18913 (char *) "self",(char *) "size", NULL
18914 };
18915
18916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18918 if (SWIG_arg_fail(1)) SWIG_fail;
18919 {
18920 wxSize * argp;
18921 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18922 if (SWIG_arg_fail(2)) SWIG_fail;
18923 if (argp == NULL) {
18924 SWIG_null_ref("wxSize");
18925 }
18926 if (SWIG_arg_fail(2)) SWIG_fail;
18927 arg2 = *argp;
18928 }
18929 {
18930 PyThreadState* __tstate = wxPyBeginAllowThreads();
18931 wxSizeEvent_SetSize(arg1,arg2);
18932
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 Py_INCREF(Py_None); resultobj = Py_None;
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18944 PyObject *resultobj;
18945 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18946 wxSize *arg2 = (wxSize *) 0 ;
18947 PyObject * obj0 = 0 ;
18948 PyObject * obj1 = 0 ;
18949 char *kwnames[] = {
18950 (char *) "self",(char *) "m_size", NULL
18951 };
18952
18953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18955 if (SWIG_arg_fail(1)) SWIG_fail;
18956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18957 if (SWIG_arg_fail(2)) SWIG_fail;
18958 if (arg1) (arg1)->m_size = *arg2;
18959
18960 Py_INCREF(Py_None); resultobj = Py_None;
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj;
18969 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18970 wxSize *result;
18971 PyObject * obj0 = 0 ;
18972 char *kwnames[] = {
18973 (char *) "self", NULL
18974 };
18975
18976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18978 if (SWIG_arg_fail(1)) SWIG_fail;
18979 result = (wxSize *)& ((arg1)->m_size);
18980
18981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18982 return resultobj;
18983 fail:
18984 return NULL;
18985 }
18986
18987
18988 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj;
18990 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18991 wxRect *arg2 = (wxRect *) 0 ;
18992 PyObject * obj0 = 0 ;
18993 PyObject * obj1 = 0 ;
18994 char *kwnames[] = {
18995 (char *) "self",(char *) "m_rect", NULL
18996 };
18997
18998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19000 if (SWIG_arg_fail(1)) SWIG_fail;
19001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19002 if (SWIG_arg_fail(2)) SWIG_fail;
19003 if (arg1) (arg1)->m_rect = *arg2;
19004
19005 Py_INCREF(Py_None); resultobj = Py_None;
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj;
19014 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19015 wxRect *result;
19016 PyObject * obj0 = 0 ;
19017 char *kwnames[] = {
19018 (char *) "self", NULL
19019 };
19020
19021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19023 if (SWIG_arg_fail(1)) SWIG_fail;
19024 result = (wxRect *)& ((arg1)->m_rect);
19025
19026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19034 PyObject *obj;
19035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19036 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19037 Py_INCREF(obj);
19038 return Py_BuildValue((char *)"");
19039 }
19040 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19041 PyObject *resultobj;
19042 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19043 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19044 int arg2 = (int) 0 ;
19045 wxMoveEvent *result;
19046 wxPoint temp1 ;
19047 PyObject * obj0 = 0 ;
19048 PyObject * obj1 = 0 ;
19049 char *kwnames[] = {
19050 (char *) "pos",(char *) "winid", NULL
19051 };
19052
19053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19054 if (obj0) {
19055 {
19056 arg1 = &temp1;
19057 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19058 }
19059 }
19060 if (obj1) {
19061 {
19062 arg2 = (int)(SWIG_As_int(obj1));
19063 if (SWIG_arg_fail(2)) SWIG_fail;
19064 }
19065 }
19066 {
19067 PyThreadState* __tstate = wxPyBeginAllowThreads();
19068 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19069
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj;
19082 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19083 wxPoint result;
19084 PyObject * obj0 = 0 ;
19085 char *kwnames[] = {
19086 (char *) "self", NULL
19087 };
19088
19089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19091 if (SWIG_arg_fail(1)) SWIG_fail;
19092 {
19093 PyThreadState* __tstate = wxPyBeginAllowThreads();
19094 result = ((wxMoveEvent const *)arg1)->GetPosition();
19095
19096 wxPyEndAllowThreads(__tstate);
19097 if (PyErr_Occurred()) SWIG_fail;
19098 }
19099 {
19100 wxPoint * resultptr;
19101 resultptr = new wxPoint((wxPoint &)(result));
19102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19103 }
19104 return resultobj;
19105 fail:
19106 return NULL;
19107 }
19108
19109
19110 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19111 PyObject *resultobj;
19112 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19113 wxRect result;
19114 PyObject * obj0 = 0 ;
19115 char *kwnames[] = {
19116 (char *) "self", NULL
19117 };
19118
19119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19121 if (SWIG_arg_fail(1)) SWIG_fail;
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = ((wxMoveEvent const *)arg1)->GetRect();
19125
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 {
19130 wxRect * resultptr;
19131 resultptr = new wxRect((wxRect &)(result));
19132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19133 }
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj;
19142 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19143 wxRect *arg2 = 0 ;
19144 wxRect temp2 ;
19145 PyObject * obj0 = 0 ;
19146 PyObject * obj1 = 0 ;
19147 char *kwnames[] = {
19148 (char *) "self",(char *) "rect", NULL
19149 };
19150
19151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19153 if (SWIG_arg_fail(1)) SWIG_fail;
19154 {
19155 arg2 = &temp2;
19156 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19157 }
19158 {
19159 PyThreadState* __tstate = wxPyBeginAllowThreads();
19160 (arg1)->SetRect((wxRect const &)*arg2);
19161
19162 wxPyEndAllowThreads(__tstate);
19163 if (PyErr_Occurred()) SWIG_fail;
19164 }
19165 Py_INCREF(Py_None); resultobj = Py_None;
19166 return resultobj;
19167 fail:
19168 return NULL;
19169 }
19170
19171
19172 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19173 PyObject *resultobj;
19174 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19175 wxPoint *arg2 = 0 ;
19176 wxPoint temp2 ;
19177 PyObject * obj0 = 0 ;
19178 PyObject * obj1 = 0 ;
19179 char *kwnames[] = {
19180 (char *) "self",(char *) "pos", NULL
19181 };
19182
19183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19185 if (SWIG_arg_fail(1)) SWIG_fail;
19186 {
19187 arg2 = &temp2;
19188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19189 }
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 (arg1)->SetPosition((wxPoint const &)*arg2);
19193
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 Py_INCREF(Py_None); resultobj = Py_None;
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19205 PyObject *obj;
19206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19207 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19208 Py_INCREF(obj);
19209 return Py_BuildValue((char *)"");
19210 }
19211 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj;
19213 int arg1 = (int) 0 ;
19214 wxPaintEvent *result;
19215 PyObject * obj0 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "Id", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19221 if (obj0) {
19222 {
19223 arg1 = (int)(SWIG_As_int(obj0));
19224 if (SWIG_arg_fail(1)) SWIG_fail;
19225 }
19226 }
19227 {
19228 PyThreadState* __tstate = wxPyBeginAllowThreads();
19229 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19230
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19242 PyObject *obj;
19243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19244 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19245 Py_INCREF(obj);
19246 return Py_BuildValue((char *)"");
19247 }
19248 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19249 PyObject *resultobj;
19250 int arg1 = (int) 0 ;
19251 wxNcPaintEvent *result;
19252 PyObject * obj0 = 0 ;
19253 char *kwnames[] = {
19254 (char *) "winid", NULL
19255 };
19256
19257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19258 if (obj0) {
19259 {
19260 arg1 = (int)(SWIG_As_int(obj0));
19261 if (SWIG_arg_fail(1)) SWIG_fail;
19262 }
19263 }
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19267
19268 wxPyEndAllowThreads(__tstate);
19269 if (PyErr_Occurred()) SWIG_fail;
19270 }
19271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19279 PyObject *obj;
19280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19281 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19282 Py_INCREF(obj);
19283 return Py_BuildValue((char *)"");
19284 }
19285 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj;
19287 int arg1 = (int) 0 ;
19288 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19289 wxEraseEvent *result;
19290 PyObject * obj0 = 0 ;
19291 PyObject * obj1 = 0 ;
19292 char *kwnames[] = {
19293 (char *) "Id",(char *) "dc", NULL
19294 };
19295
19296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19297 if (obj0) {
19298 {
19299 arg1 = (int)(SWIG_As_int(obj0));
19300 if (SWIG_arg_fail(1)) SWIG_fail;
19301 }
19302 }
19303 if (obj1) {
19304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19305 if (SWIG_arg_fail(2)) SWIG_fail;
19306 }
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19310
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19315 return resultobj;
19316 fail:
19317 return NULL;
19318 }
19319
19320
19321 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19322 PyObject *resultobj;
19323 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19324 wxDC *result;
19325 PyObject * obj0 = 0 ;
19326 char *kwnames[] = {
19327 (char *) "self", NULL
19328 };
19329
19330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19332 if (SWIG_arg_fail(1)) SWIG_fail;
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19336
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 {
19341 resultobj = wxPyMake_wxObject(result, 0);
19342 }
19343 return resultobj;
19344 fail:
19345 return NULL;
19346 }
19347
19348
19349 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19350 PyObject *obj;
19351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19352 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19353 Py_INCREF(obj);
19354 return Py_BuildValue((char *)"");
19355 }
19356 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19357 PyObject *resultobj;
19358 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19359 int arg2 = (int) 0 ;
19360 wxFocusEvent *result;
19361 PyObject * obj0 = 0 ;
19362 PyObject * obj1 = 0 ;
19363 char *kwnames[] = {
19364 (char *) "type",(char *) "winid", NULL
19365 };
19366
19367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19368 if (obj0) {
19369 {
19370 arg1 = (wxEventType)(SWIG_As_int(obj0));
19371 if (SWIG_arg_fail(1)) SWIG_fail;
19372 }
19373 }
19374 if (obj1) {
19375 {
19376 arg2 = (int)(SWIG_As_int(obj1));
19377 if (SWIG_arg_fail(2)) SWIG_fail;
19378 }
19379 }
19380 {
19381 PyThreadState* __tstate = wxPyBeginAllowThreads();
19382 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19383
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19397 wxWindow *result;
19398 PyObject * obj0 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "self", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19405 if (SWIG_arg_fail(1)) SWIG_fail;
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19409
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 {
19414 resultobj = wxPyMake_wxObject(result, 0);
19415 }
19416 return resultobj;
19417 fail:
19418 return NULL;
19419 }
19420
19421
19422 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19423 PyObject *resultobj;
19424 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19425 wxWindow *arg2 = (wxWindow *) 0 ;
19426 PyObject * obj0 = 0 ;
19427 PyObject * obj1 = 0 ;
19428 char *kwnames[] = {
19429 (char *) "self",(char *) "win", NULL
19430 };
19431
19432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19434 if (SWIG_arg_fail(1)) SWIG_fail;
19435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19436 if (SWIG_arg_fail(2)) SWIG_fail;
19437 {
19438 PyThreadState* __tstate = wxPyBeginAllowThreads();
19439 (arg1)->SetWindow(arg2);
19440
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 Py_INCREF(Py_None); resultobj = Py_None;
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19452 PyObject *obj;
19453 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19454 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19455 Py_INCREF(obj);
19456 return Py_BuildValue((char *)"");
19457 }
19458 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19459 PyObject *resultobj;
19460 wxWindow *arg1 = (wxWindow *) NULL ;
19461 wxChildFocusEvent *result;
19462 PyObject * obj0 = 0 ;
19463 char *kwnames[] = {
19464 (char *) "win", NULL
19465 };
19466
19467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19468 if (obj0) {
19469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19470 if (SWIG_arg_fail(1)) SWIG_fail;
19471 }
19472 {
19473 PyThreadState* __tstate = wxPyBeginAllowThreads();
19474 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19475
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19487 PyObject *resultobj;
19488 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19489 wxWindow *result;
19490 PyObject * obj0 = 0 ;
19491 char *kwnames[] = {
19492 (char *) "self", NULL
19493 };
19494
19495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19497 if (SWIG_arg_fail(1)) SWIG_fail;
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19501
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 {
19506 resultobj = wxPyMake_wxObject(result, 0);
19507 }
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19515 PyObject *obj;
19516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19517 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19518 Py_INCREF(obj);
19519 return Py_BuildValue((char *)"");
19520 }
19521 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19522 PyObject *resultobj;
19523 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19524 bool arg2 = (bool) true ;
19525 int arg3 = (int) 0 ;
19526 wxActivateEvent *result;
19527 PyObject * obj0 = 0 ;
19528 PyObject * obj1 = 0 ;
19529 PyObject * obj2 = 0 ;
19530 char *kwnames[] = {
19531 (char *) "type",(char *) "active",(char *) "Id", NULL
19532 };
19533
19534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19535 if (obj0) {
19536 {
19537 arg1 = (wxEventType)(SWIG_As_int(obj0));
19538 if (SWIG_arg_fail(1)) SWIG_fail;
19539 }
19540 }
19541 if (obj1) {
19542 {
19543 arg2 = (bool)(SWIG_As_bool(obj1));
19544 if (SWIG_arg_fail(2)) SWIG_fail;
19545 }
19546 }
19547 if (obj2) {
19548 {
19549 arg3 = (int)(SWIG_As_int(obj2));
19550 if (SWIG_arg_fail(3)) SWIG_fail;
19551 }
19552 }
19553 {
19554 PyThreadState* __tstate = wxPyBeginAllowThreads();
19555 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19556
19557 wxPyEndAllowThreads(__tstate);
19558 if (PyErr_Occurred()) SWIG_fail;
19559 }
19560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj;
19569 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19570 bool result;
19571 PyObject * obj0 = 0 ;
19572 char *kwnames[] = {
19573 (char *) "self", NULL
19574 };
19575
19576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19578 if (SWIG_arg_fail(1)) SWIG_fail;
19579 {
19580 PyThreadState* __tstate = wxPyBeginAllowThreads();
19581 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19582
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 {
19587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19588 }
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19596 PyObject *obj;
19597 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19598 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19599 Py_INCREF(obj);
19600 return Py_BuildValue((char *)"");
19601 }
19602 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19603 PyObject *resultobj;
19604 int arg1 = (int) 0 ;
19605 wxInitDialogEvent *result;
19606 PyObject * obj0 = 0 ;
19607 char *kwnames[] = {
19608 (char *) "Id", NULL
19609 };
19610
19611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19612 if (obj0) {
19613 {
19614 arg1 = (int)(SWIG_As_int(obj0));
19615 if (SWIG_arg_fail(1)) SWIG_fail;
19616 }
19617 }
19618 {
19619 PyThreadState* __tstate = wxPyBeginAllowThreads();
19620 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19621
19622 wxPyEndAllowThreads(__tstate);
19623 if (PyErr_Occurred()) SWIG_fail;
19624 }
19625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19626 return resultobj;
19627 fail:
19628 return NULL;
19629 }
19630
19631
19632 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19633 PyObject *obj;
19634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19635 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19636 Py_INCREF(obj);
19637 return Py_BuildValue((char *)"");
19638 }
19639 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19640 PyObject *resultobj;
19641 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19642 int arg2 = (int) 0 ;
19643 wxMenu *arg3 = (wxMenu *) NULL ;
19644 wxMenuEvent *result;
19645 PyObject * obj0 = 0 ;
19646 PyObject * obj1 = 0 ;
19647 PyObject * obj2 = 0 ;
19648 char *kwnames[] = {
19649 (char *) "type",(char *) "winid",(char *) "menu", NULL
19650 };
19651
19652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19653 if (obj0) {
19654 {
19655 arg1 = (wxEventType)(SWIG_As_int(obj0));
19656 if (SWIG_arg_fail(1)) SWIG_fail;
19657 }
19658 }
19659 if (obj1) {
19660 {
19661 arg2 = (int)(SWIG_As_int(obj1));
19662 if (SWIG_arg_fail(2)) SWIG_fail;
19663 }
19664 }
19665 if (obj2) {
19666 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19667 if (SWIG_arg_fail(3)) SWIG_fail;
19668 }
19669 {
19670 PyThreadState* __tstate = wxPyBeginAllowThreads();
19671 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19672
19673 wxPyEndAllowThreads(__tstate);
19674 if (PyErr_Occurred()) SWIG_fail;
19675 }
19676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19677 return resultobj;
19678 fail:
19679 return NULL;
19680 }
19681
19682
19683 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19684 PyObject *resultobj;
19685 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19686 int result;
19687 PyObject * obj0 = 0 ;
19688 char *kwnames[] = {
19689 (char *) "self", NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19694 if (SWIG_arg_fail(1)) SWIG_fail;
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19698
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 {
19703 resultobj = SWIG_From_int((int)(result));
19704 }
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj;
19713 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19714 bool result;
19715 PyObject * obj0 = 0 ;
19716 char *kwnames[] = {
19717 (char *) "self", NULL
19718 };
19719
19720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19722 if (SWIG_arg_fail(1)) SWIG_fail;
19723 {
19724 PyThreadState* __tstate = wxPyBeginAllowThreads();
19725 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19726
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 {
19731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19732 }
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19740 PyObject *resultobj;
19741 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19742 wxMenu *result;
19743 PyObject * obj0 = 0 ;
19744 char *kwnames[] = {
19745 (char *) "self", NULL
19746 };
19747
19748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19750 if (SWIG_arg_fail(1)) SWIG_fail;
19751 {
19752 PyThreadState* __tstate = wxPyBeginAllowThreads();
19753 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19754
19755 wxPyEndAllowThreads(__tstate);
19756 if (PyErr_Occurred()) SWIG_fail;
19757 }
19758 {
19759 resultobj = wxPyMake_wxObject(result, 0);
19760 }
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19768 PyObject *obj;
19769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19770 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19771 Py_INCREF(obj);
19772 return Py_BuildValue((char *)"");
19773 }
19774 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj;
19776 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19777 int arg2 = (int) 0 ;
19778 wxCloseEvent *result;
19779 PyObject * obj0 = 0 ;
19780 PyObject * obj1 = 0 ;
19781 char *kwnames[] = {
19782 (char *) "type",(char *) "winid", NULL
19783 };
19784
19785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19786 if (obj0) {
19787 {
19788 arg1 = (wxEventType)(SWIG_As_int(obj0));
19789 if (SWIG_arg_fail(1)) SWIG_fail;
19790 }
19791 }
19792 if (obj1) {
19793 {
19794 arg2 = (int)(SWIG_As_int(obj1));
19795 if (SWIG_arg_fail(2)) SWIG_fail;
19796 }
19797 }
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19801
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19813 PyObject *resultobj;
19814 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19815 bool arg2 ;
19816 PyObject * obj0 = 0 ;
19817 PyObject * obj1 = 0 ;
19818 char *kwnames[] = {
19819 (char *) "self",(char *) "logOff", NULL
19820 };
19821
19822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19824 if (SWIG_arg_fail(1)) SWIG_fail;
19825 {
19826 arg2 = (bool)(SWIG_As_bool(obj1));
19827 if (SWIG_arg_fail(2)) SWIG_fail;
19828 }
19829 {
19830 PyThreadState* __tstate = wxPyBeginAllowThreads();
19831 (arg1)->SetLoggingOff(arg2);
19832
19833 wxPyEndAllowThreads(__tstate);
19834 if (PyErr_Occurred()) SWIG_fail;
19835 }
19836 Py_INCREF(Py_None); resultobj = Py_None;
19837 return resultobj;
19838 fail:
19839 return NULL;
19840 }
19841
19842
19843 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19844 PyObject *resultobj;
19845 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19846 bool result;
19847 PyObject * obj0 = 0 ;
19848 char *kwnames[] = {
19849 (char *) "self", NULL
19850 };
19851
19852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19854 if (SWIG_arg_fail(1)) SWIG_fail;
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19858
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 {
19863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19864 }
19865 return resultobj;
19866 fail:
19867 return NULL;
19868 }
19869
19870
19871 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj;
19873 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19874 bool arg2 = (bool) true ;
19875 PyObject * obj0 = 0 ;
19876 PyObject * obj1 = 0 ;
19877 char *kwnames[] = {
19878 (char *) "self",(char *) "veto", NULL
19879 };
19880
19881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19883 if (SWIG_arg_fail(1)) SWIG_fail;
19884 if (obj1) {
19885 {
19886 arg2 = (bool)(SWIG_As_bool(obj1));
19887 if (SWIG_arg_fail(2)) SWIG_fail;
19888 }
19889 }
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 (arg1)->Veto(arg2);
19893
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 Py_INCREF(Py_None); resultobj = Py_None;
19898 return resultobj;
19899 fail:
19900 return NULL;
19901 }
19902
19903
19904 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19905 PyObject *resultobj;
19906 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19907 bool arg2 ;
19908 PyObject * obj0 = 0 ;
19909 PyObject * obj1 = 0 ;
19910 char *kwnames[] = {
19911 (char *) "self",(char *) "canVeto", NULL
19912 };
19913
19914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19916 if (SWIG_arg_fail(1)) SWIG_fail;
19917 {
19918 arg2 = (bool)(SWIG_As_bool(obj1));
19919 if (SWIG_arg_fail(2)) SWIG_fail;
19920 }
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 (arg1)->SetCanVeto(arg2);
19924
19925 wxPyEndAllowThreads(__tstate);
19926 if (PyErr_Occurred()) SWIG_fail;
19927 }
19928 Py_INCREF(Py_None); resultobj = Py_None;
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj;
19937 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19938 bool result;
19939 PyObject * obj0 = 0 ;
19940 char *kwnames[] = {
19941 (char *) "self", NULL
19942 };
19943
19944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19946 if (SWIG_arg_fail(1)) SWIG_fail;
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19950
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 {
19955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19956 }
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj;
19965 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19966 bool result;
19967 PyObject * obj0 = 0 ;
19968 char *kwnames[] = {
19969 (char *) "self", NULL
19970 };
19971
19972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19974 if (SWIG_arg_fail(1)) SWIG_fail;
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19978
19979 wxPyEndAllowThreads(__tstate);
19980 if (PyErr_Occurred()) SWIG_fail;
19981 }
19982 {
19983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19984 }
19985 return resultobj;
19986 fail:
19987 return NULL;
19988 }
19989
19990
19991 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19992 PyObject *obj;
19993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19994 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19995 Py_INCREF(obj);
19996 return Py_BuildValue((char *)"");
19997 }
19998 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj;
20000 int arg1 = (int) 0 ;
20001 bool arg2 = (bool) false ;
20002 wxShowEvent *result;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 char *kwnames[] = {
20006 (char *) "winid",(char *) "show", NULL
20007 };
20008
20009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20010 if (obj0) {
20011 {
20012 arg1 = (int)(SWIG_As_int(obj0));
20013 if (SWIG_arg_fail(1)) SWIG_fail;
20014 }
20015 }
20016 if (obj1) {
20017 {
20018 arg2 = (bool)(SWIG_As_bool(obj1));
20019 if (SWIG_arg_fail(2)) SWIG_fail;
20020 }
20021 }
20022 {
20023 PyThreadState* __tstate = wxPyBeginAllowThreads();
20024 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20025
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj;
20038 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20039 bool arg2 ;
20040 PyObject * obj0 = 0 ;
20041 PyObject * obj1 = 0 ;
20042 char *kwnames[] = {
20043 (char *) "self",(char *) "show", NULL
20044 };
20045
20046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20048 if (SWIG_arg_fail(1)) SWIG_fail;
20049 {
20050 arg2 = (bool)(SWIG_As_bool(obj1));
20051 if (SWIG_arg_fail(2)) SWIG_fail;
20052 }
20053 {
20054 PyThreadState* __tstate = wxPyBeginAllowThreads();
20055 (arg1)->SetShow(arg2);
20056
20057 wxPyEndAllowThreads(__tstate);
20058 if (PyErr_Occurred()) SWIG_fail;
20059 }
20060 Py_INCREF(Py_None); resultobj = Py_None;
20061 return resultobj;
20062 fail:
20063 return NULL;
20064 }
20065
20066
20067 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20070 bool result;
20071 PyObject * obj0 = 0 ;
20072 char *kwnames[] = {
20073 (char *) "self", NULL
20074 };
20075
20076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20078 if (SWIG_arg_fail(1)) SWIG_fail;
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 {
20087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20088 }
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20096 PyObject *obj;
20097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20098 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20099 Py_INCREF(obj);
20100 return Py_BuildValue((char *)"");
20101 }
20102 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj;
20104 int arg1 = (int) 0 ;
20105 bool arg2 = (bool) true ;
20106 wxIconizeEvent *result;
20107 PyObject * obj0 = 0 ;
20108 PyObject * obj1 = 0 ;
20109 char *kwnames[] = {
20110 (char *) "id",(char *) "iconized", NULL
20111 };
20112
20113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20114 if (obj0) {
20115 {
20116 arg1 = (int)(SWIG_As_int(obj0));
20117 if (SWIG_arg_fail(1)) SWIG_fail;
20118 }
20119 }
20120 if (obj1) {
20121 {
20122 arg2 = (bool)(SWIG_As_bool(obj1));
20123 if (SWIG_arg_fail(2)) SWIG_fail;
20124 }
20125 }
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20129
20130 wxPyEndAllowThreads(__tstate);
20131 if (PyErr_Occurred()) SWIG_fail;
20132 }
20133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20134 return resultobj;
20135 fail:
20136 return NULL;
20137 }
20138
20139
20140 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20141 PyObject *resultobj;
20142 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20143 bool result;
20144 PyObject * obj0 = 0 ;
20145 char *kwnames[] = {
20146 (char *) "self", NULL
20147 };
20148
20149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20151 if (SWIG_arg_fail(1)) SWIG_fail;
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 result = (bool)(arg1)->Iconized();
20155
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 {
20160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20161 }
20162 return resultobj;
20163 fail:
20164 return NULL;
20165 }
20166
20167
20168 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20169 PyObject *obj;
20170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20171 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20172 Py_INCREF(obj);
20173 return Py_BuildValue((char *)"");
20174 }
20175 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj;
20177 int arg1 = (int) 0 ;
20178 wxMaximizeEvent *result;
20179 PyObject * obj0 = 0 ;
20180 char *kwnames[] = {
20181 (char *) "id", NULL
20182 };
20183
20184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20185 if (obj0) {
20186 {
20187 arg1 = (int)(SWIG_As_int(obj0));
20188 if (SWIG_arg_fail(1)) SWIG_fail;
20189 }
20190 }
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20194
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20206 PyObject *obj;
20207 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20208 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20209 Py_INCREF(obj);
20210 return Py_BuildValue((char *)"");
20211 }
20212 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj;
20214 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20215 wxPoint result;
20216 PyObject * obj0 = 0 ;
20217 char *kwnames[] = {
20218 (char *) "self", NULL
20219 };
20220
20221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20223 if (SWIG_arg_fail(1)) SWIG_fail;
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (arg1)->GetPosition();
20227
20228 wxPyEndAllowThreads(__tstate);
20229 if (PyErr_Occurred()) SWIG_fail;
20230 }
20231 {
20232 wxPoint * resultptr;
20233 resultptr = new wxPoint((wxPoint &)(result));
20234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20235 }
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20243 PyObject *resultobj;
20244 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20245 int result;
20246 PyObject * obj0 = 0 ;
20247 char *kwnames[] = {
20248 (char *) "self", NULL
20249 };
20250
20251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (int)(arg1)->GetNumberOfFiles();
20257
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 {
20262 resultobj = SWIG_From_int((int)(result));
20263 }
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20271 PyObject *resultobj;
20272 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20273 PyObject *result;
20274 PyObject * obj0 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 resultobj = result;
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20297 PyObject *obj;
20298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20299 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20300 Py_INCREF(obj);
20301 return Py_BuildValue((char *)"");
20302 }
20303 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj;
20305 int arg1 = (int) 0 ;
20306 wxUpdateUIEvent *result;
20307 PyObject * obj0 = 0 ;
20308 char *kwnames[] = {
20309 (char *) "commandId", NULL
20310 };
20311
20312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20313 if (obj0) {
20314 {
20315 arg1 = (int)(SWIG_As_int(obj0));
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 }
20318 }
20319 {
20320 PyThreadState* __tstate = wxPyBeginAllowThreads();
20321 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20322
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20334 PyObject *resultobj;
20335 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20336 bool result;
20337 PyObject * obj0 = 0 ;
20338 char *kwnames[] = {
20339 (char *) "self", NULL
20340 };
20341
20342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20344 if (SWIG_arg_fail(1)) SWIG_fail;
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20348
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 {
20353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20354 }
20355 return resultobj;
20356 fail:
20357 return NULL;
20358 }
20359
20360
20361 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20362 PyObject *resultobj;
20363 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20364 bool result;
20365 PyObject * obj0 = 0 ;
20366 char *kwnames[] = {
20367 (char *) "self", NULL
20368 };
20369
20370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20372 if (SWIG_arg_fail(1)) SWIG_fail;
20373 {
20374 PyThreadState* __tstate = wxPyBeginAllowThreads();
20375 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20376
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 {
20381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20390 PyObject *resultobj;
20391 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20392 wxString result;
20393 PyObject * obj0 = 0 ;
20394 char *kwnames[] = {
20395 (char *) "self", NULL
20396 };
20397
20398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20400 if (SWIG_arg_fail(1)) SWIG_fail;
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20404
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 {
20409 #if wxUSE_UNICODE
20410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20411 #else
20412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20413 #endif
20414 }
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20422 PyObject *resultobj;
20423 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20424 bool result;
20425 PyObject * obj0 = 0 ;
20426 char *kwnames[] = {
20427 (char *) "self", NULL
20428 };
20429
20430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20432 if (SWIG_arg_fail(1)) SWIG_fail;
20433 {
20434 PyThreadState* __tstate = wxPyBeginAllowThreads();
20435 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20436
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 {
20441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20442 }
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20450 PyObject *resultobj;
20451 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20452 bool result;
20453 PyObject * obj0 = 0 ;
20454 char *kwnames[] = {
20455 (char *) "self", NULL
20456 };
20457
20458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20460 if (SWIG_arg_fail(1)) SWIG_fail;
20461 {
20462 PyThreadState* __tstate = wxPyBeginAllowThreads();
20463 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20464
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 {
20469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20470 }
20471 return resultobj;
20472 fail:
20473 return NULL;
20474 }
20475
20476
20477 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20478 PyObject *resultobj;
20479 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20480 bool result;
20481 PyObject * obj0 = 0 ;
20482 char *kwnames[] = {
20483 (char *) "self", NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20488 if (SWIG_arg_fail(1)) SWIG_fail;
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20492
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20506 PyObject *resultobj;
20507 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20508 bool arg2 ;
20509 PyObject * obj0 = 0 ;
20510 PyObject * obj1 = 0 ;
20511 char *kwnames[] = {
20512 (char *) "self",(char *) "check", NULL
20513 };
20514
20515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20517 if (SWIG_arg_fail(1)) SWIG_fail;
20518 {
20519 arg2 = (bool)(SWIG_As_bool(obj1));
20520 if (SWIG_arg_fail(2)) SWIG_fail;
20521 }
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 (arg1)->Check(arg2);
20525
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 Py_INCREF(Py_None); resultobj = Py_None;
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20537 PyObject *resultobj;
20538 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20539 bool arg2 ;
20540 PyObject * obj0 = 0 ;
20541 PyObject * obj1 = 0 ;
20542 char *kwnames[] = {
20543 (char *) "self",(char *) "enable", NULL
20544 };
20545
20546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20548 if (SWIG_arg_fail(1)) SWIG_fail;
20549 {
20550 arg2 = (bool)(SWIG_As_bool(obj1));
20551 if (SWIG_arg_fail(2)) SWIG_fail;
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 (arg1)->Enable(arg2);
20556
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 Py_INCREF(Py_None); resultobj = Py_None;
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj;
20569 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20570 wxString *arg2 = 0 ;
20571 bool temp2 = false ;
20572 PyObject * obj0 = 0 ;
20573 PyObject * obj1 = 0 ;
20574 char *kwnames[] = {
20575 (char *) "self",(char *) "text", NULL
20576 };
20577
20578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20580 if (SWIG_arg_fail(1)) SWIG_fail;
20581 {
20582 arg2 = wxString_in_helper(obj1);
20583 if (arg2 == NULL) SWIG_fail;
20584 temp2 = true;
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 (arg1)->SetText((wxString const &)*arg2);
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 Py_INCREF(Py_None); resultobj = Py_None;
20594 {
20595 if (temp2)
20596 delete arg2;
20597 }
20598 return resultobj;
20599 fail:
20600 {
20601 if (temp2)
20602 delete arg2;
20603 }
20604 return NULL;
20605 }
20606
20607
20608 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj;
20610 long arg1 ;
20611 PyObject * obj0 = 0 ;
20612 char *kwnames[] = {
20613 (char *) "updateInterval", NULL
20614 };
20615
20616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20617 {
20618 arg1 = (long)(SWIG_As_long(obj0));
20619 if (SWIG_arg_fail(1)) SWIG_fail;
20620 }
20621 {
20622 PyThreadState* __tstate = wxPyBeginAllowThreads();
20623 wxUpdateUIEvent::SetUpdateInterval(arg1);
20624
20625 wxPyEndAllowThreads(__tstate);
20626 if (PyErr_Occurred()) SWIG_fail;
20627 }
20628 Py_INCREF(Py_None); resultobj = Py_None;
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj;
20637 long result;
20638 char *kwnames[] = {
20639 NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20643 {
20644 PyThreadState* __tstate = wxPyBeginAllowThreads();
20645 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20646
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 {
20651 resultobj = SWIG_From_long((long)(result));
20652 }
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20660 PyObject *resultobj;
20661 wxWindow *arg1 = (wxWindow *) 0 ;
20662 bool result;
20663 PyObject * obj0 = 0 ;
20664 char *kwnames[] = {
20665 (char *) "win", NULL
20666 };
20667
20668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20670 if (SWIG_arg_fail(1)) SWIG_fail;
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20674
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 {
20679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20680 }
20681 return resultobj;
20682 fail:
20683 return NULL;
20684 }
20685
20686
20687 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20688 PyObject *resultobj;
20689 char *kwnames[] = {
20690 NULL
20691 };
20692
20693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 wxUpdateUIEvent::ResetUpdateTime();
20697
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 Py_INCREF(Py_None); resultobj = Py_None;
20702 return resultobj;
20703 fail:
20704 return NULL;
20705 }
20706
20707
20708 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20709 PyObject *resultobj;
20710 wxUpdateUIMode arg1 ;
20711 PyObject * obj0 = 0 ;
20712 char *kwnames[] = {
20713 (char *) "mode", NULL
20714 };
20715
20716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20717 {
20718 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20719 if (SWIG_arg_fail(1)) SWIG_fail;
20720 }
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20724
20725 wxPyEndAllowThreads(__tstate);
20726 if (PyErr_Occurred()) SWIG_fail;
20727 }
20728 Py_INCREF(Py_None); resultobj = Py_None;
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxUpdateUIMode result;
20738 char *kwnames[] = {
20739 NULL
20740 };
20741
20742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20746
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 resultobj = SWIG_From_int((result));
20751 return resultobj;
20752 fail:
20753 return NULL;
20754 }
20755
20756
20757 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20758 PyObject *obj;
20759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20760 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20761 Py_INCREF(obj);
20762 return Py_BuildValue((char *)"");
20763 }
20764 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20765 PyObject *resultobj;
20766 wxSysColourChangedEvent *result;
20767 char *kwnames[] = {
20768 NULL
20769 };
20770
20771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20772 {
20773 PyThreadState* __tstate = wxPyBeginAllowThreads();
20774 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20775
20776 wxPyEndAllowThreads(__tstate);
20777 if (PyErr_Occurred()) SWIG_fail;
20778 }
20779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20780 return resultobj;
20781 fail:
20782 return NULL;
20783 }
20784
20785
20786 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20787 PyObject *obj;
20788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20789 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20790 Py_INCREF(obj);
20791 return Py_BuildValue((char *)"");
20792 }
20793 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20794 PyObject *resultobj;
20795 int arg1 = (int) 0 ;
20796 wxWindow *arg2 = (wxWindow *) NULL ;
20797 wxMouseCaptureChangedEvent *result;
20798 PyObject * obj0 = 0 ;
20799 PyObject * obj1 = 0 ;
20800 char *kwnames[] = {
20801 (char *) "winid",(char *) "gainedCapture", NULL
20802 };
20803
20804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20805 if (obj0) {
20806 {
20807 arg1 = (int)(SWIG_As_int(obj0));
20808 if (SWIG_arg_fail(1)) SWIG_fail;
20809 }
20810 }
20811 if (obj1) {
20812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20813 if (SWIG_arg_fail(2)) SWIG_fail;
20814 }
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20818
20819 wxPyEndAllowThreads(__tstate);
20820 if (PyErr_Occurred()) SWIG_fail;
20821 }
20822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20823 return resultobj;
20824 fail:
20825 return NULL;
20826 }
20827
20828
20829 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20830 PyObject *resultobj;
20831 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20832 wxWindow *result;
20833 PyObject * obj0 = 0 ;
20834 char *kwnames[] = {
20835 (char *) "self", NULL
20836 };
20837
20838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20840 if (SWIG_arg_fail(1)) SWIG_fail;
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20844
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 {
20849 resultobj = wxPyMake_wxObject(result, 0);
20850 }
20851 return resultobj;
20852 fail:
20853 return NULL;
20854 }
20855
20856
20857 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20858 PyObject *obj;
20859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20860 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20861 Py_INCREF(obj);
20862 return Py_BuildValue((char *)"");
20863 }
20864 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20865 PyObject *resultobj;
20866 wxDisplayChangedEvent *result;
20867 char *kwnames[] = {
20868 NULL
20869 };
20870
20871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20872 {
20873 PyThreadState* __tstate = wxPyBeginAllowThreads();
20874 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20875
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20887 PyObject *obj;
20888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20889 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20890 Py_INCREF(obj);
20891 return Py_BuildValue((char *)"");
20892 }
20893 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20894 PyObject *resultobj;
20895 int arg1 = (int) 0 ;
20896 wxPaletteChangedEvent *result;
20897 PyObject * obj0 = 0 ;
20898 char *kwnames[] = {
20899 (char *) "id", NULL
20900 };
20901
20902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20903 if (obj0) {
20904 {
20905 arg1 = (int)(SWIG_As_int(obj0));
20906 if (SWIG_arg_fail(1)) SWIG_fail;
20907 }
20908 }
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20917 return resultobj;
20918 fail:
20919 return NULL;
20920 }
20921
20922
20923 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20924 PyObject *resultobj;
20925 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20926 wxWindow *arg2 = (wxWindow *) 0 ;
20927 PyObject * obj0 = 0 ;
20928 PyObject * obj1 = 0 ;
20929 char *kwnames[] = {
20930 (char *) "self",(char *) "win", NULL
20931 };
20932
20933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20935 if (SWIG_arg_fail(1)) SWIG_fail;
20936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20937 if (SWIG_arg_fail(2)) SWIG_fail;
20938 {
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 (arg1)->SetChangedWindow(arg2);
20941
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 Py_INCREF(Py_None); resultobj = Py_None;
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20953 PyObject *resultobj;
20954 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20955 wxWindow *result;
20956 PyObject * obj0 = 0 ;
20957 char *kwnames[] = {
20958 (char *) "self", NULL
20959 };
20960
20961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20963 if (SWIG_arg_fail(1)) SWIG_fail;
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (wxWindow *)(arg1)->GetChangedWindow();
20967
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 {
20972 resultobj = wxPyMake_wxObject(result, 0);
20973 }
20974 return resultobj;
20975 fail:
20976 return NULL;
20977 }
20978
20979
20980 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20981 PyObject *obj;
20982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20983 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20984 Py_INCREF(obj);
20985 return Py_BuildValue((char *)"");
20986 }
20987 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20988 PyObject *resultobj;
20989 int arg1 = (int) 0 ;
20990 wxQueryNewPaletteEvent *result;
20991 PyObject * obj0 = 0 ;
20992 char *kwnames[] = {
20993 (char *) "winid", NULL
20994 };
20995
20996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20997 if (obj0) {
20998 {
20999 arg1 = (int)(SWIG_As_int(obj0));
21000 if (SWIG_arg_fail(1)) SWIG_fail;
21001 }
21002 }
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21006
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj;
21019 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21020 bool arg2 ;
21021 PyObject * obj0 = 0 ;
21022 PyObject * obj1 = 0 ;
21023 char *kwnames[] = {
21024 (char *) "self",(char *) "realized", NULL
21025 };
21026
21027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21029 if (SWIG_arg_fail(1)) SWIG_fail;
21030 {
21031 arg2 = (bool)(SWIG_As_bool(obj1));
21032 if (SWIG_arg_fail(2)) SWIG_fail;
21033 }
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 (arg1)->SetPaletteRealized(arg2);
21037
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 Py_INCREF(Py_None); resultobj = Py_None;
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21049 PyObject *resultobj;
21050 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21051 bool result;
21052 PyObject * obj0 = 0 ;
21053 char *kwnames[] = {
21054 (char *) "self", NULL
21055 };
21056
21057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21059 if (SWIG_arg_fail(1)) SWIG_fail;
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21063
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21077 PyObject *obj;
21078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21079 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21080 Py_INCREF(obj);
21081 return Py_BuildValue((char *)"");
21082 }
21083 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21084 PyObject *resultobj;
21085 wxNavigationKeyEvent *result;
21086 char *kwnames[] = {
21087 NULL
21088 };
21089
21090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21091 {
21092 PyThreadState* __tstate = wxPyBeginAllowThreads();
21093 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21094
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21099 return resultobj;
21100 fail:
21101 return NULL;
21102 }
21103
21104
21105 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj;
21107 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21108 bool result;
21109 PyObject * obj0 = 0 ;
21110 char *kwnames[] = {
21111 (char *) "self", NULL
21112 };
21113
21114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21116 if (SWIG_arg_fail(1)) SWIG_fail;
21117 {
21118 PyThreadState* __tstate = wxPyBeginAllowThreads();
21119 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21120
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 {
21125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21126 }
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21134 PyObject *resultobj;
21135 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21136 bool arg2 ;
21137 PyObject * obj0 = 0 ;
21138 PyObject * obj1 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self",(char *) "forward", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 arg2 = (bool)(SWIG_As_bool(obj1));
21148 if (SWIG_arg_fail(2)) SWIG_fail;
21149 }
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 (arg1)->SetDirection(arg2);
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 Py_INCREF(Py_None); resultobj = Py_None;
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj;
21166 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21167 bool result;
21168 PyObject * obj0 = 0 ;
21169 char *kwnames[] = {
21170 (char *) "self", NULL
21171 };
21172
21173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21175 if (SWIG_arg_fail(1)) SWIG_fail;
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 {
21184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21185 }
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21193 PyObject *resultobj;
21194 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21195 bool arg2 ;
21196 PyObject * obj0 = 0 ;
21197 PyObject * obj1 = 0 ;
21198 char *kwnames[] = {
21199 (char *) "self",(char *) "ischange", NULL
21200 };
21201
21202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21204 if (SWIG_arg_fail(1)) SWIG_fail;
21205 {
21206 arg2 = (bool)(SWIG_As_bool(obj1));
21207 if (SWIG_arg_fail(2)) SWIG_fail;
21208 }
21209 {
21210 PyThreadState* __tstate = wxPyBeginAllowThreads();
21211 (arg1)->SetWindowChange(arg2);
21212
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 Py_INCREF(Py_None); resultobj = Py_None;
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21224 PyObject *resultobj;
21225 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21226 bool result;
21227 PyObject * obj0 = 0 ;
21228 char *kwnames[] = {
21229 (char *) "self", NULL
21230 };
21231
21232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21234 if (SWIG_arg_fail(1)) SWIG_fail;
21235 {
21236 PyThreadState* __tstate = wxPyBeginAllowThreads();
21237 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21238
21239 wxPyEndAllowThreads(__tstate);
21240 if (PyErr_Occurred()) SWIG_fail;
21241 }
21242 {
21243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21244 }
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21252 PyObject *resultobj;
21253 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21254 bool arg2 ;
21255 PyObject * obj0 = 0 ;
21256 PyObject * obj1 = 0 ;
21257 char *kwnames[] = {
21258 (char *) "self",(char *) "bIs", NULL
21259 };
21260
21261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21263 if (SWIG_arg_fail(1)) SWIG_fail;
21264 {
21265 arg2 = (bool)(SWIG_As_bool(obj1));
21266 if (SWIG_arg_fail(2)) SWIG_fail;
21267 }
21268 {
21269 PyThreadState* __tstate = wxPyBeginAllowThreads();
21270 (arg1)->SetFromTab(arg2);
21271
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 Py_INCREF(Py_None); resultobj = Py_None;
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21283 PyObject *resultobj;
21284 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21285 long arg2 ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 char *kwnames[] = {
21289 (char *) "self",(char *) "flags", NULL
21290 };
21291
21292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21294 if (SWIG_arg_fail(1)) SWIG_fail;
21295 {
21296 arg2 = (long)(SWIG_As_long(obj1));
21297 if (SWIG_arg_fail(2)) SWIG_fail;
21298 }
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 (arg1)->SetFlags(arg2);
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 Py_INCREF(Py_None); resultobj = Py_None;
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj;
21315 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21316 wxWindow *result;
21317 PyObject * obj0 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 {
21333 resultobj = wxPyMake_wxObject(result, 0);
21334 }
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj;
21343 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21344 wxWindow *arg2 = (wxWindow *) 0 ;
21345 PyObject * obj0 = 0 ;
21346 PyObject * obj1 = 0 ;
21347 char *kwnames[] = {
21348 (char *) "self",(char *) "win", NULL
21349 };
21350
21351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21353 if (SWIG_arg_fail(1)) SWIG_fail;
21354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21355 if (SWIG_arg_fail(2)) SWIG_fail;
21356 {
21357 PyThreadState* __tstate = wxPyBeginAllowThreads();
21358 (arg1)->SetCurrentFocus(arg2);
21359
21360 wxPyEndAllowThreads(__tstate);
21361 if (PyErr_Occurred()) SWIG_fail;
21362 }
21363 Py_INCREF(Py_None); resultobj = Py_None;
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21371 PyObject *obj;
21372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21373 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21374 Py_INCREF(obj);
21375 return Py_BuildValue((char *)"");
21376 }
21377 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21378 PyObject *resultobj;
21379 wxWindow *arg1 = (wxWindow *) NULL ;
21380 wxWindowCreateEvent *result;
21381 PyObject * obj0 = 0 ;
21382 char *kwnames[] = {
21383 (char *) "win", NULL
21384 };
21385
21386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21387 if (obj0) {
21388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21389 if (SWIG_arg_fail(1)) SWIG_fail;
21390 }
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21394
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21406 PyObject *resultobj;
21407 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21408 wxWindow *result;
21409 PyObject * obj0 = 0 ;
21410 char *kwnames[] = {
21411 (char *) "self", NULL
21412 };
21413
21414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21416 if (SWIG_arg_fail(1)) SWIG_fail;
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21420
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 {
21425 resultobj = wxPyMake_wxObject(result, 0);
21426 }
21427 return resultobj;
21428 fail:
21429 return NULL;
21430 }
21431
21432
21433 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21434 PyObject *obj;
21435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21436 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21437 Py_INCREF(obj);
21438 return Py_BuildValue((char *)"");
21439 }
21440 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21441 PyObject *resultobj;
21442 wxWindow *arg1 = (wxWindow *) NULL ;
21443 wxWindowDestroyEvent *result;
21444 PyObject * obj0 = 0 ;
21445 char *kwnames[] = {
21446 (char *) "win", NULL
21447 };
21448
21449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21450 if (obj0) {
21451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21452 if (SWIG_arg_fail(1)) SWIG_fail;
21453 }
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21457
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21469 PyObject *resultobj;
21470 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21471 wxWindow *result;
21472 PyObject * obj0 = 0 ;
21473 char *kwnames[] = {
21474 (char *) "self", NULL
21475 };
21476
21477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21479 if (SWIG_arg_fail(1)) SWIG_fail;
21480 {
21481 PyThreadState* __tstate = wxPyBeginAllowThreads();
21482 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21483
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 {
21488 resultobj = wxPyMake_wxObject(result, 0);
21489 }
21490 return resultobj;
21491 fail:
21492 return NULL;
21493 }
21494
21495
21496 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21497 PyObject *obj;
21498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21499 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21500 Py_INCREF(obj);
21501 return Py_BuildValue((char *)"");
21502 }
21503 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21504 PyObject *resultobj;
21505 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21506 int arg2 = (int) 0 ;
21507 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21508 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21509 wxContextMenuEvent *result;
21510 wxPoint temp3 ;
21511 PyObject * obj0 = 0 ;
21512 PyObject * obj1 = 0 ;
21513 PyObject * obj2 = 0 ;
21514 char *kwnames[] = {
21515 (char *) "type",(char *) "winid",(char *) "pt", NULL
21516 };
21517
21518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21519 if (obj0) {
21520 {
21521 arg1 = (wxEventType)(SWIG_As_int(obj0));
21522 if (SWIG_arg_fail(1)) SWIG_fail;
21523 }
21524 }
21525 if (obj1) {
21526 {
21527 arg2 = (int)(SWIG_As_int(obj1));
21528 if (SWIG_arg_fail(2)) SWIG_fail;
21529 }
21530 }
21531 if (obj2) {
21532 {
21533 arg3 = &temp3;
21534 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21535 }
21536 }
21537 {
21538 PyThreadState* __tstate = wxPyBeginAllowThreads();
21539 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21540
21541 wxPyEndAllowThreads(__tstate);
21542 if (PyErr_Occurred()) SWIG_fail;
21543 }
21544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21545 return resultobj;
21546 fail:
21547 return NULL;
21548 }
21549
21550
21551 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21552 PyObject *resultobj;
21553 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21554 wxPoint *result;
21555 PyObject * obj0 = 0 ;
21556 char *kwnames[] = {
21557 (char *) "self", NULL
21558 };
21559
21560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21562 if (SWIG_arg_fail(1)) SWIG_fail;
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 {
21566 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21567 result = (wxPoint *) &_result_ref;
21568 }
21569
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21581 PyObject *resultobj;
21582 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21583 wxPoint *arg2 = 0 ;
21584 wxPoint temp2 ;
21585 PyObject * obj0 = 0 ;
21586 PyObject * obj1 = 0 ;
21587 char *kwnames[] = {
21588 (char *) "self",(char *) "pos", NULL
21589 };
21590
21591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21593 if (SWIG_arg_fail(1)) SWIG_fail;
21594 {
21595 arg2 = &temp2;
21596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21597 }
21598 {
21599 PyThreadState* __tstate = wxPyBeginAllowThreads();
21600 (arg1)->SetPosition((wxPoint const &)*arg2);
21601
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 Py_INCREF(Py_None); resultobj = Py_None;
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21613 PyObject *obj;
21614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21615 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21616 Py_INCREF(obj);
21617 return Py_BuildValue((char *)"");
21618 }
21619 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxIdleEvent *result;
21622 char *kwnames[] = {
21623 NULL
21624 };
21625
21626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21627 {
21628 PyThreadState* __tstate = wxPyBeginAllowThreads();
21629 result = (wxIdleEvent *)new wxIdleEvent();
21630
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj;
21643 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21644 bool arg2 = (bool) true ;
21645 PyObject * obj0 = 0 ;
21646 PyObject * obj1 = 0 ;
21647 char *kwnames[] = {
21648 (char *) "self",(char *) "needMore", NULL
21649 };
21650
21651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21653 if (SWIG_arg_fail(1)) SWIG_fail;
21654 if (obj1) {
21655 {
21656 arg2 = (bool)(SWIG_As_bool(obj1));
21657 if (SWIG_arg_fail(2)) SWIG_fail;
21658 }
21659 }
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 (arg1)->RequestMore(arg2);
21663
21664 wxPyEndAllowThreads(__tstate);
21665 if (PyErr_Occurred()) SWIG_fail;
21666 }
21667 Py_INCREF(Py_None); resultobj = Py_None;
21668 return resultobj;
21669 fail:
21670 return NULL;
21671 }
21672
21673
21674 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21675 PyObject *resultobj;
21676 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21677 bool result;
21678 PyObject * obj0 = 0 ;
21679 char *kwnames[] = {
21680 (char *) "self", NULL
21681 };
21682
21683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21685 if (SWIG_arg_fail(1)) SWIG_fail;
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21689
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 {
21694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21695 }
21696 return resultobj;
21697 fail:
21698 return NULL;
21699 }
21700
21701
21702 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21703 PyObject *resultobj;
21704 wxIdleMode arg1 ;
21705 PyObject * obj0 = 0 ;
21706 char *kwnames[] = {
21707 (char *) "mode", NULL
21708 };
21709
21710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21711 {
21712 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21713 if (SWIG_arg_fail(1)) SWIG_fail;
21714 }
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 wxIdleEvent::SetMode((wxIdleMode )arg1);
21718
21719 wxPyEndAllowThreads(__tstate);
21720 if (PyErr_Occurred()) SWIG_fail;
21721 }
21722 Py_INCREF(Py_None); resultobj = Py_None;
21723 return resultobj;
21724 fail:
21725 return NULL;
21726 }
21727
21728
21729 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21730 PyObject *resultobj;
21731 wxIdleMode result;
21732 char *kwnames[] = {
21733 NULL
21734 };
21735
21736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21737 {
21738 PyThreadState* __tstate = wxPyBeginAllowThreads();
21739 result = (wxIdleMode)wxIdleEvent::GetMode();
21740
21741 wxPyEndAllowThreads(__tstate);
21742 if (PyErr_Occurred()) SWIG_fail;
21743 }
21744 resultobj = SWIG_From_int((result));
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj;
21753 wxWindow *arg1 = (wxWindow *) 0 ;
21754 bool result;
21755 PyObject * obj0 = 0 ;
21756 char *kwnames[] = {
21757 (char *) "win", NULL
21758 };
21759
21760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21762 if (SWIG_arg_fail(1)) SWIG_fail;
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (bool)wxIdleEvent::CanSend(arg1);
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 {
21771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21772 }
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21780 PyObject *obj;
21781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21782 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21783 Py_INCREF(obj);
21784 return Py_BuildValue((char *)"");
21785 }
21786 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj;
21788 int arg1 = (int) 0 ;
21789 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21790 wxPyEvent *result;
21791 PyObject * obj0 = 0 ;
21792 PyObject * obj1 = 0 ;
21793 char *kwnames[] = {
21794 (char *) "winid",(char *) "commandType", NULL
21795 };
21796
21797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21798 if (obj0) {
21799 {
21800 arg1 = (int)(SWIG_As_int(obj0));
21801 if (SWIG_arg_fail(1)) SWIG_fail;
21802 }
21803 }
21804 if (obj1) {
21805 {
21806 arg2 = (wxEventType)(SWIG_As_int(obj1));
21807 if (SWIG_arg_fail(2)) SWIG_fail;
21808 }
21809 }
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21813
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21818 return resultobj;
21819 fail:
21820 return NULL;
21821 }
21822
21823
21824 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21825 PyObject *resultobj;
21826 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21827 PyObject * obj0 = 0 ;
21828 char *kwnames[] = {
21829 (char *) "self", NULL
21830 };
21831
21832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21834 if (SWIG_arg_fail(1)) SWIG_fail;
21835 {
21836 PyThreadState* __tstate = wxPyBeginAllowThreads();
21837 delete arg1;
21838
21839 wxPyEndAllowThreads(__tstate);
21840 if (PyErr_Occurred()) SWIG_fail;
21841 }
21842 Py_INCREF(Py_None); resultobj = Py_None;
21843 return resultobj;
21844 fail:
21845 return NULL;
21846 }
21847
21848
21849 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj;
21851 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21852 PyObject *arg2 = (PyObject *) 0 ;
21853 PyObject * obj0 = 0 ;
21854 PyObject * obj1 = 0 ;
21855 char *kwnames[] = {
21856 (char *) "self",(char *) "self", NULL
21857 };
21858
21859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21861 if (SWIG_arg_fail(1)) SWIG_fail;
21862 arg2 = obj1;
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 (arg1)->SetSelf(arg2);
21866
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 Py_INCREF(Py_None); resultobj = Py_None;
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21878 PyObject *resultobj;
21879 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21880 PyObject *result;
21881 PyObject * obj0 = 0 ;
21882 char *kwnames[] = {
21883 (char *) "self", NULL
21884 };
21885
21886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21888 if (SWIG_arg_fail(1)) SWIG_fail;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (PyObject *)(arg1)->GetSelf();
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 resultobj = result;
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21904 PyObject *obj;
21905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21906 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21907 Py_INCREF(obj);
21908 return Py_BuildValue((char *)"");
21909 }
21910 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21911 PyObject *resultobj;
21912 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21913 int arg2 = (int) 0 ;
21914 wxPyCommandEvent *result;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 char *kwnames[] = {
21918 (char *) "commandType",(char *) "id", NULL
21919 };
21920
21921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21922 if (obj0) {
21923 {
21924 arg1 = (wxEventType)(SWIG_As_int(obj0));
21925 if (SWIG_arg_fail(1)) SWIG_fail;
21926 }
21927 }
21928 if (obj1) {
21929 {
21930 arg2 = (int)(SWIG_As_int(obj1));
21931 if (SWIG_arg_fail(2)) SWIG_fail;
21932 }
21933 }
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21937
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21942 return resultobj;
21943 fail:
21944 return NULL;
21945 }
21946
21947
21948 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj;
21950 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21951 PyObject * obj0 = 0 ;
21952 char *kwnames[] = {
21953 (char *) "self", NULL
21954 };
21955
21956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21958 if (SWIG_arg_fail(1)) SWIG_fail;
21959 {
21960 PyThreadState* __tstate = wxPyBeginAllowThreads();
21961 delete arg1;
21962
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 Py_INCREF(Py_None); resultobj = Py_None;
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21976 PyObject *arg2 = (PyObject *) 0 ;
21977 PyObject * obj0 = 0 ;
21978 PyObject * obj1 = 0 ;
21979 char *kwnames[] = {
21980 (char *) "self",(char *) "self", NULL
21981 };
21982
21983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21985 if (SWIG_arg_fail(1)) SWIG_fail;
21986 arg2 = obj1;
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 (arg1)->SetSelf(arg2);
21990
21991 wxPyEndAllowThreads(__tstate);
21992 if (PyErr_Occurred()) SWIG_fail;
21993 }
21994 Py_INCREF(Py_None); resultobj = Py_None;
21995 return resultobj;
21996 fail:
21997 return NULL;
21998 }
21999
22000
22001 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22002 PyObject *resultobj;
22003 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22004 PyObject *result;
22005 PyObject * obj0 = 0 ;
22006 char *kwnames[] = {
22007 (char *) "self", NULL
22008 };
22009
22010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22012 if (SWIG_arg_fail(1)) SWIG_fail;
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (PyObject *)(arg1)->GetSelf();
22016
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = result;
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22028 PyObject *obj;
22029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22030 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22031 Py_INCREF(obj);
22032 return Py_BuildValue((char *)"");
22033 }
22034 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22035 PyObject *resultobj;
22036 wxWindow *arg1 = (wxWindow *) 0 ;
22037 wxDateTime *arg2 = 0 ;
22038 wxEventType arg3 ;
22039 wxDateEvent *result;
22040 PyObject * obj0 = 0 ;
22041 PyObject * obj1 = 0 ;
22042 PyObject * obj2 = 0 ;
22043 char *kwnames[] = {
22044 (char *) "win",(char *) "dt",(char *) "type", NULL
22045 };
22046
22047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22049 if (SWIG_arg_fail(1)) SWIG_fail;
22050 {
22051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22052 if (SWIG_arg_fail(2)) SWIG_fail;
22053 if (arg2 == NULL) {
22054 SWIG_null_ref("wxDateTime");
22055 }
22056 if (SWIG_arg_fail(2)) SWIG_fail;
22057 }
22058 {
22059 arg3 = (wxEventType)(SWIG_As_int(obj2));
22060 if (SWIG_arg_fail(3)) SWIG_fail;
22061 }
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22065
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22070 return resultobj;
22071 fail:
22072 return NULL;
22073 }
22074
22075
22076 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22077 PyObject *resultobj;
22078 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22079 wxDateTime *result;
22080 PyObject * obj0 = 0 ;
22081 char *kwnames[] = {
22082 (char *) "self", NULL
22083 };
22084
22085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22087 if (SWIG_arg_fail(1)) SWIG_fail;
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 {
22091 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22092 result = (wxDateTime *) &_result_ref;
22093 }
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22106 PyObject *resultobj;
22107 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22108 wxDateTime *arg2 = 0 ;
22109 PyObject * obj0 = 0 ;
22110 PyObject * obj1 = 0 ;
22111 char *kwnames[] = {
22112 (char *) "self",(char *) "date", NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(1)) SWIG_fail;
22118 {
22119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22120 if (SWIG_arg_fail(2)) SWIG_fail;
22121 if (arg2 == NULL) {
22122 SWIG_null_ref("wxDateTime");
22123 }
22124 if (SWIG_arg_fail(2)) SWIG_fail;
22125 }
22126 {
22127 PyThreadState* __tstate = wxPyBeginAllowThreads();
22128 (arg1)->SetDate((wxDateTime const &)*arg2);
22129
22130 wxPyEndAllowThreads(__tstate);
22131 if (PyErr_Occurred()) SWIG_fail;
22132 }
22133 Py_INCREF(Py_None); resultobj = Py_None;
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22141 PyObject *obj;
22142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22143 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22144 Py_INCREF(obj);
22145 return Py_BuildValue((char *)"");
22146 }
22147 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22148 PyObject *resultobj;
22149 wxPyApp *result;
22150 char *kwnames[] = {
22151 NULL
22152 };
22153
22154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22155 {
22156 PyThreadState* __tstate = wxPyBeginAllowThreads();
22157 result = (wxPyApp *)new_wxPyApp();
22158
22159 wxPyEndAllowThreads(__tstate);
22160 if (PyErr_Occurred()) SWIG_fail;
22161 }
22162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22163 return resultobj;
22164 fail:
22165 return NULL;
22166 }
22167
22168
22169 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22170 PyObject *resultobj;
22171 wxPyApp *arg1 = (wxPyApp *) 0 ;
22172 PyObject * obj0 = 0 ;
22173 char *kwnames[] = {
22174 (char *) "self", NULL
22175 };
22176
22177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22179 if (SWIG_arg_fail(1)) SWIG_fail;
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 delete arg1;
22183
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 Py_INCREF(Py_None); resultobj = Py_None;
22188 return resultobj;
22189 fail:
22190 return NULL;
22191 }
22192
22193
22194 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22195 PyObject *resultobj;
22196 wxPyApp *arg1 = (wxPyApp *) 0 ;
22197 PyObject *arg2 = (PyObject *) 0 ;
22198 PyObject *arg3 = (PyObject *) 0 ;
22199 PyObject * obj0 = 0 ;
22200 PyObject * obj1 = 0 ;
22201 PyObject * obj2 = 0 ;
22202 char *kwnames[] = {
22203 (char *) "self",(char *) "self",(char *) "_class", NULL
22204 };
22205
22206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22208 if (SWIG_arg_fail(1)) SWIG_fail;
22209 arg2 = obj1;
22210 arg3 = obj2;
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 (arg1)->_setCallbackInfo(arg2,arg3);
22214
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 Py_INCREF(Py_None); resultobj = Py_None;
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22226 PyObject *resultobj;
22227 wxPyApp *arg1 = (wxPyApp *) 0 ;
22228 wxString result;
22229 PyObject * obj0 = 0 ;
22230 char *kwnames[] = {
22231 (char *) "self", NULL
22232 };
22233
22234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22236 if (SWIG_arg_fail(1)) SWIG_fail;
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 result = ((wxPyApp const *)arg1)->GetAppName();
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 {
22245 #if wxUSE_UNICODE
22246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22247 #else
22248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22249 #endif
22250 }
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22258 PyObject *resultobj;
22259 wxPyApp *arg1 = (wxPyApp *) 0 ;
22260 wxString *arg2 = 0 ;
22261 bool temp2 = false ;
22262 PyObject * obj0 = 0 ;
22263 PyObject * obj1 = 0 ;
22264 char *kwnames[] = {
22265 (char *) "self",(char *) "name", NULL
22266 };
22267
22268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22270 if (SWIG_arg_fail(1)) SWIG_fail;
22271 {
22272 arg2 = wxString_in_helper(obj1);
22273 if (arg2 == NULL) SWIG_fail;
22274 temp2 = true;
22275 }
22276 {
22277 PyThreadState* __tstate = wxPyBeginAllowThreads();
22278 (arg1)->SetAppName((wxString const &)*arg2);
22279
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 Py_INCREF(Py_None); resultobj = Py_None;
22284 {
22285 if (temp2)
22286 delete arg2;
22287 }
22288 return resultobj;
22289 fail:
22290 {
22291 if (temp2)
22292 delete arg2;
22293 }
22294 return NULL;
22295 }
22296
22297
22298 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22299 PyObject *resultobj;
22300 wxPyApp *arg1 = (wxPyApp *) 0 ;
22301 wxString result;
22302 PyObject * obj0 = 0 ;
22303 char *kwnames[] = {
22304 (char *) "self", NULL
22305 };
22306
22307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22309 if (SWIG_arg_fail(1)) SWIG_fail;
22310 {
22311 PyThreadState* __tstate = wxPyBeginAllowThreads();
22312 result = ((wxPyApp const *)arg1)->GetClassName();
22313
22314 wxPyEndAllowThreads(__tstate);
22315 if (PyErr_Occurred()) SWIG_fail;
22316 }
22317 {
22318 #if wxUSE_UNICODE
22319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22320 #else
22321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22322 #endif
22323 }
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22331 PyObject *resultobj;
22332 wxPyApp *arg1 = (wxPyApp *) 0 ;
22333 wxString *arg2 = 0 ;
22334 bool temp2 = false ;
22335 PyObject * obj0 = 0 ;
22336 PyObject * obj1 = 0 ;
22337 char *kwnames[] = {
22338 (char *) "self",(char *) "name", NULL
22339 };
22340
22341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22343 if (SWIG_arg_fail(1)) SWIG_fail;
22344 {
22345 arg2 = wxString_in_helper(obj1);
22346 if (arg2 == NULL) SWIG_fail;
22347 temp2 = true;
22348 }
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 (arg1)->SetClassName((wxString const &)*arg2);
22352
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 Py_INCREF(Py_None); resultobj = Py_None;
22357 {
22358 if (temp2)
22359 delete arg2;
22360 }
22361 return resultobj;
22362 fail:
22363 {
22364 if (temp2)
22365 delete arg2;
22366 }
22367 return NULL;
22368 }
22369
22370
22371 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22372 PyObject *resultobj;
22373 wxPyApp *arg1 = (wxPyApp *) 0 ;
22374 wxString *result;
22375 PyObject * obj0 = 0 ;
22376 char *kwnames[] = {
22377 (char *) "self", NULL
22378 };
22379
22380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22382 if (SWIG_arg_fail(1)) SWIG_fail;
22383 {
22384 PyThreadState* __tstate = wxPyBeginAllowThreads();
22385 {
22386 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22387 result = (wxString *) &_result_ref;
22388 }
22389
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 {
22394 #if wxUSE_UNICODE
22395 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22396 #else
22397 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22398 #endif
22399 }
22400 return resultobj;
22401 fail:
22402 return NULL;
22403 }
22404
22405
22406 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22407 PyObject *resultobj;
22408 wxPyApp *arg1 = (wxPyApp *) 0 ;
22409 wxString *arg2 = 0 ;
22410 bool temp2 = false ;
22411 PyObject * obj0 = 0 ;
22412 PyObject * obj1 = 0 ;
22413 char *kwnames[] = {
22414 (char *) "self",(char *) "name", NULL
22415 };
22416
22417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22419 if (SWIG_arg_fail(1)) SWIG_fail;
22420 {
22421 arg2 = wxString_in_helper(obj1);
22422 if (arg2 == NULL) SWIG_fail;
22423 temp2 = true;
22424 }
22425 {
22426 PyThreadState* __tstate = wxPyBeginAllowThreads();
22427 (arg1)->SetVendorName((wxString const &)*arg2);
22428
22429 wxPyEndAllowThreads(__tstate);
22430 if (PyErr_Occurred()) SWIG_fail;
22431 }
22432 Py_INCREF(Py_None); resultobj = Py_None;
22433 {
22434 if (temp2)
22435 delete arg2;
22436 }
22437 return resultobj;
22438 fail:
22439 {
22440 if (temp2)
22441 delete arg2;
22442 }
22443 return NULL;
22444 }
22445
22446
22447 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22448 PyObject *resultobj;
22449 wxPyApp *arg1 = (wxPyApp *) 0 ;
22450 wxAppTraits *result;
22451 PyObject * obj0 = 0 ;
22452 char *kwnames[] = {
22453 (char *) "self", NULL
22454 };
22455
22456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22458 if (SWIG_arg_fail(1)) SWIG_fail;
22459 {
22460 PyThreadState* __tstate = wxPyBeginAllowThreads();
22461 result = (wxAppTraits *)(arg1)->GetTraits();
22462
22463 wxPyEndAllowThreads(__tstate);
22464 if (PyErr_Occurred()) SWIG_fail;
22465 }
22466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22474 PyObject *resultobj;
22475 wxPyApp *arg1 = (wxPyApp *) 0 ;
22476 PyObject * obj0 = 0 ;
22477 char *kwnames[] = {
22478 (char *) "self", NULL
22479 };
22480
22481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(1)) SWIG_fail;
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 (arg1)->ProcessPendingEvents();
22487
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 Py_INCREF(Py_None); resultobj = Py_None;
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22499 PyObject *resultobj;
22500 wxPyApp *arg1 = (wxPyApp *) 0 ;
22501 bool arg2 = (bool) false ;
22502 bool result;
22503 PyObject * obj0 = 0 ;
22504 PyObject * obj1 = 0 ;
22505 char *kwnames[] = {
22506 (char *) "self",(char *) "onlyIfNeeded", NULL
22507 };
22508
22509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22511 if (SWIG_arg_fail(1)) SWIG_fail;
22512 if (obj1) {
22513 {
22514 arg2 = (bool)(SWIG_As_bool(obj1));
22515 if (SWIG_arg_fail(2)) SWIG_fail;
22516 }
22517 }
22518 {
22519 PyThreadState* __tstate = wxPyBeginAllowThreads();
22520 result = (bool)(arg1)->Yield(arg2);
22521
22522 wxPyEndAllowThreads(__tstate);
22523 if (PyErr_Occurred()) SWIG_fail;
22524 }
22525 {
22526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22527 }
22528 return resultobj;
22529 fail:
22530 return NULL;
22531 }
22532
22533
22534 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22535 PyObject *resultobj;
22536 wxPyApp *arg1 = (wxPyApp *) 0 ;
22537 PyObject * obj0 = 0 ;
22538 char *kwnames[] = {
22539 (char *) "self", NULL
22540 };
22541
22542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22544 if (SWIG_arg_fail(1)) SWIG_fail;
22545 {
22546 PyThreadState* __tstate = wxPyBeginAllowThreads();
22547 (arg1)->WakeUpIdle();
22548
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 Py_INCREF(Py_None); resultobj = Py_None;
22553 return resultobj;
22554 fail:
22555 return NULL;
22556 }
22557
22558
22559 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22560 PyObject *resultobj;
22561 bool result;
22562 char *kwnames[] = {
22563 NULL
22564 };
22565
22566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22567 {
22568 PyThreadState* __tstate = wxPyBeginAllowThreads();
22569 result = (bool)wxPyApp::IsMainLoopRunning();
22570
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 {
22575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22576 }
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22584 PyObject *resultobj;
22585 wxPyApp *arg1 = (wxPyApp *) 0 ;
22586 int result;
22587 PyObject * obj0 = 0 ;
22588 char *kwnames[] = {
22589 (char *) "self", NULL
22590 };
22591
22592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22594 if (SWIG_arg_fail(1)) SWIG_fail;
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 result = (int)(arg1)->MainLoop();
22598
22599 wxPyEndAllowThreads(__tstate);
22600 if (PyErr_Occurred()) SWIG_fail;
22601 }
22602 {
22603 resultobj = SWIG_From_int((int)(result));
22604 }
22605 return resultobj;
22606 fail:
22607 return NULL;
22608 }
22609
22610
22611 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22612 PyObject *resultobj;
22613 wxPyApp *arg1 = (wxPyApp *) 0 ;
22614 PyObject * obj0 = 0 ;
22615 char *kwnames[] = {
22616 (char *) "self", NULL
22617 };
22618
22619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22621 if (SWIG_arg_fail(1)) SWIG_fail;
22622 {
22623 PyThreadState* __tstate = wxPyBeginAllowThreads();
22624 (arg1)->Exit();
22625
22626 wxPyEndAllowThreads(__tstate);
22627 if (PyErr_Occurred()) SWIG_fail;
22628 }
22629 Py_INCREF(Py_None); resultobj = Py_None;
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22637 PyObject *resultobj;
22638 wxPyApp *arg1 = (wxPyApp *) 0 ;
22639 PyObject * obj0 = 0 ;
22640 char *kwnames[] = {
22641 (char *) "self", NULL
22642 };
22643
22644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22646 if (SWIG_arg_fail(1)) SWIG_fail;
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 (arg1)->ExitMainLoop();
22650
22651 wxPyEndAllowThreads(__tstate);
22652 if (PyErr_Occurred()) SWIG_fail;
22653 }
22654 Py_INCREF(Py_None); resultobj = Py_None;
22655 return resultobj;
22656 fail:
22657 return NULL;
22658 }
22659
22660
22661 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22662 PyObject *resultobj;
22663 wxPyApp *arg1 = (wxPyApp *) 0 ;
22664 bool result;
22665 PyObject * obj0 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (bool)(arg1)->Pending();
22676
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 {
22681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22682 }
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj;
22691 wxPyApp *arg1 = (wxPyApp *) 0 ;
22692 bool result;
22693 PyObject * obj0 = 0 ;
22694 char *kwnames[] = {
22695 (char *) "self", NULL
22696 };
22697
22698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22700 if (SWIG_arg_fail(1)) SWIG_fail;
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 result = (bool)(arg1)->Dispatch();
22704
22705 wxPyEndAllowThreads(__tstate);
22706 if (PyErr_Occurred()) SWIG_fail;
22707 }
22708 {
22709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22710 }
22711 return resultobj;
22712 fail:
22713 return NULL;
22714 }
22715
22716
22717 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22718 PyObject *resultobj;
22719 wxPyApp *arg1 = (wxPyApp *) 0 ;
22720 bool result;
22721 PyObject * obj0 = 0 ;
22722 char *kwnames[] = {
22723 (char *) "self", NULL
22724 };
22725
22726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22728 if (SWIG_arg_fail(1)) SWIG_fail;
22729 {
22730 PyThreadState* __tstate = wxPyBeginAllowThreads();
22731 result = (bool)(arg1)->ProcessIdle();
22732
22733 wxPyEndAllowThreads(__tstate);
22734 if (PyErr_Occurred()) SWIG_fail;
22735 }
22736 {
22737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22738 }
22739 return resultobj;
22740 fail:
22741 return NULL;
22742 }
22743
22744
22745 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22746 PyObject *resultobj;
22747 wxPyApp *arg1 = (wxPyApp *) 0 ;
22748 wxWindow *arg2 = (wxWindow *) 0 ;
22749 wxIdleEvent *arg3 = 0 ;
22750 bool result;
22751 PyObject * obj0 = 0 ;
22752 PyObject * obj1 = 0 ;
22753 PyObject * obj2 = 0 ;
22754 char *kwnames[] = {
22755 (char *) "self",(char *) "win",(char *) "event", NULL
22756 };
22757
22758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22760 if (SWIG_arg_fail(1)) SWIG_fail;
22761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22762 if (SWIG_arg_fail(2)) SWIG_fail;
22763 {
22764 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22765 if (SWIG_arg_fail(3)) SWIG_fail;
22766 if (arg3 == NULL) {
22767 SWIG_null_ref("wxIdleEvent");
22768 }
22769 if (SWIG_arg_fail(3)) SWIG_fail;
22770 }
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22774
22775 wxPyEndAllowThreads(__tstate);
22776 if (PyErr_Occurred()) SWIG_fail;
22777 }
22778 {
22779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22780 }
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj;
22789 wxPyApp *arg1 = (wxPyApp *) 0 ;
22790 bool result;
22791 PyObject * obj0 = 0 ;
22792 char *kwnames[] = {
22793 (char *) "self", NULL
22794 };
22795
22796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22798 if (SWIG_arg_fail(1)) SWIG_fail;
22799 {
22800 PyThreadState* __tstate = wxPyBeginAllowThreads();
22801 result = (bool)((wxPyApp const *)arg1)->IsActive();
22802
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 {
22807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22808 }
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22816 PyObject *resultobj;
22817 wxPyApp *arg1 = (wxPyApp *) 0 ;
22818 wxWindow *arg2 = (wxWindow *) 0 ;
22819 PyObject * obj0 = 0 ;
22820 PyObject * obj1 = 0 ;
22821 char *kwnames[] = {
22822 (char *) "self",(char *) "win", NULL
22823 };
22824
22825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22827 if (SWIG_arg_fail(1)) SWIG_fail;
22828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22829 if (SWIG_arg_fail(2)) SWIG_fail;
22830 {
22831 PyThreadState* __tstate = wxPyBeginAllowThreads();
22832 (arg1)->SetTopWindow(arg2);
22833
22834 wxPyEndAllowThreads(__tstate);
22835 if (PyErr_Occurred()) SWIG_fail;
22836 }
22837 Py_INCREF(Py_None); resultobj = Py_None;
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22845 PyObject *resultobj;
22846 wxPyApp *arg1 = (wxPyApp *) 0 ;
22847 wxWindow *result;
22848 PyObject * obj0 = 0 ;
22849 char *kwnames[] = {
22850 (char *) "self", NULL
22851 };
22852
22853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22855 if (SWIG_arg_fail(1)) SWIG_fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 {
22864 resultobj = wxPyMake_wxObject(result, 0);
22865 }
22866 return resultobj;
22867 fail:
22868 return NULL;
22869 }
22870
22871
22872 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj;
22874 wxPyApp *arg1 = (wxPyApp *) 0 ;
22875 bool arg2 ;
22876 PyObject * obj0 = 0 ;
22877 PyObject * obj1 = 0 ;
22878 char *kwnames[] = {
22879 (char *) "self",(char *) "flag", NULL
22880 };
22881
22882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22884 if (SWIG_arg_fail(1)) SWIG_fail;
22885 {
22886 arg2 = (bool)(SWIG_As_bool(obj1));
22887 if (SWIG_arg_fail(2)) SWIG_fail;
22888 }
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 (arg1)->SetExitOnFrameDelete(arg2);
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 Py_INCREF(Py_None); resultobj = Py_None;
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22904 PyObject *resultobj;
22905 wxPyApp *arg1 = (wxPyApp *) 0 ;
22906 bool result;
22907 PyObject * obj0 = 0 ;
22908 char *kwnames[] = {
22909 (char *) "self", NULL
22910 };
22911
22912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22914 if (SWIG_arg_fail(1)) SWIG_fail;
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22918
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 {
22923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22924 }
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22932 PyObject *resultobj;
22933 wxPyApp *arg1 = (wxPyApp *) 0 ;
22934 bool arg2 ;
22935 PyObject * obj0 = 0 ;
22936 PyObject * obj1 = 0 ;
22937 char *kwnames[] = {
22938 (char *) "self",(char *) "flag", NULL
22939 };
22940
22941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22943 if (SWIG_arg_fail(1)) SWIG_fail;
22944 {
22945 arg2 = (bool)(SWIG_As_bool(obj1));
22946 if (SWIG_arg_fail(2)) SWIG_fail;
22947 }
22948 {
22949 PyThreadState* __tstate = wxPyBeginAllowThreads();
22950 (arg1)->SetUseBestVisual(arg2);
22951
22952 wxPyEndAllowThreads(__tstate);
22953 if (PyErr_Occurred()) SWIG_fail;
22954 }
22955 Py_INCREF(Py_None); resultobj = Py_None;
22956 return resultobj;
22957 fail:
22958 return NULL;
22959 }
22960
22961
22962 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22963 PyObject *resultobj;
22964 wxPyApp *arg1 = (wxPyApp *) 0 ;
22965 bool result;
22966 PyObject * obj0 = 0 ;
22967 char *kwnames[] = {
22968 (char *) "self", NULL
22969 };
22970
22971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22973 if (SWIG_arg_fail(1)) SWIG_fail;
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22977
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 {
22982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22983 }
22984 return resultobj;
22985 fail:
22986 return NULL;
22987 }
22988
22989
22990 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22991 PyObject *resultobj;
22992 wxPyApp *arg1 = (wxPyApp *) 0 ;
22993 int arg2 ;
22994 PyObject * obj0 = 0 ;
22995 PyObject * obj1 = 0 ;
22996 char *kwnames[] = {
22997 (char *) "self",(char *) "mode", NULL
22998 };
22999
23000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23002 if (SWIG_arg_fail(1)) SWIG_fail;
23003 {
23004 arg2 = (int)(SWIG_As_int(obj1));
23005 if (SWIG_arg_fail(2)) SWIG_fail;
23006 }
23007 {
23008 PyThreadState* __tstate = wxPyBeginAllowThreads();
23009 (arg1)->SetPrintMode(arg2);
23010
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 Py_INCREF(Py_None); resultobj = Py_None;
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23022 PyObject *resultobj;
23023 wxPyApp *arg1 = (wxPyApp *) 0 ;
23024 int result;
23025 PyObject * obj0 = 0 ;
23026 char *kwnames[] = {
23027 (char *) "self", NULL
23028 };
23029
23030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23032 if (SWIG_arg_fail(1)) SWIG_fail;
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23036
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 {
23041 resultobj = SWIG_From_int((int)(result));
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23050 PyObject *resultobj;
23051 wxPyApp *arg1 = (wxPyApp *) 0 ;
23052 int arg2 ;
23053 PyObject * obj0 = 0 ;
23054 PyObject * obj1 = 0 ;
23055 char *kwnames[] = {
23056 (char *) "self",(char *) "mode", NULL
23057 };
23058
23059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23061 if (SWIG_arg_fail(1)) SWIG_fail;
23062 {
23063 arg2 = (int)(SWIG_As_int(obj1));
23064 if (SWIG_arg_fail(2)) SWIG_fail;
23065 }
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 (arg1)->SetAssertMode(arg2);
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 Py_INCREF(Py_None); resultobj = Py_None;
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23081 PyObject *resultobj;
23082 wxPyApp *arg1 = (wxPyApp *) 0 ;
23083 int result;
23084 PyObject * obj0 = 0 ;
23085 char *kwnames[] = {
23086 (char *) "self", NULL
23087 };
23088
23089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(1)) SWIG_fail;
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 result = (int)(arg1)->GetAssertMode();
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 {
23100 resultobj = SWIG_From_int((int)(result));
23101 }
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23109 PyObject *resultobj;
23110 bool result;
23111 char *kwnames[] = {
23112 NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23116 {
23117 PyThreadState* __tstate = wxPyBeginAllowThreads();
23118 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23119
23120 wxPyEndAllowThreads(__tstate);
23121 if (PyErr_Occurred()) SWIG_fail;
23122 }
23123 {
23124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23125 }
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj;
23134 long result;
23135 char *kwnames[] = {
23136 NULL
23137 };
23138
23139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23140 {
23141 PyThreadState* __tstate = wxPyBeginAllowThreads();
23142 result = (long)wxPyApp::GetMacAboutMenuItemId();
23143
23144 wxPyEndAllowThreads(__tstate);
23145 if (PyErr_Occurred()) SWIG_fail;
23146 }
23147 {
23148 resultobj = SWIG_From_long((long)(result));
23149 }
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23157 PyObject *resultobj;
23158 long result;
23159 char *kwnames[] = {
23160 NULL
23161 };
23162
23163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23164 {
23165 PyThreadState* __tstate = wxPyBeginAllowThreads();
23166 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23167
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 {
23172 resultobj = SWIG_From_long((long)(result));
23173 }
23174 return resultobj;
23175 fail:
23176 return NULL;
23177 }
23178
23179
23180 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23181 PyObject *resultobj;
23182 long result;
23183 char *kwnames[] = {
23184 NULL
23185 };
23186
23187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = (long)wxPyApp::GetMacExitMenuItemId();
23191
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 {
23196 resultobj = SWIG_From_long((long)(result));
23197 }
23198 return resultobj;
23199 fail:
23200 return NULL;
23201 }
23202
23203
23204 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23205 PyObject *resultobj;
23206 wxString result;
23207 char *kwnames[] = {
23208 NULL
23209 };
23210
23211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = wxPyApp::GetMacHelpMenuTitleName();
23215
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 #if wxUSE_UNICODE
23221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23222 #else
23223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23224 #endif
23225 }
23226 return resultobj;
23227 fail:
23228 return NULL;
23229 }
23230
23231
23232 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23233 PyObject *resultobj;
23234 bool arg1 ;
23235 PyObject * obj0 = 0 ;
23236 char *kwnames[] = {
23237 (char *) "val", NULL
23238 };
23239
23240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23241 {
23242 arg1 = (bool)(SWIG_As_bool(obj0));
23243 if (SWIG_arg_fail(1)) SWIG_fail;
23244 }
23245 {
23246 PyThreadState* __tstate = wxPyBeginAllowThreads();
23247 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23248
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 Py_INCREF(Py_None); resultobj = Py_None;
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23260 PyObject *resultobj;
23261 long arg1 ;
23262 PyObject * obj0 = 0 ;
23263 char *kwnames[] = {
23264 (char *) "val", NULL
23265 };
23266
23267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23268 {
23269 arg1 = (long)(SWIG_As_long(obj0));
23270 if (SWIG_arg_fail(1)) SWIG_fail;
23271 }
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 wxPyApp::SetMacAboutMenuItemId(arg1);
23275
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 Py_INCREF(Py_None); resultobj = Py_None;
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 long arg1 ;
23289 PyObject * obj0 = 0 ;
23290 char *kwnames[] = {
23291 (char *) "val", NULL
23292 };
23293
23294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23295 {
23296 arg1 = (long)(SWIG_As_long(obj0));
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 }
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23302
23303 wxPyEndAllowThreads(__tstate);
23304 if (PyErr_Occurred()) SWIG_fail;
23305 }
23306 Py_INCREF(Py_None); resultobj = Py_None;
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23314 PyObject *resultobj;
23315 long arg1 ;
23316 PyObject * obj0 = 0 ;
23317 char *kwnames[] = {
23318 (char *) "val", NULL
23319 };
23320
23321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23322 {
23323 arg1 = (long)(SWIG_As_long(obj0));
23324 if (SWIG_arg_fail(1)) SWIG_fail;
23325 }
23326 {
23327 PyThreadState* __tstate = wxPyBeginAllowThreads();
23328 wxPyApp::SetMacExitMenuItemId(arg1);
23329
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 Py_INCREF(Py_None); resultobj = Py_None;
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj;
23342 wxString *arg1 = 0 ;
23343 bool temp1 = false ;
23344 PyObject * obj0 = 0 ;
23345 char *kwnames[] = {
23346 (char *) "val", NULL
23347 };
23348
23349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23350 {
23351 arg1 = wxString_in_helper(obj0);
23352 if (arg1 == NULL) SWIG_fail;
23353 temp1 = true;
23354 }
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 Py_INCREF(Py_None); resultobj = Py_None;
23363 {
23364 if (temp1)
23365 delete arg1;
23366 }
23367 return resultobj;
23368 fail:
23369 {
23370 if (temp1)
23371 delete arg1;
23372 }
23373 return NULL;
23374 }
23375
23376
23377 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23378 PyObject *resultobj;
23379 wxPyApp *arg1 = (wxPyApp *) 0 ;
23380 PyObject * obj0 = 0 ;
23381 char *kwnames[] = {
23382 (char *) "self", NULL
23383 };
23384
23385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23387 if (SWIG_arg_fail(1)) SWIG_fail;
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 (arg1)->_BootstrapApp();
23391
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 Py_INCREF(Py_None); resultobj = Py_None;
23396 return resultobj;
23397 fail:
23398 return NULL;
23399 }
23400
23401
23402 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj;
23404 int result;
23405 char *kwnames[] = {
23406 NULL
23407 };
23408
23409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 result = (int)PyApp_GetComCtl32Version();
23413
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = SWIG_From_int((int)(result));
23419 }
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23427 PyObject *obj;
23428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23429 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23430 Py_INCREF(obj);
23431 return Py_BuildValue((char *)"");
23432 }
23433 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj;
23435 char *kwnames[] = {
23436 NULL
23437 };
23438
23439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 wxExit();
23443
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 Py_INCREF(Py_None); resultobj = Py_None;
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj;
23456 bool result;
23457 char *kwnames[] = {
23458 NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23462 {
23463 PyThreadState* __tstate = wxPyBeginAllowThreads();
23464 result = (bool)wxYield();
23465
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 {
23470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23471 }
23472 return resultobj;
23473 fail:
23474 return NULL;
23475 }
23476
23477
23478 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23479 PyObject *resultobj;
23480 bool result;
23481 char *kwnames[] = {
23482 NULL
23483 };
23484
23485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (bool)wxYieldIfNeeded();
23489
23490 wxPyEndAllowThreads(__tstate);
23491 if (PyErr_Occurred()) SWIG_fail;
23492 }
23493 {
23494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23495 }
23496 return resultobj;
23497 fail:
23498 return NULL;
23499 }
23500
23501
23502 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23503 PyObject *resultobj;
23504 wxWindow *arg1 = (wxWindow *) NULL ;
23505 bool arg2 = (bool) false ;
23506 bool result;
23507 PyObject * obj0 = 0 ;
23508 PyObject * obj1 = 0 ;
23509 char *kwnames[] = {
23510 (char *) "win",(char *) "onlyIfNeeded", NULL
23511 };
23512
23513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23514 if (obj0) {
23515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23516 if (SWIG_arg_fail(1)) SWIG_fail;
23517 }
23518 if (obj1) {
23519 {
23520 arg2 = (bool)(SWIG_As_bool(obj1));
23521 if (SWIG_arg_fail(2)) SWIG_fail;
23522 }
23523 }
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = (bool)wxSafeYield(arg1,arg2);
23527
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 {
23532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23533 }
23534 return resultobj;
23535 fail:
23536 return NULL;
23537 }
23538
23539
23540 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23541 PyObject *resultobj;
23542 char *kwnames[] = {
23543 NULL
23544 };
23545
23546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 wxWakeUpIdle();
23550
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 Py_INCREF(Py_None); resultobj = Py_None;
23555 return resultobj;
23556 fail:
23557 return NULL;
23558 }
23559
23560
23561 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23562 PyObject *resultobj;
23563 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23564 wxEvent *arg2 = 0 ;
23565 PyObject * obj0 = 0 ;
23566 PyObject * obj1 = 0 ;
23567 char *kwnames[] = {
23568 (char *) "dest",(char *) "event", NULL
23569 };
23570
23571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23573 if (SWIG_arg_fail(1)) SWIG_fail;
23574 {
23575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23576 if (SWIG_arg_fail(2)) SWIG_fail;
23577 if (arg2 == NULL) {
23578 SWIG_null_ref("wxEvent");
23579 }
23580 if (SWIG_arg_fail(2)) SWIG_fail;
23581 }
23582 {
23583 PyThreadState* __tstate = wxPyBeginAllowThreads();
23584 wxPostEvent(arg1,*arg2);
23585
23586 wxPyEndAllowThreads(__tstate);
23587 if (PyErr_Occurred()) SWIG_fail;
23588 }
23589 Py_INCREF(Py_None); resultobj = Py_None;
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj;
23598 char *kwnames[] = {
23599 NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 wxApp_CleanUp();
23606
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 Py_INCREF(Py_None); resultobj = Py_None;
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxPyApp *result;
23620 char *kwnames[] = {
23621 NULL
23622 };
23623
23624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = (wxPyApp *)wxPyGetApp();
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 {
23633 resultobj = wxPyMake_wxObject(result, 0);
23634 }
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj;
23643 char *arg1 = (char *) 0 ;
23644 PyObject * obj0 = 0 ;
23645 char *kwnames[] = {
23646 (char *) "encoding", NULL
23647 };
23648
23649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23650 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23651 SWIG_arg_fail(1);SWIG_fail;
23652 }
23653 {
23654 PyThreadState* __tstate = wxPyBeginAllowThreads();
23655 wxSetDefaultPyEncoding((char const *)arg1);
23656
23657 wxPyEndAllowThreads(__tstate);
23658 if (PyErr_Occurred()) SWIG_fail;
23659 }
23660 Py_INCREF(Py_None); resultobj = Py_None;
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj;
23669 char *result;
23670 char *kwnames[] = {
23671 NULL
23672 };
23673
23674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23675 {
23676 PyThreadState* __tstate = wxPyBeginAllowThreads();
23677 result = (char *)wxGetDefaultPyEncoding();
23678
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 resultobj = SWIG_FromCharPtr(result);
23683 return resultobj;
23684 fail:
23685 return NULL;
23686 }
23687
23688
23689 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23690 PyObject *resultobj;
23691 wxEventLoop *result;
23692 char *kwnames[] = {
23693 NULL
23694 };
23695
23696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23697 {
23698 PyThreadState* __tstate = wxPyBeginAllowThreads();
23699 result = (wxEventLoop *)new wxEventLoop();
23700
23701 wxPyEndAllowThreads(__tstate);
23702 if (PyErr_Occurred()) SWIG_fail;
23703 }
23704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23705 return resultobj;
23706 fail:
23707 return NULL;
23708 }
23709
23710
23711 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23712 PyObject *resultobj;
23713 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23714 PyObject * obj0 = 0 ;
23715 char *kwnames[] = {
23716 (char *) "self", NULL
23717 };
23718
23719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23721 if (SWIG_arg_fail(1)) SWIG_fail;
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 delete arg1;
23725
23726 wxPyEndAllowThreads(__tstate);
23727 if (PyErr_Occurred()) SWIG_fail;
23728 }
23729 Py_INCREF(Py_None); resultobj = Py_None;
23730 return resultobj;
23731 fail:
23732 return NULL;
23733 }
23734
23735
23736 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23737 PyObject *resultobj;
23738 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23739 int result;
23740 PyObject * obj0 = 0 ;
23741 char *kwnames[] = {
23742 (char *) "self", NULL
23743 };
23744
23745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23747 if (SWIG_arg_fail(1)) SWIG_fail;
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = (int)(arg1)->Run();
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 {
23756 resultobj = SWIG_From_int((int)(result));
23757 }
23758 return resultobj;
23759 fail:
23760 return NULL;
23761 }
23762
23763
23764 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23765 PyObject *resultobj;
23766 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23767 int arg2 = (int) 0 ;
23768 PyObject * obj0 = 0 ;
23769 PyObject * obj1 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "self",(char *) "rc", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23776 if (SWIG_arg_fail(1)) SWIG_fail;
23777 if (obj1) {
23778 {
23779 arg2 = (int)(SWIG_As_int(obj1));
23780 if (SWIG_arg_fail(2)) SWIG_fail;
23781 }
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 (arg1)->Exit(arg2);
23786
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 Py_INCREF(Py_None); resultobj = Py_None;
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj;
23799 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23800 bool result;
23801 PyObject * obj0 = 0 ;
23802 char *kwnames[] = {
23803 (char *) "self", NULL
23804 };
23805
23806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23808 if (SWIG_arg_fail(1)) SWIG_fail;
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 result = (bool)((wxEventLoop const *)arg1)->Pending();
23812
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23826 PyObject *resultobj;
23827 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23828 bool result;
23829 PyObject * obj0 = 0 ;
23830 char *kwnames[] = {
23831 (char *) "self", NULL
23832 };
23833
23834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23836 if (SWIG_arg_fail(1)) SWIG_fail;
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (bool)(arg1)->Dispatch();
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 {
23845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23846 }
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23854 PyObject *resultobj;
23855 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23856 bool result;
23857 PyObject * obj0 = 0 ;
23858 char *kwnames[] = {
23859 (char *) "self", NULL
23860 };
23861
23862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23864 if (SWIG_arg_fail(1)) SWIG_fail;
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23868
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 {
23873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23874 }
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23882 PyObject *resultobj;
23883 wxEventLoop *result;
23884 char *kwnames[] = {
23885 NULL
23886 };
23887
23888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23889 {
23890 PyThreadState* __tstate = wxPyBeginAllowThreads();
23891 result = (wxEventLoop *)wxEventLoop::GetActive();
23892
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23904 PyObject *resultobj;
23905 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23906 PyObject * obj0 = 0 ;
23907 char *kwnames[] = {
23908 (char *) "loop", NULL
23909 };
23910
23911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23913 if (SWIG_arg_fail(1)) SWIG_fail;
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 wxEventLoop::SetActive(arg1);
23917
23918 wxPyEndAllowThreads(__tstate);
23919 if (PyErr_Occurred()) SWIG_fail;
23920 }
23921 Py_INCREF(Py_None); resultobj = Py_None;
23922 return resultobj;
23923 fail:
23924 return NULL;
23925 }
23926
23927
23928 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23929 PyObject *obj;
23930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23931 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23932 Py_INCREF(obj);
23933 return Py_BuildValue((char *)"");
23934 }
23935 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj;
23937 int arg1 = (int) 0 ;
23938 int arg2 = (int) 0 ;
23939 int arg3 = (int) 0 ;
23940 wxAcceleratorEntry *result;
23941 PyObject * obj0 = 0 ;
23942 PyObject * obj1 = 0 ;
23943 PyObject * obj2 = 0 ;
23944 char *kwnames[] = {
23945 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23946 };
23947
23948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23949 if (obj0) {
23950 {
23951 arg1 = (int)(SWIG_As_int(obj0));
23952 if (SWIG_arg_fail(1)) SWIG_fail;
23953 }
23954 }
23955 if (obj1) {
23956 {
23957 arg2 = (int)(SWIG_As_int(obj1));
23958 if (SWIG_arg_fail(2)) SWIG_fail;
23959 }
23960 }
23961 if (obj2) {
23962 {
23963 arg3 = (int)(SWIG_As_int(obj2));
23964 if (SWIG_arg_fail(3)) SWIG_fail;
23965 }
23966 }
23967 {
23968 PyThreadState* __tstate = wxPyBeginAllowThreads();
23969 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23970
23971 wxPyEndAllowThreads(__tstate);
23972 if (PyErr_Occurred()) SWIG_fail;
23973 }
23974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23975 return resultobj;
23976 fail:
23977 return NULL;
23978 }
23979
23980
23981 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23982 PyObject *resultobj;
23983 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23984 PyObject * obj0 = 0 ;
23985 char *kwnames[] = {
23986 (char *) "self", NULL
23987 };
23988
23989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23991 if (SWIG_arg_fail(1)) SWIG_fail;
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 delete arg1;
23995
23996 wxPyEndAllowThreads(__tstate);
23997 if (PyErr_Occurred()) SWIG_fail;
23998 }
23999 Py_INCREF(Py_None); resultobj = Py_None;
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj;
24008 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24009 int arg2 ;
24010 int arg3 ;
24011 int arg4 ;
24012 PyObject * obj0 = 0 ;
24013 PyObject * obj1 = 0 ;
24014 PyObject * obj2 = 0 ;
24015 PyObject * obj3 = 0 ;
24016 char *kwnames[] = {
24017 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24018 };
24019
24020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24022 if (SWIG_arg_fail(1)) SWIG_fail;
24023 {
24024 arg2 = (int)(SWIG_As_int(obj1));
24025 if (SWIG_arg_fail(2)) SWIG_fail;
24026 }
24027 {
24028 arg3 = (int)(SWIG_As_int(obj2));
24029 if (SWIG_arg_fail(3)) SWIG_fail;
24030 }
24031 {
24032 arg4 = (int)(SWIG_As_int(obj3));
24033 if (SWIG_arg_fail(4)) SWIG_fail;
24034 }
24035 {
24036 PyThreadState* __tstate = wxPyBeginAllowThreads();
24037 (arg1)->Set(arg2,arg3,arg4);
24038
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 Py_INCREF(Py_None); resultobj = Py_None;
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24050 PyObject *resultobj;
24051 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24052 int result;
24053 PyObject * obj0 = 0 ;
24054 char *kwnames[] = {
24055 (char *) "self", NULL
24056 };
24057
24058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24060 if (SWIG_arg_fail(1)) SWIG_fail;
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 result = (int)(arg1)->GetFlags();
24064
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 {
24069 resultobj = SWIG_From_int((int)(result));
24070 }
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24078 PyObject *resultobj;
24079 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24080 int result;
24081 PyObject * obj0 = 0 ;
24082 char *kwnames[] = {
24083 (char *) "self", NULL
24084 };
24085
24086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24088 if (SWIG_arg_fail(1)) SWIG_fail;
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 result = (int)(arg1)->GetKeyCode();
24092
24093 wxPyEndAllowThreads(__tstate);
24094 if (PyErr_Occurred()) SWIG_fail;
24095 }
24096 {
24097 resultobj = SWIG_From_int((int)(result));
24098 }
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj;
24107 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24108 int result;
24109 PyObject * obj0 = 0 ;
24110 char *kwnames[] = {
24111 (char *) "self", NULL
24112 };
24113
24114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24116 if (SWIG_arg_fail(1)) SWIG_fail;
24117 {
24118 PyThreadState* __tstate = wxPyBeginAllowThreads();
24119 result = (int)(arg1)->GetCommand();
24120
24121 wxPyEndAllowThreads(__tstate);
24122 if (PyErr_Occurred()) SWIG_fail;
24123 }
24124 {
24125 resultobj = SWIG_From_int((int)(result));
24126 }
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24134 PyObject *obj;
24135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24136 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24137 Py_INCREF(obj);
24138 return Py_BuildValue((char *)"");
24139 }
24140 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 int arg1 ;
24143 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24144 wxAcceleratorTable *result;
24145 PyObject * obj0 = 0 ;
24146 char *kwnames[] = {
24147 (char *) "n", NULL
24148 };
24149
24150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24151 {
24152 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24153 if (arg2) arg1 = PyList_Size(obj0);
24154 else arg1 = 0;
24155 }
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24159
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24164 {
24165 delete [] arg2;
24166 }
24167 return resultobj;
24168 fail:
24169 {
24170 delete [] arg2;
24171 }
24172 return NULL;
24173 }
24174
24175
24176 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24177 PyObject *resultobj;
24178 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24179 PyObject * obj0 = 0 ;
24180 char *kwnames[] = {
24181 (char *) "self", NULL
24182 };
24183
24184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24186 if (SWIG_arg_fail(1)) SWIG_fail;
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 delete arg1;
24190
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 Py_INCREF(Py_None); resultobj = Py_None;
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24202 PyObject *resultobj;
24203 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24204 bool result;
24205 PyObject * obj0 = 0 ;
24206 char *kwnames[] = {
24207 (char *) "self", NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24212 if (SWIG_arg_fail(1)) SWIG_fail;
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24216
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 {
24221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24222 }
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24230 PyObject *obj;
24231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24232 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24233 Py_INCREF(obj);
24234 return Py_BuildValue((char *)"");
24235 }
24236 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24237 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24238 return 1;
24239 }
24240
24241
24242 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24243 PyObject *pyobj;
24244
24245 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24246 return pyobj;
24247 }
24248
24249
24250 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24251 PyObject *resultobj;
24252 wxString *arg1 = 0 ;
24253 wxAcceleratorEntry *result;
24254 bool temp1 = false ;
24255 PyObject * obj0 = 0 ;
24256 char *kwnames[] = {
24257 (char *) "label", NULL
24258 };
24259
24260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24261 {
24262 arg1 = wxString_in_helper(obj0);
24263 if (arg1 == NULL) SWIG_fail;
24264 temp1 = true;
24265 }
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24269
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24274 {
24275 if (temp1)
24276 delete arg1;
24277 }
24278 return resultobj;
24279 fail:
24280 {
24281 if (temp1)
24282 delete arg1;
24283 }
24284 return NULL;
24285 }
24286
24287
24288 static int _wrap_PanelNameStr_set(PyObject *) {
24289 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24290 return 1;
24291 }
24292
24293
24294 static PyObject *_wrap_PanelNameStr_get(void) {
24295 PyObject *pyobj;
24296
24297 {
24298 #if wxUSE_UNICODE
24299 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24300 #else
24301 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24302 #endif
24303 }
24304 return pyobj;
24305 }
24306
24307
24308 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 wxVisualAttributes *result;
24311 char *kwnames[] = {
24312 NULL
24313 };
24314
24315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 result = (wxVisualAttributes *)new_wxVisualAttributes();
24319
24320 wxPyEndAllowThreads(__tstate);
24321 if (PyErr_Occurred()) SWIG_fail;
24322 }
24323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24324 return resultobj;
24325 fail:
24326 return NULL;
24327 }
24328
24329
24330 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24331 PyObject *resultobj;
24332 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24333 PyObject * obj0 = 0 ;
24334 char *kwnames[] = {
24335 (char *) "self", NULL
24336 };
24337
24338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24340 if (SWIG_arg_fail(1)) SWIG_fail;
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 delete_wxVisualAttributes(arg1);
24344
24345 wxPyEndAllowThreads(__tstate);
24346 if (PyErr_Occurred()) SWIG_fail;
24347 }
24348 Py_INCREF(Py_None); resultobj = Py_None;
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24356 PyObject *resultobj;
24357 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24358 wxFont *arg2 = (wxFont *) 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char *kwnames[] = {
24362 (char *) "self",(char *) "font", NULL
24363 };
24364
24365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24367 if (SWIG_arg_fail(1)) SWIG_fail;
24368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24369 if (SWIG_arg_fail(2)) SWIG_fail;
24370 if (arg1) (arg1)->font = *arg2;
24371
24372 Py_INCREF(Py_None); resultobj = Py_None;
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24380 PyObject *resultobj;
24381 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24382 wxFont *result;
24383 PyObject * obj0 = 0 ;
24384 char *kwnames[] = {
24385 (char *) "self", NULL
24386 };
24387
24388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24390 if (SWIG_arg_fail(1)) SWIG_fail;
24391 result = (wxFont *)& ((arg1)->font);
24392
24393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj;
24402 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24403 wxColour *arg2 = (wxColour *) 0 ;
24404 PyObject * obj0 = 0 ;
24405 PyObject * obj1 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self",(char *) "colFg", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24414 if (SWIG_arg_fail(2)) SWIG_fail;
24415 if (arg1) (arg1)->colFg = *arg2;
24416
24417 Py_INCREF(Py_None); resultobj = Py_None;
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24425 PyObject *resultobj;
24426 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24427 wxColour *result;
24428 PyObject * obj0 = 0 ;
24429 char *kwnames[] = {
24430 (char *) "self", NULL
24431 };
24432
24433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24435 if (SWIG_arg_fail(1)) SWIG_fail;
24436 result = (wxColour *)& ((arg1)->colFg);
24437
24438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24446 PyObject *resultobj;
24447 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24448 wxColour *arg2 = (wxColour *) 0 ;
24449 PyObject * obj0 = 0 ;
24450 PyObject * obj1 = 0 ;
24451 char *kwnames[] = {
24452 (char *) "self",(char *) "colBg", NULL
24453 };
24454
24455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24457 if (SWIG_arg_fail(1)) SWIG_fail;
24458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24459 if (SWIG_arg_fail(2)) SWIG_fail;
24460 if (arg1) (arg1)->colBg = *arg2;
24461
24462 Py_INCREF(Py_None); resultobj = Py_None;
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj;
24471 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24472 wxColour *result;
24473 PyObject * obj0 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 result = (wxColour *)& ((arg1)->colBg);
24482
24483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24484 return resultobj;
24485 fail:
24486 return NULL;
24487 }
24488
24489
24490 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24491 PyObject *obj;
24492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24493 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24494 Py_INCREF(obj);
24495 return Py_BuildValue((char *)"");
24496 }
24497 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24498 PyObject *resultobj;
24499 wxWindow *arg1 = (wxWindow *) 0 ;
24500 int arg2 = (int) (int)-1 ;
24501 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24502 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24503 wxSize const &arg4_defvalue = wxDefaultSize ;
24504 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24505 long arg5 = (long) 0 ;
24506 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24507 wxString *arg6 = (wxString *) &arg6_defvalue ;
24508 wxWindow *result;
24509 wxPoint temp3 ;
24510 wxSize temp4 ;
24511 bool temp6 = false ;
24512 PyObject * obj0 = 0 ;
24513 PyObject * obj1 = 0 ;
24514 PyObject * obj2 = 0 ;
24515 PyObject * obj3 = 0 ;
24516 PyObject * obj4 = 0 ;
24517 PyObject * obj5 = 0 ;
24518 char *kwnames[] = {
24519 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24520 };
24521
24522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24524 if (SWIG_arg_fail(1)) SWIG_fail;
24525 if (obj1) {
24526 {
24527 arg2 = (int const)(SWIG_As_int(obj1));
24528 if (SWIG_arg_fail(2)) SWIG_fail;
24529 }
24530 }
24531 if (obj2) {
24532 {
24533 arg3 = &temp3;
24534 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24535 }
24536 }
24537 if (obj3) {
24538 {
24539 arg4 = &temp4;
24540 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24541 }
24542 }
24543 if (obj4) {
24544 {
24545 arg5 = (long)(SWIG_As_long(obj4));
24546 if (SWIG_arg_fail(5)) SWIG_fail;
24547 }
24548 }
24549 if (obj5) {
24550 {
24551 arg6 = wxString_in_helper(obj5);
24552 if (arg6 == NULL) SWIG_fail;
24553 temp6 = true;
24554 }
24555 }
24556 {
24557 if (!wxPyCheckForApp()) SWIG_fail;
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24560
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24565 {
24566 if (temp6)
24567 delete arg6;
24568 }
24569 return resultobj;
24570 fail:
24571 {
24572 if (temp6)
24573 delete arg6;
24574 }
24575 return NULL;
24576 }
24577
24578
24579 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24580 PyObject *resultobj;
24581 wxWindow *result;
24582 char *kwnames[] = {
24583 NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24587 {
24588 if (!wxPyCheckForApp()) SWIG_fail;
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 result = (wxWindow *)new wxWindow();
24591
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj;
24604 wxWindow *arg1 = (wxWindow *) 0 ;
24605 wxWindow *arg2 = (wxWindow *) 0 ;
24606 int arg3 = (int) (int)-1 ;
24607 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24608 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24609 wxSize const &arg5_defvalue = wxDefaultSize ;
24610 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24611 long arg6 = (long) 0 ;
24612 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24613 wxString *arg7 = (wxString *) &arg7_defvalue ;
24614 bool result;
24615 wxPoint temp4 ;
24616 wxSize temp5 ;
24617 bool temp7 = false ;
24618 PyObject * obj0 = 0 ;
24619 PyObject * obj1 = 0 ;
24620 PyObject * obj2 = 0 ;
24621 PyObject * obj3 = 0 ;
24622 PyObject * obj4 = 0 ;
24623 PyObject * obj5 = 0 ;
24624 PyObject * obj6 = 0 ;
24625 char *kwnames[] = {
24626 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24627 };
24628
24629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24631 if (SWIG_arg_fail(1)) SWIG_fail;
24632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24633 if (SWIG_arg_fail(2)) SWIG_fail;
24634 if (obj2) {
24635 {
24636 arg3 = (int const)(SWIG_As_int(obj2));
24637 if (SWIG_arg_fail(3)) SWIG_fail;
24638 }
24639 }
24640 if (obj3) {
24641 {
24642 arg4 = &temp4;
24643 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24644 }
24645 }
24646 if (obj4) {
24647 {
24648 arg5 = &temp5;
24649 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24650 }
24651 }
24652 if (obj5) {
24653 {
24654 arg6 = (long)(SWIG_As_long(obj5));
24655 if (SWIG_arg_fail(6)) SWIG_fail;
24656 }
24657 }
24658 if (obj6) {
24659 {
24660 arg7 = wxString_in_helper(obj6);
24661 if (arg7 == NULL) SWIG_fail;
24662 temp7 = true;
24663 }
24664 }
24665 {
24666 PyThreadState* __tstate = wxPyBeginAllowThreads();
24667 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24668
24669 wxPyEndAllowThreads(__tstate);
24670 if (PyErr_Occurred()) SWIG_fail;
24671 }
24672 {
24673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24674 }
24675 {
24676 if (temp7)
24677 delete arg7;
24678 }
24679 return resultobj;
24680 fail:
24681 {
24682 if (temp7)
24683 delete arg7;
24684 }
24685 return NULL;
24686 }
24687
24688
24689 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj;
24691 wxWindow *arg1 = (wxWindow *) 0 ;
24692 bool arg2 = (bool) false ;
24693 bool result;
24694 PyObject * obj0 = 0 ;
24695 PyObject * obj1 = 0 ;
24696 char *kwnames[] = {
24697 (char *) "self",(char *) "force", NULL
24698 };
24699
24700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24702 if (SWIG_arg_fail(1)) SWIG_fail;
24703 if (obj1) {
24704 {
24705 arg2 = (bool)(SWIG_As_bool(obj1));
24706 if (SWIG_arg_fail(2)) SWIG_fail;
24707 }
24708 }
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)(arg1)->Close(arg2);
24712
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 {
24717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24718 }
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24726 PyObject *resultobj;
24727 wxWindow *arg1 = (wxWindow *) 0 ;
24728 bool result;
24729 PyObject * obj0 = 0 ;
24730 char *kwnames[] = {
24731 (char *) "self", NULL
24732 };
24733
24734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24736 if (SWIG_arg_fail(1)) SWIG_fail;
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (bool)(arg1)->Destroy();
24740
24741 wxPyEndAllowThreads(__tstate);
24742 if (PyErr_Occurred()) SWIG_fail;
24743 }
24744 {
24745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24746 }
24747 return resultobj;
24748 fail:
24749 return NULL;
24750 }
24751
24752
24753 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24754 PyObject *resultobj;
24755 wxWindow *arg1 = (wxWindow *) 0 ;
24756 bool result;
24757 PyObject * obj0 = 0 ;
24758 char *kwnames[] = {
24759 (char *) "self", NULL
24760 };
24761
24762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24764 if (SWIG_arg_fail(1)) SWIG_fail;
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 result = (bool)(arg1)->DestroyChildren();
24768
24769 wxPyEndAllowThreads(__tstate);
24770 if (PyErr_Occurred()) SWIG_fail;
24771 }
24772 {
24773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24774 }
24775 return resultobj;
24776 fail:
24777 return NULL;
24778 }
24779
24780
24781 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24782 PyObject *resultobj;
24783 wxWindow *arg1 = (wxWindow *) 0 ;
24784 bool result;
24785 PyObject * obj0 = 0 ;
24786 char *kwnames[] = {
24787 (char *) "self", NULL
24788 };
24789
24790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24792 if (SWIG_arg_fail(1)) SWIG_fail;
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24796
24797 wxPyEndAllowThreads(__tstate);
24798 if (PyErr_Occurred()) SWIG_fail;
24799 }
24800 {
24801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24802 }
24803 return resultobj;
24804 fail:
24805 return NULL;
24806 }
24807
24808
24809 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24810 PyObject *resultobj;
24811 wxWindow *arg1 = (wxWindow *) 0 ;
24812 wxString *arg2 = 0 ;
24813 bool temp2 = false ;
24814 PyObject * obj0 = 0 ;
24815 PyObject * obj1 = 0 ;
24816 char *kwnames[] = {
24817 (char *) "self",(char *) "title", NULL
24818 };
24819
24820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(1)) SWIG_fail;
24823 {
24824 arg2 = wxString_in_helper(obj1);
24825 if (arg2 == NULL) SWIG_fail;
24826 temp2 = true;
24827 }
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 (arg1)->SetTitle((wxString const &)*arg2);
24831
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 Py_INCREF(Py_None); resultobj = Py_None;
24836 {
24837 if (temp2)
24838 delete arg2;
24839 }
24840 return resultobj;
24841 fail:
24842 {
24843 if (temp2)
24844 delete arg2;
24845 }
24846 return NULL;
24847 }
24848
24849
24850 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 wxWindow *arg1 = (wxWindow *) 0 ;
24853 wxString result;
24854 PyObject * obj0 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "self", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24861 if (SWIG_arg_fail(1)) SWIG_fail;
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 result = ((wxWindow const *)arg1)->GetTitle();
24865
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 #if wxUSE_UNICODE
24871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24872 #else
24873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24874 #endif
24875 }
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj;
24884 wxWindow *arg1 = (wxWindow *) 0 ;
24885 wxString *arg2 = 0 ;
24886 bool temp2 = false ;
24887 PyObject * obj0 = 0 ;
24888 PyObject * obj1 = 0 ;
24889 char *kwnames[] = {
24890 (char *) "self",(char *) "label", NULL
24891 };
24892
24893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24895 if (SWIG_arg_fail(1)) SWIG_fail;
24896 {
24897 arg2 = wxString_in_helper(obj1);
24898 if (arg2 == NULL) SWIG_fail;
24899 temp2 = true;
24900 }
24901 {
24902 PyThreadState* __tstate = wxPyBeginAllowThreads();
24903 (arg1)->SetLabel((wxString const &)*arg2);
24904
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 Py_INCREF(Py_None); resultobj = Py_None;
24909 {
24910 if (temp2)
24911 delete arg2;
24912 }
24913 return resultobj;
24914 fail:
24915 {
24916 if (temp2)
24917 delete arg2;
24918 }
24919 return NULL;
24920 }
24921
24922
24923 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj;
24925 wxWindow *arg1 = (wxWindow *) 0 ;
24926 wxString result;
24927 PyObject * obj0 = 0 ;
24928 char *kwnames[] = {
24929 (char *) "self", NULL
24930 };
24931
24932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(1)) SWIG_fail;
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 result = ((wxWindow const *)arg1)->GetLabel();
24938
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 #if wxUSE_UNICODE
24944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24945 #else
24946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24947 #endif
24948 }
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24956 PyObject *resultobj;
24957 wxWindow *arg1 = (wxWindow *) 0 ;
24958 wxString *arg2 = 0 ;
24959 bool temp2 = false ;
24960 PyObject * obj0 = 0 ;
24961 PyObject * obj1 = 0 ;
24962 char *kwnames[] = {
24963 (char *) "self",(char *) "name", NULL
24964 };
24965
24966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24968 if (SWIG_arg_fail(1)) SWIG_fail;
24969 {
24970 arg2 = wxString_in_helper(obj1);
24971 if (arg2 == NULL) SWIG_fail;
24972 temp2 = true;
24973 }
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 (arg1)->SetName((wxString const &)*arg2);
24977
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 Py_INCREF(Py_None); resultobj = Py_None;
24982 {
24983 if (temp2)
24984 delete arg2;
24985 }
24986 return resultobj;
24987 fail:
24988 {
24989 if (temp2)
24990 delete arg2;
24991 }
24992 return NULL;
24993 }
24994
24995
24996 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj;
24998 wxWindow *arg1 = (wxWindow *) 0 ;
24999 wxString result;
25000 PyObject * obj0 = 0 ;
25001 char *kwnames[] = {
25002 (char *) "self", NULL
25003 };
25004
25005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25007 if (SWIG_arg_fail(1)) SWIG_fail;
25008 {
25009 PyThreadState* __tstate = wxPyBeginAllowThreads();
25010 result = ((wxWindow const *)arg1)->GetName();
25011
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 {
25016 #if wxUSE_UNICODE
25017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25018 #else
25019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25020 #endif
25021 }
25022 return resultobj;
25023 fail:
25024 return NULL;
25025 }
25026
25027
25028 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25029 PyObject *resultobj;
25030 wxWindow *arg1 = (wxWindow *) 0 ;
25031 wxWindowVariant arg2 ;
25032 PyObject * obj0 = 0 ;
25033 PyObject * obj1 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self",(char *) "variant", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 {
25042 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25043 if (SWIG_arg_fail(2)) SWIG_fail;
25044 }
25045 {
25046 PyThreadState* __tstate = wxPyBeginAllowThreads();
25047 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25048
25049 wxPyEndAllowThreads(__tstate);
25050 if (PyErr_Occurred()) SWIG_fail;
25051 }
25052 Py_INCREF(Py_None); resultobj = Py_None;
25053 return resultobj;
25054 fail:
25055 return NULL;
25056 }
25057
25058
25059 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj;
25061 wxWindow *arg1 = (wxWindow *) 0 ;
25062 wxWindowVariant result;
25063 PyObject * obj0 = 0 ;
25064 char *kwnames[] = {
25065 (char *) "self", NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25070 if (SWIG_arg_fail(1)) SWIG_fail;
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25074
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 resultobj = SWIG_From_int((result));
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj;
25087 wxWindow *arg1 = (wxWindow *) 0 ;
25088 int arg2 ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 char *kwnames[] = {
25092 (char *) "self",(char *) "winid", NULL
25093 };
25094
25095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25097 if (SWIG_arg_fail(1)) SWIG_fail;
25098 {
25099 arg2 = (int)(SWIG_As_int(obj1));
25100 if (SWIG_arg_fail(2)) SWIG_fail;
25101 }
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 (arg1)->SetId(arg2);
25105
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 Py_INCREF(Py_None); resultobj = Py_None;
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25117 PyObject *resultobj;
25118 wxWindow *arg1 = (wxWindow *) 0 ;
25119 int result;
25120 PyObject * obj0 = 0 ;
25121 char *kwnames[] = {
25122 (char *) "self", NULL
25123 };
25124
25125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25127 if (SWIG_arg_fail(1)) SWIG_fail;
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 result = (int)((wxWindow const *)arg1)->GetId();
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 {
25136 resultobj = SWIG_From_int((int)(result));
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj;
25146 int result;
25147 char *kwnames[] = {
25148 NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (int)wxWindow::NewControlId();
25155
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = SWIG_From_int((int)(result));
25161 }
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj;
25170 int arg1 ;
25171 int result;
25172 PyObject * obj0 = 0 ;
25173 char *kwnames[] = {
25174 (char *) "winid", NULL
25175 };
25176
25177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25178 {
25179 arg1 = (int)(SWIG_As_int(obj0));
25180 if (SWIG_arg_fail(1)) SWIG_fail;
25181 }
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (int)wxWindow::NextControlId(arg1);
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 resultobj = SWIG_From_int((int)(result));
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 int arg1 ;
25201 int result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "winid", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25208 {
25209 arg1 = (int)(SWIG_As_int(obj0));
25210 if (SWIG_arg_fail(1)) SWIG_fail;
25211 }
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (int)wxWindow::PrevControlId(arg1);
25215
25216 wxPyEndAllowThreads(__tstate);
25217 if (PyErr_Occurred()) SWIG_fail;
25218 }
25219 {
25220 resultobj = SWIG_From_int((int)(result));
25221 }
25222 return resultobj;
25223 fail:
25224 return NULL;
25225 }
25226
25227
25228 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj;
25230 wxWindow *arg1 = (wxWindow *) 0 ;
25231 wxSize *arg2 = 0 ;
25232 wxSize temp2 ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 char *kwnames[] = {
25236 (char *) "self",(char *) "size", NULL
25237 };
25238
25239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25241 if (SWIG_arg_fail(1)) SWIG_fail;
25242 {
25243 arg2 = &temp2;
25244 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25245 }
25246 {
25247 PyThreadState* __tstate = wxPyBeginAllowThreads();
25248 (arg1)->SetSize((wxSize const &)*arg2);
25249
25250 wxPyEndAllowThreads(__tstate);
25251 if (PyErr_Occurred()) SWIG_fail;
25252 }
25253 Py_INCREF(Py_None); resultobj = Py_None;
25254 return resultobj;
25255 fail:
25256 return NULL;
25257 }
25258
25259
25260 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25261 PyObject *resultobj;
25262 wxWindow *arg1 = (wxWindow *) 0 ;
25263 int arg2 ;
25264 int arg3 ;
25265 int arg4 ;
25266 int arg5 ;
25267 int arg6 = (int) wxSIZE_AUTO ;
25268 PyObject * obj0 = 0 ;
25269 PyObject * obj1 = 0 ;
25270 PyObject * obj2 = 0 ;
25271 PyObject * obj3 = 0 ;
25272 PyObject * obj4 = 0 ;
25273 PyObject * obj5 = 0 ;
25274 char *kwnames[] = {
25275 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25276 };
25277
25278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25280 if (SWIG_arg_fail(1)) SWIG_fail;
25281 {
25282 arg2 = (int)(SWIG_As_int(obj1));
25283 if (SWIG_arg_fail(2)) SWIG_fail;
25284 }
25285 {
25286 arg3 = (int)(SWIG_As_int(obj2));
25287 if (SWIG_arg_fail(3)) SWIG_fail;
25288 }
25289 {
25290 arg4 = (int)(SWIG_As_int(obj3));
25291 if (SWIG_arg_fail(4)) SWIG_fail;
25292 }
25293 {
25294 arg5 = (int)(SWIG_As_int(obj4));
25295 if (SWIG_arg_fail(5)) SWIG_fail;
25296 }
25297 if (obj5) {
25298 {
25299 arg6 = (int)(SWIG_As_int(obj5));
25300 if (SWIG_arg_fail(6)) SWIG_fail;
25301 }
25302 }
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25306
25307 wxPyEndAllowThreads(__tstate);
25308 if (PyErr_Occurred()) SWIG_fail;
25309 }
25310 Py_INCREF(Py_None); resultobj = Py_None;
25311 return resultobj;
25312 fail:
25313 return NULL;
25314 }
25315
25316
25317 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25318 PyObject *resultobj;
25319 wxWindow *arg1 = (wxWindow *) 0 ;
25320 wxRect *arg2 = 0 ;
25321 int arg3 = (int) wxSIZE_AUTO ;
25322 wxRect temp2 ;
25323 PyObject * obj0 = 0 ;
25324 PyObject * obj1 = 0 ;
25325 PyObject * obj2 = 0 ;
25326 char *kwnames[] = {
25327 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25328 };
25329
25330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = &temp2;
25335 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25336 }
25337 if (obj2) {
25338 {
25339 arg3 = (int)(SWIG_As_int(obj2));
25340 if (SWIG_arg_fail(3)) SWIG_fail;
25341 }
25342 }
25343 {
25344 PyThreadState* __tstate = wxPyBeginAllowThreads();
25345 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25346
25347 wxPyEndAllowThreads(__tstate);
25348 if (PyErr_Occurred()) SWIG_fail;
25349 }
25350 Py_INCREF(Py_None); resultobj = Py_None;
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj;
25359 wxWindow *arg1 = (wxWindow *) 0 ;
25360 int arg2 ;
25361 int arg3 ;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 PyObject * obj2 = 0 ;
25365 char *kwnames[] = {
25366 (char *) "self",(char *) "width",(char *) "height", NULL
25367 };
25368
25369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25371 if (SWIG_arg_fail(1)) SWIG_fail;
25372 {
25373 arg2 = (int)(SWIG_As_int(obj1));
25374 if (SWIG_arg_fail(2)) SWIG_fail;
25375 }
25376 {
25377 arg3 = (int)(SWIG_As_int(obj2));
25378 if (SWIG_arg_fail(3)) SWIG_fail;
25379 }
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 (arg1)->SetSize(arg2,arg3);
25383
25384 wxPyEndAllowThreads(__tstate);
25385 if (PyErr_Occurred()) SWIG_fail;
25386 }
25387 Py_INCREF(Py_None); resultobj = Py_None;
25388 return resultobj;
25389 fail:
25390 return NULL;
25391 }
25392
25393
25394 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25395 PyObject *resultobj;
25396 wxWindow *arg1 = (wxWindow *) 0 ;
25397 wxPoint *arg2 = 0 ;
25398 int arg3 = (int) wxSIZE_USE_EXISTING ;
25399 wxPoint temp2 ;
25400 PyObject * obj0 = 0 ;
25401 PyObject * obj1 = 0 ;
25402 PyObject * obj2 = 0 ;
25403 char *kwnames[] = {
25404 (char *) "self",(char *) "pt",(char *) "flags", NULL
25405 };
25406
25407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25409 if (SWIG_arg_fail(1)) SWIG_fail;
25410 {
25411 arg2 = &temp2;
25412 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25413 }
25414 if (obj2) {
25415 {
25416 arg3 = (int)(SWIG_As_int(obj2));
25417 if (SWIG_arg_fail(3)) SWIG_fail;
25418 }
25419 }
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 (arg1)->Move((wxPoint const &)*arg2,arg3);
25423
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 Py_INCREF(Py_None); resultobj = Py_None;
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25435 PyObject *resultobj;
25436 wxWindow *arg1 = (wxWindow *) 0 ;
25437 int arg2 ;
25438 int arg3 ;
25439 int arg4 = (int) wxSIZE_USE_EXISTING ;
25440 PyObject * obj0 = 0 ;
25441 PyObject * obj1 = 0 ;
25442 PyObject * obj2 = 0 ;
25443 PyObject * obj3 = 0 ;
25444 char *kwnames[] = {
25445 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25446 };
25447
25448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25450 if (SWIG_arg_fail(1)) SWIG_fail;
25451 {
25452 arg2 = (int)(SWIG_As_int(obj1));
25453 if (SWIG_arg_fail(2)) SWIG_fail;
25454 }
25455 {
25456 arg3 = (int)(SWIG_As_int(obj2));
25457 if (SWIG_arg_fail(3)) SWIG_fail;
25458 }
25459 if (obj3) {
25460 {
25461 arg4 = (int)(SWIG_As_int(obj3));
25462 if (SWIG_arg_fail(4)) SWIG_fail;
25463 }
25464 }
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 (arg1)->Move(arg2,arg3,arg4);
25468
25469 wxPyEndAllowThreads(__tstate);
25470 if (PyErr_Occurred()) SWIG_fail;
25471 }
25472 Py_INCREF(Py_None); resultobj = Py_None;
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj;
25481 wxWindow *arg1 = (wxWindow *) 0 ;
25482 wxSize const &arg2_defvalue = wxDefaultSize ;
25483 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25484 wxSize temp2 ;
25485 PyObject * obj0 = 0 ;
25486 PyObject * obj1 = 0 ;
25487 char *kwnames[] = {
25488 (char *) "self",(char *) "size", NULL
25489 };
25490
25491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25493 if (SWIG_arg_fail(1)) SWIG_fail;
25494 if (obj1) {
25495 {
25496 arg2 = &temp2;
25497 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25498 }
25499 }
25500 {
25501 PyThreadState* __tstate = wxPyBeginAllowThreads();
25502 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25503
25504 wxPyEndAllowThreads(__tstate);
25505 if (PyErr_Occurred()) SWIG_fail;
25506 }
25507 Py_INCREF(Py_None); resultobj = Py_None;
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj;
25516 wxWindow *arg1 = (wxWindow *) 0 ;
25517 PyObject * obj0 = 0 ;
25518 char *kwnames[] = {
25519 (char *) "self", NULL
25520 };
25521
25522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25524 if (SWIG_arg_fail(1)) SWIG_fail;
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 (arg1)->Raise();
25528
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 Py_INCREF(Py_None); resultobj = Py_None;
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj;
25541 wxWindow *arg1 = (wxWindow *) 0 ;
25542 PyObject * obj0 = 0 ;
25543 char *kwnames[] = {
25544 (char *) "self", NULL
25545 };
25546
25547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25549 if (SWIG_arg_fail(1)) SWIG_fail;
25550 {
25551 PyThreadState* __tstate = wxPyBeginAllowThreads();
25552 (arg1)->Lower();
25553
25554 wxPyEndAllowThreads(__tstate);
25555 if (PyErr_Occurred()) SWIG_fail;
25556 }
25557 Py_INCREF(Py_None); resultobj = Py_None;
25558 return resultobj;
25559 fail:
25560 return NULL;
25561 }
25562
25563
25564 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25565 PyObject *resultobj;
25566 wxWindow *arg1 = (wxWindow *) 0 ;
25567 wxSize *arg2 = 0 ;
25568 wxSize temp2 ;
25569 PyObject * obj0 = 0 ;
25570 PyObject * obj1 = 0 ;
25571 char *kwnames[] = {
25572 (char *) "self",(char *) "size", NULL
25573 };
25574
25575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25577 if (SWIG_arg_fail(1)) SWIG_fail;
25578 {
25579 arg2 = &temp2;
25580 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25581 }
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 (arg1)->SetClientSize((wxSize const &)*arg2);
25585
25586 wxPyEndAllowThreads(__tstate);
25587 if (PyErr_Occurred()) SWIG_fail;
25588 }
25589 Py_INCREF(Py_None); resultobj = Py_None;
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj;
25598 wxWindow *arg1 = (wxWindow *) 0 ;
25599 int arg2 ;
25600 int arg3 ;
25601 PyObject * obj0 = 0 ;
25602 PyObject * obj1 = 0 ;
25603 PyObject * obj2 = 0 ;
25604 char *kwnames[] = {
25605 (char *) "self",(char *) "width",(char *) "height", NULL
25606 };
25607
25608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25610 if (SWIG_arg_fail(1)) SWIG_fail;
25611 {
25612 arg2 = (int)(SWIG_As_int(obj1));
25613 if (SWIG_arg_fail(2)) SWIG_fail;
25614 }
25615 {
25616 arg3 = (int)(SWIG_As_int(obj2));
25617 if (SWIG_arg_fail(3)) SWIG_fail;
25618 }
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 (arg1)->SetClientSize(arg2,arg3);
25622
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 Py_INCREF(Py_None); resultobj = Py_None;
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj;
25635 wxWindow *arg1 = (wxWindow *) 0 ;
25636 wxRect *arg2 = 0 ;
25637 wxRect temp2 ;
25638 PyObject * obj0 = 0 ;
25639 PyObject * obj1 = 0 ;
25640 char *kwnames[] = {
25641 (char *) "self",(char *) "rect", NULL
25642 };
25643
25644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25646 if (SWIG_arg_fail(1)) SWIG_fail;
25647 {
25648 arg2 = &temp2;
25649 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25650 }
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 (arg1)->SetClientSize((wxRect const &)*arg2);
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 Py_INCREF(Py_None); resultobj = Py_None;
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25666 PyObject *resultobj;
25667 wxWindow *arg1 = (wxWindow *) 0 ;
25668 wxPoint result;
25669 PyObject * obj0 = 0 ;
25670 char *kwnames[] = {
25671 (char *) "self", NULL
25672 };
25673
25674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25676 if (SWIG_arg_fail(1)) SWIG_fail;
25677 {
25678 PyThreadState* __tstate = wxPyBeginAllowThreads();
25679 result = (arg1)->GetPosition();
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 {
25685 wxPoint * resultptr;
25686 resultptr = new wxPoint((wxPoint &)(result));
25687 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25688 }
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj;
25697 wxWindow *arg1 = (wxWindow *) 0 ;
25698 int *arg2 = (int *) 0 ;
25699 int *arg3 = (int *) 0 ;
25700 int temp2 ;
25701 int res2 = 0 ;
25702 int temp3 ;
25703 int res3 = 0 ;
25704 PyObject * obj0 = 0 ;
25705 char *kwnames[] = {
25706 (char *) "self", NULL
25707 };
25708
25709 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25710 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25713 if (SWIG_arg_fail(1)) SWIG_fail;
25714 {
25715 PyThreadState* __tstate = wxPyBeginAllowThreads();
25716 (arg1)->GetPosition(arg2,arg3);
25717
25718 wxPyEndAllowThreads(__tstate);
25719 if (PyErr_Occurred()) SWIG_fail;
25720 }
25721 Py_INCREF(Py_None); resultobj = Py_None;
25722 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25723 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25724 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25725 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25726 return resultobj;
25727 fail:
25728 return NULL;
25729 }
25730
25731
25732 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25733 PyObject *resultobj;
25734 wxWindow *arg1 = (wxWindow *) 0 ;
25735 wxSize result;
25736 PyObject * obj0 = 0 ;
25737 char *kwnames[] = {
25738 (char *) "self", NULL
25739 };
25740
25741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(1)) SWIG_fail;
25744 {
25745 PyThreadState* __tstate = wxPyBeginAllowThreads();
25746 result = ((wxWindow const *)arg1)->GetSize();
25747
25748 wxPyEndAllowThreads(__tstate);
25749 if (PyErr_Occurred()) SWIG_fail;
25750 }
25751 {
25752 wxSize * resultptr;
25753 resultptr = new wxSize((wxSize &)(result));
25754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25755 }
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25763 PyObject *resultobj;
25764 wxWindow *arg1 = (wxWindow *) 0 ;
25765 int *arg2 = (int *) 0 ;
25766 int *arg3 = (int *) 0 ;
25767 int temp2 ;
25768 int res2 = 0 ;
25769 int temp3 ;
25770 int res3 = 0 ;
25771 PyObject * obj0 = 0 ;
25772 char *kwnames[] = {
25773 (char *) "self", NULL
25774 };
25775
25776 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25777 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25780 if (SWIG_arg_fail(1)) SWIG_fail;
25781 {
25782 PyThreadState* __tstate = wxPyBeginAllowThreads();
25783 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25784
25785 wxPyEndAllowThreads(__tstate);
25786 if (PyErr_Occurred()) SWIG_fail;
25787 }
25788 Py_INCREF(Py_None); resultobj = Py_None;
25789 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25790 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25791 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25792 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj;
25801 wxWindow *arg1 = (wxWindow *) 0 ;
25802 wxRect result;
25803 PyObject * obj0 = 0 ;
25804 char *kwnames[] = {
25805 (char *) "self", NULL
25806 };
25807
25808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25810 if (SWIG_arg_fail(1)) SWIG_fail;
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 result = ((wxWindow const *)arg1)->GetRect();
25814
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 wxRect * resultptr;
25820 resultptr = new wxRect((wxRect &)(result));
25821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25830 PyObject *resultobj;
25831 wxWindow *arg1 = (wxWindow *) 0 ;
25832 wxSize result;
25833 PyObject * obj0 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 result = ((wxWindow const *)arg1)->GetClientSize();
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 wxSize * resultptr;
25850 resultptr = new wxSize((wxSize &)(result));
25851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25852 }
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj;
25861 wxWindow *arg1 = (wxWindow *) 0 ;
25862 int *arg2 = (int *) 0 ;
25863 int *arg3 = (int *) 0 ;
25864 int temp2 ;
25865 int res2 = 0 ;
25866 int temp3 ;
25867 int res3 = 0 ;
25868 PyObject * obj0 = 0 ;
25869 char *kwnames[] = {
25870 (char *) "self", NULL
25871 };
25872
25873 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25874 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25877 if (SWIG_arg_fail(1)) SWIG_fail;
25878 {
25879 PyThreadState* __tstate = wxPyBeginAllowThreads();
25880 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25881
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 Py_INCREF(Py_None); resultobj = Py_None;
25886 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25887 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25888 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25889 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25897 PyObject *resultobj;
25898 wxWindow *arg1 = (wxWindow *) 0 ;
25899 wxPoint result;
25900 PyObject * obj0 = 0 ;
25901 char *kwnames[] = {
25902 (char *) "self", NULL
25903 };
25904
25905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25907 if (SWIG_arg_fail(1)) SWIG_fail;
25908 {
25909 PyThreadState* __tstate = wxPyBeginAllowThreads();
25910 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25911
25912 wxPyEndAllowThreads(__tstate);
25913 if (PyErr_Occurred()) SWIG_fail;
25914 }
25915 {
25916 wxPoint * resultptr;
25917 resultptr = new wxPoint((wxPoint &)(result));
25918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25919 }
25920 return resultobj;
25921 fail:
25922 return NULL;
25923 }
25924
25925
25926 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj;
25928 wxWindow *arg1 = (wxWindow *) 0 ;
25929 wxRect result;
25930 PyObject * obj0 = 0 ;
25931 char *kwnames[] = {
25932 (char *) "self", NULL
25933 };
25934
25935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(1)) SWIG_fail;
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 result = ((wxWindow const *)arg1)->GetClientRect();
25941
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 {
25946 wxRect * resultptr;
25947 resultptr = new wxRect((wxRect &)(result));
25948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25949 }
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25957 PyObject *resultobj;
25958 wxWindow *arg1 = (wxWindow *) 0 ;
25959 wxSize result;
25960 PyObject * obj0 = 0 ;
25961 char *kwnames[] = {
25962 (char *) "self", NULL
25963 };
25964
25965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25967 if (SWIG_arg_fail(1)) SWIG_fail;
25968 {
25969 PyThreadState* __tstate = wxPyBeginAllowThreads();
25970 result = ((wxWindow const *)arg1)->GetBestSize();
25971
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 {
25976 wxSize * resultptr;
25977 resultptr = new wxSize((wxSize &)(result));
25978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25979 }
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj;
25988 wxWindow *arg1 = (wxWindow *) 0 ;
25989 int *arg2 = (int *) 0 ;
25990 int *arg3 = (int *) 0 ;
25991 int temp2 ;
25992 int res2 = 0 ;
25993 int temp3 ;
25994 int res3 = 0 ;
25995 PyObject * obj0 = 0 ;
25996 char *kwnames[] = {
25997 (char *) "self", NULL
25998 };
25999
26000 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26001 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26004 if (SWIG_arg_fail(1)) SWIG_fail;
26005 {
26006 PyThreadState* __tstate = wxPyBeginAllowThreads();
26007 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26008
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 Py_INCREF(Py_None); resultobj = Py_None;
26013 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26014 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26015 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26016 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj;
26025 wxWindow *arg1 = (wxWindow *) 0 ;
26026 PyObject * obj0 = 0 ;
26027 char *kwnames[] = {
26028 (char *) "self", NULL
26029 };
26030
26031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26033 if (SWIG_arg_fail(1)) SWIG_fail;
26034 {
26035 PyThreadState* __tstate = wxPyBeginAllowThreads();
26036 (arg1)->InvalidateBestSize();
26037
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 Py_INCREF(Py_None); resultobj = Py_None;
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26049 PyObject *resultobj;
26050 wxWindow *arg1 = (wxWindow *) 0 ;
26051 wxSize result;
26052 PyObject * obj0 = 0 ;
26053 char *kwnames[] = {
26054 (char *) "self", NULL
26055 };
26056
26057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26059 if (SWIG_arg_fail(1)) SWIG_fail;
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26063
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 {
26068 wxSize * resultptr;
26069 resultptr = new wxSize((wxSize &)(result));
26070 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26071 }
26072 return resultobj;
26073 fail:
26074 return NULL;
26075 }
26076
26077
26078 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26079 PyObject *resultobj;
26080 wxWindow *arg1 = (wxWindow *) 0 ;
26081 wxSize result;
26082 PyObject * obj0 = 0 ;
26083 char *kwnames[] = {
26084 (char *) "self", NULL
26085 };
26086
26087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26089 if (SWIG_arg_fail(1)) SWIG_fail;
26090 {
26091 PyThreadState* __tstate = wxPyBeginAllowThreads();
26092 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26093
26094 wxPyEndAllowThreads(__tstate);
26095 if (PyErr_Occurred()) SWIG_fail;
26096 }
26097 {
26098 wxSize * resultptr;
26099 resultptr = new wxSize((wxSize &)(result));
26100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26101 }
26102 return resultobj;
26103 fail:
26104 return NULL;
26105 }
26106
26107
26108 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26109 PyObject *resultobj;
26110 wxWindow *arg1 = (wxWindow *) 0 ;
26111 int arg2 = (int) wxBOTH ;
26112 PyObject * obj0 = 0 ;
26113 PyObject * obj1 = 0 ;
26114 char *kwnames[] = {
26115 (char *) "self",(char *) "direction", NULL
26116 };
26117
26118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26120 if (SWIG_arg_fail(1)) SWIG_fail;
26121 if (obj1) {
26122 {
26123 arg2 = (int)(SWIG_As_int(obj1));
26124 if (SWIG_arg_fail(2)) SWIG_fail;
26125 }
26126 }
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 (arg1)->Center(arg2);
26130
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 Py_INCREF(Py_None); resultobj = Py_None;
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26142 PyObject *resultobj;
26143 wxWindow *arg1 = (wxWindow *) 0 ;
26144 int arg2 = (int) wxBOTH ;
26145 PyObject * obj0 = 0 ;
26146 PyObject * obj1 = 0 ;
26147 char *kwnames[] = {
26148 (char *) "self",(char *) "dir", NULL
26149 };
26150
26151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26153 if (SWIG_arg_fail(1)) SWIG_fail;
26154 if (obj1) {
26155 {
26156 arg2 = (int)(SWIG_As_int(obj1));
26157 if (SWIG_arg_fail(2)) SWIG_fail;
26158 }
26159 }
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 (arg1)->CenterOnScreen(arg2);
26163
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 Py_INCREF(Py_None); resultobj = Py_None;
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj;
26176 wxWindow *arg1 = (wxWindow *) 0 ;
26177 int arg2 = (int) wxBOTH ;
26178 PyObject * obj0 = 0 ;
26179 PyObject * obj1 = 0 ;
26180 char *kwnames[] = {
26181 (char *) "self",(char *) "dir", NULL
26182 };
26183
26184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26186 if (SWIG_arg_fail(1)) SWIG_fail;
26187 if (obj1) {
26188 {
26189 arg2 = (int)(SWIG_As_int(obj1));
26190 if (SWIG_arg_fail(2)) SWIG_fail;
26191 }
26192 }
26193 {
26194 PyThreadState* __tstate = wxPyBeginAllowThreads();
26195 (arg1)->CenterOnParent(arg2);
26196
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 Py_INCREF(Py_None); resultobj = Py_None;
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26208 PyObject *resultobj;
26209 wxWindow *arg1 = (wxWindow *) 0 ;
26210 PyObject * obj0 = 0 ;
26211 char *kwnames[] = {
26212 (char *) "self", NULL
26213 };
26214
26215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26217 if (SWIG_arg_fail(1)) SWIG_fail;
26218 {
26219 PyThreadState* __tstate = wxPyBeginAllowThreads();
26220 (arg1)->Fit();
26221
26222 wxPyEndAllowThreads(__tstate);
26223 if (PyErr_Occurred()) SWIG_fail;
26224 }
26225 Py_INCREF(Py_None); resultobj = Py_None;
26226 return resultobj;
26227 fail:
26228 return NULL;
26229 }
26230
26231
26232 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26233 PyObject *resultobj;
26234 wxWindow *arg1 = (wxWindow *) 0 ;
26235 PyObject * obj0 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 (arg1)->FitInside();
26246
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 Py_INCREF(Py_None); resultobj = Py_None;
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26258 PyObject *resultobj;
26259 wxWindow *arg1 = (wxWindow *) 0 ;
26260 int arg2 ;
26261 int arg3 ;
26262 int arg4 = (int) -1 ;
26263 int arg5 = (int) -1 ;
26264 int arg6 = (int) -1 ;
26265 int arg7 = (int) -1 ;
26266 PyObject * obj0 = 0 ;
26267 PyObject * obj1 = 0 ;
26268 PyObject * obj2 = 0 ;
26269 PyObject * obj3 = 0 ;
26270 PyObject * obj4 = 0 ;
26271 PyObject * obj5 = 0 ;
26272 PyObject * obj6 = 0 ;
26273 char *kwnames[] = {
26274 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26275 };
26276
26277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26279 if (SWIG_arg_fail(1)) SWIG_fail;
26280 {
26281 arg2 = (int)(SWIG_As_int(obj1));
26282 if (SWIG_arg_fail(2)) SWIG_fail;
26283 }
26284 {
26285 arg3 = (int)(SWIG_As_int(obj2));
26286 if (SWIG_arg_fail(3)) SWIG_fail;
26287 }
26288 if (obj3) {
26289 {
26290 arg4 = (int)(SWIG_As_int(obj3));
26291 if (SWIG_arg_fail(4)) SWIG_fail;
26292 }
26293 }
26294 if (obj4) {
26295 {
26296 arg5 = (int)(SWIG_As_int(obj4));
26297 if (SWIG_arg_fail(5)) SWIG_fail;
26298 }
26299 }
26300 if (obj5) {
26301 {
26302 arg6 = (int)(SWIG_As_int(obj5));
26303 if (SWIG_arg_fail(6)) SWIG_fail;
26304 }
26305 }
26306 if (obj6) {
26307 {
26308 arg7 = (int)(SWIG_As_int(obj6));
26309 if (SWIG_arg_fail(7)) SWIG_fail;
26310 }
26311 }
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26315
26316 wxPyEndAllowThreads(__tstate);
26317 if (PyErr_Occurred()) SWIG_fail;
26318 }
26319 Py_INCREF(Py_None); resultobj = Py_None;
26320 return resultobj;
26321 fail:
26322 return NULL;
26323 }
26324
26325
26326 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26327 PyObject *resultobj;
26328 wxWindow *arg1 = (wxWindow *) 0 ;
26329 wxSize *arg2 = 0 ;
26330 wxSize const &arg3_defvalue = wxDefaultSize ;
26331 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26332 wxSize const &arg4_defvalue = wxDefaultSize ;
26333 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26334 wxSize temp2 ;
26335 wxSize temp3 ;
26336 wxSize temp4 ;
26337 PyObject * obj0 = 0 ;
26338 PyObject * obj1 = 0 ;
26339 PyObject * obj2 = 0 ;
26340 PyObject * obj3 = 0 ;
26341 char *kwnames[] = {
26342 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26343 };
26344
26345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26347 if (SWIG_arg_fail(1)) SWIG_fail;
26348 {
26349 arg2 = &temp2;
26350 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26351 }
26352 if (obj2) {
26353 {
26354 arg3 = &temp3;
26355 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26356 }
26357 }
26358 if (obj3) {
26359 {
26360 arg4 = &temp4;
26361 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26362 }
26363 }
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26367
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 Py_INCREF(Py_None); resultobj = Py_None;
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26379 PyObject *resultobj;
26380 wxWindow *arg1 = (wxWindow *) 0 ;
26381 int arg2 ;
26382 int arg3 ;
26383 int arg4 = (int) -1 ;
26384 int arg5 = (int) -1 ;
26385 PyObject * obj0 = 0 ;
26386 PyObject * obj1 = 0 ;
26387 PyObject * obj2 = 0 ;
26388 PyObject * obj3 = 0 ;
26389 PyObject * obj4 = 0 ;
26390 char *kwnames[] = {
26391 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26392 };
26393
26394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26396 if (SWIG_arg_fail(1)) SWIG_fail;
26397 {
26398 arg2 = (int)(SWIG_As_int(obj1));
26399 if (SWIG_arg_fail(2)) SWIG_fail;
26400 }
26401 {
26402 arg3 = (int)(SWIG_As_int(obj2));
26403 if (SWIG_arg_fail(3)) SWIG_fail;
26404 }
26405 if (obj3) {
26406 {
26407 arg4 = (int)(SWIG_As_int(obj3));
26408 if (SWIG_arg_fail(4)) SWIG_fail;
26409 }
26410 }
26411 if (obj4) {
26412 {
26413 arg5 = (int)(SWIG_As_int(obj4));
26414 if (SWIG_arg_fail(5)) SWIG_fail;
26415 }
26416 }
26417 {
26418 PyThreadState* __tstate = wxPyBeginAllowThreads();
26419 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26420
26421 wxPyEndAllowThreads(__tstate);
26422 if (PyErr_Occurred()) SWIG_fail;
26423 }
26424 Py_INCREF(Py_None); resultobj = Py_None;
26425 return resultobj;
26426 fail:
26427 return NULL;
26428 }
26429
26430
26431 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26432 PyObject *resultobj;
26433 wxWindow *arg1 = (wxWindow *) 0 ;
26434 wxSize *arg2 = 0 ;
26435 wxSize const &arg3_defvalue = wxDefaultSize ;
26436 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26437 wxSize temp2 ;
26438 wxSize temp3 ;
26439 PyObject * obj0 = 0 ;
26440 PyObject * obj1 = 0 ;
26441 PyObject * obj2 = 0 ;
26442 char *kwnames[] = {
26443 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26444 };
26445
26446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) 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 {
26450 arg2 = &temp2;
26451 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26452 }
26453 if (obj2) {
26454 {
26455 arg3 = &temp3;
26456 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26457 }
26458 }
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26462
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 Py_INCREF(Py_None); resultobj = Py_None;
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj;
26475 wxWindow *arg1 = (wxWindow *) 0 ;
26476 wxSize result;
26477 PyObject * obj0 = 0 ;
26478 char *kwnames[] = {
26479 (char *) "self", NULL
26480 };
26481
26482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26484 if (SWIG_arg_fail(1)) SWIG_fail;
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 result = ((wxWindow const *)arg1)->GetMaxSize();
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 {
26493 wxSize * resultptr;
26494 resultptr = new wxSize((wxSize &)(result));
26495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26496 }
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26504 PyObject *resultobj;
26505 wxWindow *arg1 = (wxWindow *) 0 ;
26506 wxSize result;
26507 PyObject * obj0 = 0 ;
26508 char *kwnames[] = {
26509 (char *) "self", NULL
26510 };
26511
26512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26514 if (SWIG_arg_fail(1)) SWIG_fail;
26515 {
26516 PyThreadState* __tstate = wxPyBeginAllowThreads();
26517 result = ((wxWindow const *)arg1)->GetMinSize();
26518
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 {
26523 wxSize * resultptr;
26524 resultptr = new wxSize((wxSize &)(result));
26525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26526 }
26527 return resultobj;
26528 fail:
26529 return NULL;
26530 }
26531
26532
26533 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26534 PyObject *resultobj;
26535 wxWindow *arg1 = (wxWindow *) 0 ;
26536 wxSize *arg2 = 0 ;
26537 wxSize temp2 ;
26538 PyObject * obj0 = 0 ;
26539 PyObject * obj1 = 0 ;
26540 char *kwnames[] = {
26541 (char *) "self",(char *) "minSize", NULL
26542 };
26543
26544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26546 if (SWIG_arg_fail(1)) SWIG_fail;
26547 {
26548 arg2 = &temp2;
26549 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 (arg1)->SetMinSize((wxSize const &)*arg2);
26554
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 Py_INCREF(Py_None); resultobj = Py_None;
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26566 PyObject *resultobj;
26567 wxWindow *arg1 = (wxWindow *) 0 ;
26568 wxSize *arg2 = 0 ;
26569 wxSize temp2 ;
26570 PyObject * obj0 = 0 ;
26571 PyObject * obj1 = 0 ;
26572 char *kwnames[] = {
26573 (char *) "self",(char *) "maxSize", NULL
26574 };
26575
26576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26578 if (SWIG_arg_fail(1)) SWIG_fail;
26579 {
26580 arg2 = &temp2;
26581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26582 }
26583 {
26584 PyThreadState* __tstate = wxPyBeginAllowThreads();
26585 (arg1)->SetMaxSize((wxSize const &)*arg2);
26586
26587 wxPyEndAllowThreads(__tstate);
26588 if (PyErr_Occurred()) SWIG_fail;
26589 }
26590 Py_INCREF(Py_None); resultobj = Py_None;
26591 return resultobj;
26592 fail:
26593 return NULL;
26594 }
26595
26596
26597 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26598 PyObject *resultobj;
26599 wxWindow *arg1 = (wxWindow *) 0 ;
26600 int result;
26601 PyObject * obj0 = 0 ;
26602 char *kwnames[] = {
26603 (char *) "self", NULL
26604 };
26605
26606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26608 if (SWIG_arg_fail(1)) SWIG_fail;
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 {
26617 resultobj = SWIG_From_int((int)(result));
26618 }
26619 return resultobj;
26620 fail:
26621 return NULL;
26622 }
26623
26624
26625 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26626 PyObject *resultobj;
26627 wxWindow *arg1 = (wxWindow *) 0 ;
26628 int result;
26629 PyObject * obj0 = 0 ;
26630 char *kwnames[] = {
26631 (char *) "self", NULL
26632 };
26633
26634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26636 if (SWIG_arg_fail(1)) SWIG_fail;
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26640
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 {
26645 resultobj = SWIG_From_int((int)(result));
26646 }
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj;
26655 wxWindow *arg1 = (wxWindow *) 0 ;
26656 int result;
26657 PyObject * obj0 = 0 ;
26658 char *kwnames[] = {
26659 (char *) "self", NULL
26660 };
26661
26662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26664 if (SWIG_arg_fail(1)) SWIG_fail;
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26668
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 {
26673 resultobj = SWIG_From_int((int)(result));
26674 }
26675 return resultobj;
26676 fail:
26677 return NULL;
26678 }
26679
26680
26681 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26682 PyObject *resultobj;
26683 wxWindow *arg1 = (wxWindow *) 0 ;
26684 int result;
26685 PyObject * obj0 = 0 ;
26686 char *kwnames[] = {
26687 (char *) "self", NULL
26688 };
26689
26690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26692 if (SWIG_arg_fail(1)) SWIG_fail;
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26696
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 {
26701 resultobj = SWIG_From_int((int)(result));
26702 }
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26710 PyObject *resultobj;
26711 wxWindow *arg1 = (wxWindow *) 0 ;
26712 wxSize *arg2 = 0 ;
26713 wxSize temp2 ;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716 char *kwnames[] = {
26717 (char *) "self",(char *) "size", NULL
26718 };
26719
26720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26722 if (SWIG_arg_fail(1)) SWIG_fail;
26723 {
26724 arg2 = &temp2;
26725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26726 }
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26730
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 Py_INCREF(Py_None); resultobj = Py_None;
26735 return resultobj;
26736 fail:
26737 return NULL;
26738 }
26739
26740
26741 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26742 PyObject *resultobj;
26743 wxWindow *arg1 = (wxWindow *) 0 ;
26744 int arg2 ;
26745 int arg3 ;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 PyObject * obj2 = 0 ;
26749 char *kwnames[] = {
26750 (char *) "self",(char *) "w",(char *) "h", NULL
26751 };
26752
26753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26755 if (SWIG_arg_fail(1)) SWIG_fail;
26756 {
26757 arg2 = (int)(SWIG_As_int(obj1));
26758 if (SWIG_arg_fail(2)) SWIG_fail;
26759 }
26760 {
26761 arg3 = (int)(SWIG_As_int(obj2));
26762 if (SWIG_arg_fail(3)) SWIG_fail;
26763 }
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 (arg1)->SetVirtualSize(arg2,arg3);
26767
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 Py_INCREF(Py_None); resultobj = Py_None;
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26779 PyObject *resultobj;
26780 wxWindow *arg1 = (wxWindow *) 0 ;
26781 wxSize result;
26782 PyObject * obj0 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self", NULL
26785 };
26786
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 result = ((wxWindow const *)arg1)->GetVirtualSize();
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 {
26798 wxSize * resultptr;
26799 resultptr = new wxSize((wxSize &)(result));
26800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26801 }
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj;
26810 wxWindow *arg1 = (wxWindow *) 0 ;
26811 int *arg2 = (int *) 0 ;
26812 int *arg3 = (int *) 0 ;
26813 int temp2 ;
26814 int res2 = 0 ;
26815 int temp3 ;
26816 int res3 = 0 ;
26817 PyObject * obj0 = 0 ;
26818 char *kwnames[] = {
26819 (char *) "self", NULL
26820 };
26821
26822 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26823 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26826 if (SWIG_arg_fail(1)) SWIG_fail;
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 Py_INCREF(Py_None); resultobj = Py_None;
26835 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26836 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26837 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26838 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26839 return resultobj;
26840 fail:
26841 return NULL;
26842 }
26843
26844
26845 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj;
26847 wxWindow *arg1 = (wxWindow *) 0 ;
26848 wxSize result;
26849 PyObject * obj0 = 0 ;
26850 char *kwnames[] = {
26851 (char *) "self", NULL
26852 };
26853
26854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26856 if (SWIG_arg_fail(1)) SWIG_fail;
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26860
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 {
26865 wxSize * resultptr;
26866 resultptr = new wxSize((wxSize &)(result));
26867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26868 }
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26876 PyObject *resultobj;
26877 wxWindow *arg1 = (wxWindow *) 0 ;
26878 bool arg2 = (bool) true ;
26879 bool result;
26880 PyObject * obj0 = 0 ;
26881 PyObject * obj1 = 0 ;
26882 char *kwnames[] = {
26883 (char *) "self",(char *) "show", NULL
26884 };
26885
26886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26888 if (SWIG_arg_fail(1)) SWIG_fail;
26889 if (obj1) {
26890 {
26891 arg2 = (bool)(SWIG_As_bool(obj1));
26892 if (SWIG_arg_fail(2)) SWIG_fail;
26893 }
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 result = (bool)(arg1)->Show(arg2);
26898
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 {
26903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26904 }
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 bool result;
26915 PyObject * obj0 = 0 ;
26916 char *kwnames[] = {
26917 (char *) "self", NULL
26918 };
26919
26920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26922 if (SWIG_arg_fail(1)) SWIG_fail;
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (bool)(arg1)->Hide();
26926
26927 wxPyEndAllowThreads(__tstate);
26928 if (PyErr_Occurred()) SWIG_fail;
26929 }
26930 {
26931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26932 }
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26940 PyObject *resultobj;
26941 wxWindow *arg1 = (wxWindow *) 0 ;
26942 bool arg2 = (bool) true ;
26943 bool result;
26944 PyObject * obj0 = 0 ;
26945 PyObject * obj1 = 0 ;
26946 char *kwnames[] = {
26947 (char *) "self",(char *) "enable", NULL
26948 };
26949
26950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26952 if (SWIG_arg_fail(1)) SWIG_fail;
26953 if (obj1) {
26954 {
26955 arg2 = (bool)(SWIG_As_bool(obj1));
26956 if (SWIG_arg_fail(2)) SWIG_fail;
26957 }
26958 }
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (bool)(arg1)->Enable(arg2);
26962
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 {
26967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26968 }
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj;
26977 wxWindow *arg1 = (wxWindow *) 0 ;
26978 bool result;
26979 PyObject * obj0 = 0 ;
26980 char *kwnames[] = {
26981 (char *) "self", NULL
26982 };
26983
26984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26986 if (SWIG_arg_fail(1)) SWIG_fail;
26987 {
26988 PyThreadState* __tstate = wxPyBeginAllowThreads();
26989 result = (bool)(arg1)->Disable();
26990
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 {
26995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26996 }
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27004 PyObject *resultobj;
27005 wxWindow *arg1 = (wxWindow *) 0 ;
27006 bool result;
27007 PyObject * obj0 = 0 ;
27008 char *kwnames[] = {
27009 (char *) "self", NULL
27010 };
27011
27012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27014 if (SWIG_arg_fail(1)) SWIG_fail;
27015 {
27016 PyThreadState* __tstate = wxPyBeginAllowThreads();
27017 result = (bool)((wxWindow const *)arg1)->IsShown();
27018
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 {
27023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27024 }
27025 return resultobj;
27026 fail:
27027 return NULL;
27028 }
27029
27030
27031 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27032 PyObject *resultobj;
27033 wxWindow *arg1 = (wxWindow *) 0 ;
27034 bool result;
27035 PyObject * obj0 = 0 ;
27036 char *kwnames[] = {
27037 (char *) "self", NULL
27038 };
27039
27040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27042 if (SWIG_arg_fail(1)) SWIG_fail;
27043 {
27044 PyThreadState* __tstate = wxPyBeginAllowThreads();
27045 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27046
27047 wxPyEndAllowThreads(__tstate);
27048 if (PyErr_Occurred()) SWIG_fail;
27049 }
27050 {
27051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27052 }
27053 return resultobj;
27054 fail:
27055 return NULL;
27056 }
27057
27058
27059 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27060 PyObject *resultobj;
27061 wxWindow *arg1 = (wxWindow *) 0 ;
27062 long arg2 ;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 char *kwnames[] = {
27066 (char *) "self",(char *) "style", NULL
27067 };
27068
27069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27071 if (SWIG_arg_fail(1)) SWIG_fail;
27072 {
27073 arg2 = (long)(SWIG_As_long(obj1));
27074 if (SWIG_arg_fail(2)) SWIG_fail;
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 (arg1)->SetWindowStyleFlag(arg2);
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 Py_INCREF(Py_None); resultobj = Py_None;
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj;
27092 wxWindow *arg1 = (wxWindow *) 0 ;
27093 long result;
27094 PyObject * obj0 = 0 ;
27095 char *kwnames[] = {
27096 (char *) "self", NULL
27097 };
27098
27099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27101 if (SWIG_arg_fail(1)) SWIG_fail;
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27105
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 {
27110 resultobj = SWIG_From_long((long)(result));
27111 }
27112 return resultobj;
27113 fail:
27114 return NULL;
27115 }
27116
27117
27118 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27119 PyObject *resultobj;
27120 wxWindow *arg1 = (wxWindow *) 0 ;
27121 int arg2 ;
27122 bool result;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char *kwnames[] = {
27126 (char *) "self",(char *) "flag", NULL
27127 };
27128
27129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27131 if (SWIG_arg_fail(1)) SWIG_fail;
27132 {
27133 arg2 = (int)(SWIG_As_int(obj1));
27134 if (SWIG_arg_fail(2)) SWIG_fail;
27135 }
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj;
27154 wxWindow *arg1 = (wxWindow *) 0 ;
27155 bool result;
27156 PyObject * obj0 = 0 ;
27157 char *kwnames[] = {
27158 (char *) "self", NULL
27159 };
27160
27161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(1)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (bool)((wxWindow const *)arg1)->IsRetained();
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxWindow *arg1 = (wxWindow *) 0 ;
27183 long arg2 ;
27184 PyObject * obj0 = 0 ;
27185 PyObject * obj1 = 0 ;
27186 char *kwnames[] = {
27187 (char *) "self",(char *) "exStyle", NULL
27188 };
27189
27190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27192 if (SWIG_arg_fail(1)) SWIG_fail;
27193 {
27194 arg2 = (long)(SWIG_As_long(obj1));
27195 if (SWIG_arg_fail(2)) SWIG_fail;
27196 }
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 (arg1)->SetExtraStyle(arg2);
27200
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 Py_INCREF(Py_None); resultobj = Py_None;
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj;
27213 wxWindow *arg1 = (wxWindow *) 0 ;
27214 long result;
27215 PyObject * obj0 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self", NULL
27218 };
27219
27220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27222 if (SWIG_arg_fail(1)) SWIG_fail;
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27226
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 {
27231 resultobj = SWIG_From_long((long)(result));
27232 }
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj;
27241 wxWindow *arg1 = (wxWindow *) 0 ;
27242 bool arg2 = (bool) true ;
27243 PyObject * obj0 = 0 ;
27244 PyObject * obj1 = 0 ;
27245 char *kwnames[] = {
27246 (char *) "self",(char *) "modal", NULL
27247 };
27248
27249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27251 if (SWIG_arg_fail(1)) SWIG_fail;
27252 if (obj1) {
27253 {
27254 arg2 = (bool)(SWIG_As_bool(obj1));
27255 if (SWIG_arg_fail(2)) SWIG_fail;
27256 }
27257 }
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 (arg1)->MakeModal(arg2);
27261
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 Py_INCREF(Py_None); resultobj = Py_None;
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27273 PyObject *resultobj;
27274 wxWindow *arg1 = (wxWindow *) 0 ;
27275 bool arg2 ;
27276 PyObject * obj0 = 0 ;
27277 PyObject * obj1 = 0 ;
27278 char *kwnames[] = {
27279 (char *) "self",(char *) "enableTheme", NULL
27280 };
27281
27282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27284 if (SWIG_arg_fail(1)) SWIG_fail;
27285 {
27286 arg2 = (bool)(SWIG_As_bool(obj1));
27287 if (SWIG_arg_fail(2)) SWIG_fail;
27288 }
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 (arg1)->SetThemeEnabled(arg2);
27292
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 Py_INCREF(Py_None); resultobj = Py_None;
27297 return resultobj;
27298 fail:
27299 return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxWindow *arg1 = (wxWindow *) 0 ;
27306 bool result;
27307 PyObject * obj0 = 0 ;
27308 char *kwnames[] = {
27309 (char *) "self", NULL
27310 };
27311
27312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27314 if (SWIG_arg_fail(1)) SWIG_fail;
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27318
27319 wxPyEndAllowThreads(__tstate);
27320 if (PyErr_Occurred()) SWIG_fail;
27321 }
27322 {
27323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27324 }
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj;
27333 wxWindow *arg1 = (wxWindow *) 0 ;
27334 PyObject * obj0 = 0 ;
27335 char *kwnames[] = {
27336 (char *) "self", NULL
27337 };
27338
27339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27341 if (SWIG_arg_fail(1)) SWIG_fail;
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 (arg1)->SetFocus();
27345
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 Py_INCREF(Py_None); resultobj = Py_None;
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27357 PyObject *resultobj;
27358 wxWindow *arg1 = (wxWindow *) 0 ;
27359 PyObject * obj0 = 0 ;
27360 char *kwnames[] = {
27361 (char *) "self", NULL
27362 };
27363
27364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27366 if (SWIG_arg_fail(1)) SWIG_fail;
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 (arg1)->SetFocusFromKbd();
27370
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 Py_INCREF(Py_None); resultobj = Py_None;
27375 return resultobj;
27376 fail:
27377 return NULL;
27378 }
27379
27380
27381 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27382 PyObject *resultobj;
27383 wxWindow *result;
27384 char *kwnames[] = {
27385 NULL
27386 };
27387
27388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27389 {
27390 if (!wxPyCheckForApp()) SWIG_fail;
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = (wxWindow *)wxWindow::FindFocus();
27393
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 {
27398 resultobj = wxPyMake_wxObject(result, 0);
27399 }
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj;
27408 wxWindow *arg1 = (wxWindow *) 0 ;
27409 bool result;
27410 PyObject * obj0 = 0 ;
27411 char *kwnames[] = {
27412 (char *) "self", NULL
27413 };
27414
27415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27417 if (SWIG_arg_fail(1)) SWIG_fail;
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27421
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 {
27426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27427 }
27428 return resultobj;
27429 fail:
27430 return NULL;
27431 }
27432
27433
27434 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27435 PyObject *resultobj;
27436 wxWindow *arg1 = (wxWindow *) 0 ;
27437 bool result;
27438 PyObject * obj0 = 0 ;
27439 char *kwnames[] = {
27440 (char *) "self", NULL
27441 };
27442
27443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27445 if (SWIG_arg_fail(1)) SWIG_fail;
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27449
27450 wxPyEndAllowThreads(__tstate);
27451 if (PyErr_Occurred()) SWIG_fail;
27452 }
27453 {
27454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27455 }
27456 return resultobj;
27457 fail:
27458 return NULL;
27459 }
27460
27461
27462 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27463 PyObject *resultobj;
27464 wxWindow *arg1 = (wxWindow *) 0 ;
27465 wxWindow *result;
27466 PyObject * obj0 = 0 ;
27467 char *kwnames[] = {
27468 (char *) "self", NULL
27469 };
27470
27471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27473 if (SWIG_arg_fail(1)) SWIG_fail;
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27477
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 {
27482 resultobj = wxPyMake_wxObject(result, 0);
27483 }
27484 return resultobj;
27485 fail:
27486 return NULL;
27487 }
27488
27489
27490 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27491 PyObject *resultobj;
27492 wxWindow *arg1 = (wxWindow *) 0 ;
27493 wxWindow *arg2 = (wxWindow *) 0 ;
27494 wxWindow *result;
27495 PyObject * obj0 = 0 ;
27496 PyObject * obj1 = 0 ;
27497 char *kwnames[] = {
27498 (char *) "self",(char *) "child", NULL
27499 };
27500
27501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27505 if (SWIG_arg_fail(2)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 {
27514 resultobj = wxPyMake_wxObject(result, 0);
27515 }
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj;
27524 wxWindow *arg1 = (wxWindow *) 0 ;
27525 wxWindow *arg2 = (wxWindow *) 0 ;
27526 PyObject * obj0 = 0 ;
27527 PyObject * obj1 = 0 ;
27528 char *kwnames[] = {
27529 (char *) "self",(char *) "win", NULL
27530 };
27531
27532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27534 if (SWIG_arg_fail(1)) SWIG_fail;
27535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27536 if (SWIG_arg_fail(2)) SWIG_fail;
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 (arg1)->SetTmpDefaultItem(arg2);
27540
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 Py_INCREF(Py_None); resultobj = Py_None;
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27552 PyObject *resultobj;
27553 wxWindow *arg1 = (wxWindow *) 0 ;
27554 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27555 bool result;
27556 PyObject * obj0 = 0 ;
27557 PyObject * obj1 = 0 ;
27558 char *kwnames[] = {
27559 (char *) "self",(char *) "flags", NULL
27560 };
27561
27562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(1)) SWIG_fail;
27565 if (obj1) {
27566 {
27567 arg2 = (int)(SWIG_As_int(obj1));
27568 if (SWIG_arg_fail(2)) SWIG_fail;
27569 }
27570 }
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = (bool)(arg1)->Navigate(arg2);
27574
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 {
27579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27580 }
27581 return resultobj;
27582 fail:
27583 return NULL;
27584 }
27585
27586
27587 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27588 PyObject *resultobj;
27589 wxWindow *arg1 = (wxWindow *) 0 ;
27590 wxWindow *arg2 = (wxWindow *) 0 ;
27591 PyObject * obj0 = 0 ;
27592 PyObject * obj1 = 0 ;
27593 char *kwnames[] = {
27594 (char *) "self",(char *) "win", NULL
27595 };
27596
27597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27599 if (SWIG_arg_fail(1)) SWIG_fail;
27600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27601 if (SWIG_arg_fail(2)) SWIG_fail;
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 (arg1)->MoveAfterInTabOrder(arg2);
27605
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 Py_INCREF(Py_None); resultobj = Py_None;
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27617 PyObject *resultobj;
27618 wxWindow *arg1 = (wxWindow *) 0 ;
27619 wxWindow *arg2 = (wxWindow *) 0 ;
27620 PyObject * obj0 = 0 ;
27621 PyObject * obj1 = 0 ;
27622 char *kwnames[] = {
27623 (char *) "self",(char *) "win", NULL
27624 };
27625
27626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(2)) SWIG_fail;
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 (arg1)->MoveBeforeInTabOrder(arg2);
27634
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 Py_INCREF(Py_None); resultobj = Py_None;
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27646 PyObject *resultobj;
27647 wxWindow *arg1 = (wxWindow *) 0 ;
27648 PyObject *result;
27649 PyObject * obj0 = 0 ;
27650 char *kwnames[] = {
27651 (char *) "self", NULL
27652 };
27653
27654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27656 if (SWIG_arg_fail(1)) SWIG_fail;
27657 {
27658 PyThreadState* __tstate = wxPyBeginAllowThreads();
27659 result = (PyObject *)wxWindow_GetChildren(arg1);
27660
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 resultobj = result;
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27672 PyObject *resultobj;
27673 wxWindow *arg1 = (wxWindow *) 0 ;
27674 wxWindow *result;
27675 PyObject * obj0 = 0 ;
27676 char *kwnames[] = {
27677 (char *) "self", NULL
27678 };
27679
27680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27682 if (SWIG_arg_fail(1)) SWIG_fail;
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27686
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 {
27691 resultobj = wxPyMake_wxObject(result, 0);
27692 }
27693 return resultobj;
27694 fail:
27695 return NULL;
27696 }
27697
27698
27699 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27700 PyObject *resultobj;
27701 wxWindow *arg1 = (wxWindow *) 0 ;
27702 wxWindow *result;
27703 PyObject * obj0 = 0 ;
27704 char *kwnames[] = {
27705 (char *) "self", NULL
27706 };
27707
27708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(1)) SWIG_fail;
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 {
27719 resultobj = wxPyMake_wxObject(result, 0);
27720 }
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxWindow *arg1 = (wxWindow *) 0 ;
27730 bool result;
27731 PyObject * obj0 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "self", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27738 if (SWIG_arg_fail(1)) SWIG_fail;
27739 {
27740 PyThreadState* __tstate = wxPyBeginAllowThreads();
27741 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27742
27743 wxPyEndAllowThreads(__tstate);
27744 if (PyErr_Occurred()) SWIG_fail;
27745 }
27746 {
27747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27748 }
27749 return resultobj;
27750 fail:
27751 return NULL;
27752 }
27753
27754
27755 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27756 PyObject *resultobj;
27757 wxWindow *arg1 = (wxWindow *) 0 ;
27758 wxWindow *arg2 = (wxWindow *) 0 ;
27759 bool result;
27760 PyObject * obj0 = 0 ;
27761 PyObject * obj1 = 0 ;
27762 char *kwnames[] = {
27763 (char *) "self",(char *) "newParent", NULL
27764 };
27765
27766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27768 if (SWIG_arg_fail(1)) SWIG_fail;
27769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27770 if (SWIG_arg_fail(2)) SWIG_fail;
27771 {
27772 PyThreadState* __tstate = wxPyBeginAllowThreads();
27773 result = (bool)(arg1)->Reparent(arg2);
27774
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 {
27779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27780 }
27781 return resultobj;
27782 fail:
27783 return NULL;
27784 }
27785
27786
27787 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27788 PyObject *resultobj;
27789 wxWindow *arg1 = (wxWindow *) 0 ;
27790 wxWindow *arg2 = (wxWindow *) 0 ;
27791 PyObject * obj0 = 0 ;
27792 PyObject * obj1 = 0 ;
27793 char *kwnames[] = {
27794 (char *) "self",(char *) "child", NULL
27795 };
27796
27797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27799 if (SWIG_arg_fail(1)) SWIG_fail;
27800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27801 if (SWIG_arg_fail(2)) SWIG_fail;
27802 {
27803 PyThreadState* __tstate = wxPyBeginAllowThreads();
27804 (arg1)->AddChild(arg2);
27805
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 Py_INCREF(Py_None); resultobj = Py_None;
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj;
27818 wxWindow *arg1 = (wxWindow *) 0 ;
27819 wxWindow *arg2 = (wxWindow *) 0 ;
27820 PyObject * obj0 = 0 ;
27821 PyObject * obj1 = 0 ;
27822 char *kwnames[] = {
27823 (char *) "self",(char *) "child", NULL
27824 };
27825
27826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27828 if (SWIG_arg_fail(1)) SWIG_fail;
27829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(2)) SWIG_fail;
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 (arg1)->RemoveChild(arg2);
27834
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 Py_INCREF(Py_None); resultobj = Py_None;
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27846 PyObject *resultobj;
27847 wxWindow *arg1 = (wxWindow *) 0 ;
27848 long arg2 ;
27849 wxWindow *result;
27850 PyObject * obj0 = 0 ;
27851 PyObject * obj1 = 0 ;
27852 char *kwnames[] = {
27853 (char *) "self",(char *) "winid", NULL
27854 };
27855
27856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27858 if (SWIG_arg_fail(1)) SWIG_fail;
27859 {
27860 arg2 = (long)(SWIG_As_long(obj1));
27861 if (SWIG_arg_fail(2)) SWIG_fail;
27862 }
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 result = (wxWindow *)(arg1)->FindWindow(arg2);
27866
27867 wxPyEndAllowThreads(__tstate);
27868 if (PyErr_Occurred()) SWIG_fail;
27869 }
27870 {
27871 resultobj = wxPyMake_wxObject(result, 0);
27872 }
27873 return resultobj;
27874 fail:
27875 return NULL;
27876 }
27877
27878
27879 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27880 PyObject *resultobj;
27881 wxWindow *arg1 = (wxWindow *) 0 ;
27882 wxString *arg2 = 0 ;
27883 wxWindow *result;
27884 bool temp2 = false ;
27885 PyObject * obj0 = 0 ;
27886 PyObject * obj1 = 0 ;
27887 char *kwnames[] = {
27888 (char *) "self",(char *) "name", NULL
27889 };
27890
27891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27893 if (SWIG_arg_fail(1)) SWIG_fail;
27894 {
27895 arg2 = wxString_in_helper(obj1);
27896 if (arg2 == NULL) SWIG_fail;
27897 temp2 = true;
27898 }
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27902
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = wxPyMake_wxObject(result, 0);
27908 }
27909 {
27910 if (temp2)
27911 delete arg2;
27912 }
27913 return resultobj;
27914 fail:
27915 {
27916 if (temp2)
27917 delete arg2;
27918 }
27919 return NULL;
27920 }
27921
27922
27923 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27924 PyObject *resultobj;
27925 wxWindow *arg1 = (wxWindow *) 0 ;
27926 wxEvtHandler *result;
27927 PyObject * obj0 = 0 ;
27928 char *kwnames[] = {
27929 (char *) "self", NULL
27930 };
27931
27932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27934 if (SWIG_arg_fail(1)) SWIG_fail;
27935 {
27936 PyThreadState* __tstate = wxPyBeginAllowThreads();
27937 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27938
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 {
27943 resultobj = wxPyMake_wxObject(result, 0);
27944 }
27945 return resultobj;
27946 fail:
27947 return NULL;
27948 }
27949
27950
27951 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27952 PyObject *resultobj;
27953 wxWindow *arg1 = (wxWindow *) 0 ;
27954 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27955 PyObject * obj0 = 0 ;
27956 PyObject * obj1 = 0 ;
27957 char *kwnames[] = {
27958 (char *) "self",(char *) "handler", NULL
27959 };
27960
27961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27963 if (SWIG_arg_fail(1)) SWIG_fail;
27964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27965 if (SWIG_arg_fail(2)) SWIG_fail;
27966 {
27967 PyThreadState* __tstate = wxPyBeginAllowThreads();
27968 (arg1)->SetEventHandler(arg2);
27969
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 Py_INCREF(Py_None); resultobj = Py_None;
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj;
27982 wxWindow *arg1 = (wxWindow *) 0 ;
27983 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27984 PyObject * obj0 = 0 ;
27985 PyObject * obj1 = 0 ;
27986 char *kwnames[] = {
27987 (char *) "self",(char *) "handler", NULL
27988 };
27989
27990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27992 if (SWIG_arg_fail(1)) SWIG_fail;
27993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27994 if (SWIG_arg_fail(2)) SWIG_fail;
27995 {
27996 PyThreadState* __tstate = wxPyBeginAllowThreads();
27997 (arg1)->PushEventHandler(arg2);
27998
27999 wxPyEndAllowThreads(__tstate);
28000 if (PyErr_Occurred()) SWIG_fail;
28001 }
28002 Py_INCREF(Py_None); resultobj = Py_None;
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxWindow *arg1 = (wxWindow *) 0 ;
28012 bool arg2 = (bool) false ;
28013 wxEvtHandler *result;
28014 PyObject * obj0 = 0 ;
28015 PyObject * obj1 = 0 ;
28016 char *kwnames[] = {
28017 (char *) "self",(char *) "deleteHandler", NULL
28018 };
28019
28020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28022 if (SWIG_arg_fail(1)) SWIG_fail;
28023 if (obj1) {
28024 {
28025 arg2 = (bool)(SWIG_As_bool(obj1));
28026 if (SWIG_arg_fail(2)) SWIG_fail;
28027 }
28028 }
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28032
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 {
28037 resultobj = wxPyMake_wxObject(result, 0);
28038 }
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj;
28047 wxWindow *arg1 = (wxWindow *) 0 ;
28048 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28049 bool result;
28050 PyObject * obj0 = 0 ;
28051 PyObject * obj1 = 0 ;
28052 char *kwnames[] = {
28053 (char *) "self",(char *) "handler", NULL
28054 };
28055
28056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28058 if (SWIG_arg_fail(1)) SWIG_fail;
28059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28060 if (SWIG_arg_fail(2)) SWIG_fail;
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 result = (bool)(arg1)->RemoveEventHandler(arg2);
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 {
28069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28070 }
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj;
28079 wxWindow *arg1 = (wxWindow *) 0 ;
28080 wxValidator *arg2 = 0 ;
28081 PyObject * obj0 = 0 ;
28082 PyObject * obj1 = 0 ;
28083 char *kwnames[] = {
28084 (char *) "self",(char *) "validator", NULL
28085 };
28086
28087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28089 if (SWIG_arg_fail(1)) SWIG_fail;
28090 {
28091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28092 if (SWIG_arg_fail(2)) SWIG_fail;
28093 if (arg2 == NULL) {
28094 SWIG_null_ref("wxValidator");
28095 }
28096 if (SWIG_arg_fail(2)) SWIG_fail;
28097 }
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 (arg1)->SetValidator((wxValidator const &)*arg2);
28101
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 Py_INCREF(Py_None); resultobj = Py_None;
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj;
28114 wxWindow *arg1 = (wxWindow *) 0 ;
28115 wxValidator *result;
28116 PyObject * obj0 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "self", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 {
28125 PyThreadState* __tstate = wxPyBeginAllowThreads();
28126 result = (wxValidator *)(arg1)->GetValidator();
28127
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 {
28132 resultobj = wxPyMake_wxObject(result, 0);
28133 }
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28141 PyObject *resultobj;
28142 wxWindow *arg1 = (wxWindow *) 0 ;
28143 bool result;
28144 PyObject * obj0 = 0 ;
28145 char *kwnames[] = {
28146 (char *) "self", NULL
28147 };
28148
28149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28151 if (SWIG_arg_fail(1)) SWIG_fail;
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 result = (bool)(arg1)->Validate();
28155
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 {
28160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28161 }
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj;
28170 wxWindow *arg1 = (wxWindow *) 0 ;
28171 bool result;
28172 PyObject * obj0 = 0 ;
28173 char *kwnames[] = {
28174 (char *) "self", NULL
28175 };
28176
28177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28179 if (SWIG_arg_fail(1)) SWIG_fail;
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = (bool)(arg1)->TransferDataToWindow();
28183
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 {
28188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28189 }
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28197 PyObject *resultobj;
28198 wxWindow *arg1 = (wxWindow *) 0 ;
28199 bool result;
28200 PyObject * obj0 = 0 ;
28201 char *kwnames[] = {
28202 (char *) "self", NULL
28203 };
28204
28205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28207 if (SWIG_arg_fail(1)) SWIG_fail;
28208 {
28209 PyThreadState* __tstate = wxPyBeginAllowThreads();
28210 result = (bool)(arg1)->TransferDataFromWindow();
28211
28212 wxPyEndAllowThreads(__tstate);
28213 if (PyErr_Occurred()) SWIG_fail;
28214 }
28215 {
28216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28217 }
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj;
28226 wxWindow *arg1 = (wxWindow *) 0 ;
28227 PyObject * obj0 = 0 ;
28228 char *kwnames[] = {
28229 (char *) "self", NULL
28230 };
28231
28232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28234 if (SWIG_arg_fail(1)) SWIG_fail;
28235 {
28236 PyThreadState* __tstate = wxPyBeginAllowThreads();
28237 (arg1)->InitDialog();
28238
28239 wxPyEndAllowThreads(__tstate);
28240 if (PyErr_Occurred()) SWIG_fail;
28241 }
28242 Py_INCREF(Py_None); resultobj = Py_None;
28243 return resultobj;
28244 fail:
28245 return NULL;
28246 }
28247
28248
28249 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28250 PyObject *resultobj;
28251 wxWindow *arg1 = (wxWindow *) 0 ;
28252 wxAcceleratorTable *arg2 = 0 ;
28253 PyObject * obj0 = 0 ;
28254 PyObject * obj1 = 0 ;
28255 char *kwnames[] = {
28256 (char *) "self",(char *) "accel", NULL
28257 };
28258
28259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28261 if (SWIG_arg_fail(1)) SWIG_fail;
28262 {
28263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28264 if (SWIG_arg_fail(2)) SWIG_fail;
28265 if (arg2 == NULL) {
28266 SWIG_null_ref("wxAcceleratorTable");
28267 }
28268 if (SWIG_arg_fail(2)) SWIG_fail;
28269 }
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28273
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 Py_INCREF(Py_None); resultobj = Py_None;
28278 return resultobj;
28279 fail:
28280 return NULL;
28281 }
28282
28283
28284 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28285 PyObject *resultobj;
28286 wxWindow *arg1 = (wxWindow *) 0 ;
28287 wxAcceleratorTable *result;
28288 PyObject * obj0 = 0 ;
28289 char *kwnames[] = {
28290 (char *) "self", NULL
28291 };
28292
28293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28295 if (SWIG_arg_fail(1)) SWIG_fail;
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28299
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj;
28312 wxWindow *arg1 = (wxWindow *) 0 ;
28313 int arg2 ;
28314 int arg3 ;
28315 int arg4 ;
28316 bool result;
28317 PyObject * obj0 = 0 ;
28318 PyObject * obj1 = 0 ;
28319 PyObject * obj2 = 0 ;
28320 PyObject * obj3 = 0 ;
28321 char *kwnames[] = {
28322 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28323 };
28324
28325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28327 if (SWIG_arg_fail(1)) SWIG_fail;
28328 {
28329 arg2 = (int)(SWIG_As_int(obj1));
28330 if (SWIG_arg_fail(2)) SWIG_fail;
28331 }
28332 {
28333 arg3 = (int)(SWIG_As_int(obj2));
28334 if (SWIG_arg_fail(3)) SWIG_fail;
28335 }
28336 {
28337 arg4 = (int)(SWIG_As_int(obj3));
28338 if (SWIG_arg_fail(4)) SWIG_fail;
28339 }
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28343
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 {
28348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28349 }
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28357 PyObject *resultobj;
28358 wxWindow *arg1 = (wxWindow *) 0 ;
28359 int arg2 ;
28360 bool result;
28361 PyObject * obj0 = 0 ;
28362 PyObject * obj1 = 0 ;
28363 char *kwnames[] = {
28364 (char *) "self",(char *) "hotkeyId", NULL
28365 };
28366
28367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28369 if (SWIG_arg_fail(1)) SWIG_fail;
28370 {
28371 arg2 = (int)(SWIG_As_int(obj1));
28372 if (SWIG_arg_fail(2)) SWIG_fail;
28373 }
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28377
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 {
28382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28383 }
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxWindow *arg1 = (wxWindow *) 0 ;
28393 wxPoint *arg2 = 0 ;
28394 wxPoint result;
28395 wxPoint temp2 ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char *kwnames[] = {
28399 (char *) "self",(char *) "pt", NULL
28400 };
28401
28402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28404 if (SWIG_arg_fail(1)) SWIG_fail;
28405 {
28406 arg2 = &temp2;
28407 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28408 }
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28412
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 {
28417 wxPoint * resultptr;
28418 resultptr = new wxPoint((wxPoint &)(result));
28419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28420 }
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28428 PyObject *resultobj;
28429 wxWindow *arg1 = (wxWindow *) 0 ;
28430 wxSize *arg2 = 0 ;
28431 wxSize result;
28432 wxSize temp2 ;
28433 PyObject * obj0 = 0 ;
28434 PyObject * obj1 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self",(char *) "sz", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
28444 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28445 }
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28449
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 {
28454 wxSize * resultptr;
28455 resultptr = new wxSize((wxSize &)(result));
28456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28457 }
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj;
28466 wxWindow *arg1 = (wxWindow *) 0 ;
28467 wxPoint *arg2 = 0 ;
28468 wxPoint result;
28469 wxPoint temp2 ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28472 char *kwnames[] = {
28473 (char *) "self",(char *) "pt", NULL
28474 };
28475
28476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28478 if (SWIG_arg_fail(1)) SWIG_fail;
28479 {
28480 arg2 = &temp2;
28481 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28482 }
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28486
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 {
28491 wxPoint * resultptr;
28492 resultptr = new wxPoint((wxPoint &)(result));
28493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28494 }
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28502 PyObject *resultobj;
28503 wxWindow *arg1 = (wxWindow *) 0 ;
28504 wxSize *arg2 = 0 ;
28505 wxSize result;
28506 wxSize temp2 ;
28507 PyObject * obj0 = 0 ;
28508 PyObject * obj1 = 0 ;
28509 char *kwnames[] = {
28510 (char *) "self",(char *) "sz", NULL
28511 };
28512
28513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28515 if (SWIG_arg_fail(1)) SWIG_fail;
28516 {
28517 arg2 = &temp2;
28518 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28519 }
28520 {
28521 PyThreadState* __tstate = wxPyBeginAllowThreads();
28522 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28523
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 {
28528 wxSize * resultptr;
28529 resultptr = new wxSize((wxSize &)(result));
28530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28531 }
28532 return resultobj;
28533 fail:
28534 return NULL;
28535 }
28536
28537
28538 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28539 PyObject *resultobj;
28540 wxWindow *arg1 = (wxWindow *) 0 ;
28541 wxPoint *arg2 = 0 ;
28542 wxPoint result;
28543 wxPoint temp2 ;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char *kwnames[] = {
28547 (char *) "self",(char *) "pt", NULL
28548 };
28549
28550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28552 if (SWIG_arg_fail(1)) SWIG_fail;
28553 {
28554 arg2 = &temp2;
28555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28556 }
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28560
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 {
28565 wxPoint * resultptr;
28566 resultptr = new wxPoint((wxPoint &)(result));
28567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28568 }
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28576 PyObject *resultobj;
28577 wxWindow *arg1 = (wxWindow *) 0 ;
28578 wxSize *arg2 = 0 ;
28579 wxSize result;
28580 wxSize temp2 ;
28581 PyObject * obj0 = 0 ;
28582 PyObject * obj1 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "sz", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) 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 = &temp2;
28592 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28593 }
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28597
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 {
28602 wxSize * resultptr;
28603 resultptr = new wxSize((wxSize &)(result));
28604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28605 }
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj;
28614 wxWindow *arg1 = (wxWindow *) 0 ;
28615 int arg2 ;
28616 int arg3 ;
28617 PyObject * obj0 = 0 ;
28618 PyObject * obj1 = 0 ;
28619 PyObject * obj2 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self",(char *) "x",(char *) "y", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 arg2 = (int)(SWIG_As_int(obj1));
28629 if (SWIG_arg_fail(2)) SWIG_fail;
28630 }
28631 {
28632 arg3 = (int)(SWIG_As_int(obj2));
28633 if (SWIG_arg_fail(3)) SWIG_fail;
28634 }
28635 {
28636 PyThreadState* __tstate = wxPyBeginAllowThreads();
28637 (arg1)->WarpPointer(arg2,arg3);
28638
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 Py_INCREF(Py_None); resultobj = Py_None;
28643 return resultobj;
28644 fail:
28645 return NULL;
28646 }
28647
28648
28649 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28650 PyObject *resultobj;
28651 wxWindow *arg1 = (wxWindow *) 0 ;
28652 PyObject * obj0 = 0 ;
28653 char *kwnames[] = {
28654 (char *) "self", NULL
28655 };
28656
28657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28659 if (SWIG_arg_fail(1)) SWIG_fail;
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 (arg1)->CaptureMouse();
28663
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 Py_INCREF(Py_None); resultobj = Py_None;
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj;
28676 wxWindow *arg1 = (wxWindow *) 0 ;
28677 PyObject * obj0 = 0 ;
28678 char *kwnames[] = {
28679 (char *) "self", NULL
28680 };
28681
28682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28684 if (SWIG_arg_fail(1)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 (arg1)->ReleaseMouse();
28688
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 Py_INCREF(Py_None); resultobj = Py_None;
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj;
28701 wxWindow *result;
28702 char *kwnames[] = {
28703 NULL
28704 };
28705
28706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28707 {
28708 if (!wxPyCheckForApp()) SWIG_fail;
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = (wxWindow *)wxWindow::GetCapture();
28711
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 {
28716 resultobj = wxPyMake_wxObject(result, 0);
28717 }
28718 return resultobj;
28719 fail:
28720 return NULL;
28721 }
28722
28723
28724 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28725 PyObject *resultobj;
28726 wxWindow *arg1 = (wxWindow *) 0 ;
28727 bool result;
28728 PyObject * obj0 = 0 ;
28729 char *kwnames[] = {
28730 (char *) "self", NULL
28731 };
28732
28733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28735 if (SWIG_arg_fail(1)) SWIG_fail;
28736 {
28737 PyThreadState* __tstate = wxPyBeginAllowThreads();
28738 result = (bool)((wxWindow const *)arg1)->HasCapture();
28739
28740 wxPyEndAllowThreads(__tstate);
28741 if (PyErr_Occurred()) SWIG_fail;
28742 }
28743 {
28744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28745 }
28746 return resultobj;
28747 fail:
28748 return NULL;
28749 }
28750
28751
28752 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28753 PyObject *resultobj;
28754 wxWindow *arg1 = (wxWindow *) 0 ;
28755 bool arg2 = (bool) true ;
28756 wxRect *arg3 = (wxRect *) NULL ;
28757 PyObject * obj0 = 0 ;
28758 PyObject * obj1 = 0 ;
28759 PyObject * obj2 = 0 ;
28760 char *kwnames[] = {
28761 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28762 };
28763
28764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28766 if (SWIG_arg_fail(1)) SWIG_fail;
28767 if (obj1) {
28768 {
28769 arg2 = (bool)(SWIG_As_bool(obj1));
28770 if (SWIG_arg_fail(2)) SWIG_fail;
28771 }
28772 }
28773 if (obj2) {
28774 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28775 if (SWIG_arg_fail(3)) SWIG_fail;
28776 }
28777 {
28778 PyThreadState* __tstate = wxPyBeginAllowThreads();
28779 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28780
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 Py_INCREF(Py_None); resultobj = Py_None;
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj;
28793 wxWindow *arg1 = (wxWindow *) 0 ;
28794 wxRect *arg2 = 0 ;
28795 bool arg3 = (bool) true ;
28796 wxRect temp2 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 PyObject * obj2 = 0 ;
28800 char *kwnames[] = {
28801 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28802 };
28803
28804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28806 if (SWIG_arg_fail(1)) SWIG_fail;
28807 {
28808 arg2 = &temp2;
28809 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28810 }
28811 if (obj2) {
28812 {
28813 arg3 = (bool)(SWIG_As_bool(obj2));
28814 if (SWIG_arg_fail(3)) SWIG_fail;
28815 }
28816 }
28817 {
28818 PyThreadState* __tstate = wxPyBeginAllowThreads();
28819 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28820
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 Py_INCREF(Py_None); resultobj = Py_None;
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj;
28833 wxWindow *arg1 = (wxWindow *) 0 ;
28834 PyObject * obj0 = 0 ;
28835 char *kwnames[] = {
28836 (char *) "self", NULL
28837 };
28838
28839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28841 if (SWIG_arg_fail(1)) SWIG_fail;
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 (arg1)->Update();
28845
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 Py_INCREF(Py_None); resultobj = Py_None;
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj;
28858 wxWindow *arg1 = (wxWindow *) 0 ;
28859 PyObject * obj0 = 0 ;
28860 char *kwnames[] = {
28861 (char *) "self", NULL
28862 };
28863
28864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28866 if (SWIG_arg_fail(1)) SWIG_fail;
28867 {
28868 PyThreadState* __tstate = wxPyBeginAllowThreads();
28869 (arg1)->ClearBackground();
28870
28871 wxPyEndAllowThreads(__tstate);
28872 if (PyErr_Occurred()) SWIG_fail;
28873 }
28874 Py_INCREF(Py_None); resultobj = Py_None;
28875 return resultobj;
28876 fail:
28877 return NULL;
28878 }
28879
28880
28881 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28882 PyObject *resultobj;
28883 wxWindow *arg1 = (wxWindow *) 0 ;
28884 PyObject * obj0 = 0 ;
28885 char *kwnames[] = {
28886 (char *) "self", NULL
28887 };
28888
28889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28891 if (SWIG_arg_fail(1)) SWIG_fail;
28892 {
28893 PyThreadState* __tstate = wxPyBeginAllowThreads();
28894 (arg1)->Freeze();
28895
28896 wxPyEndAllowThreads(__tstate);
28897 if (PyErr_Occurred()) SWIG_fail;
28898 }
28899 Py_INCREF(Py_None); resultobj = Py_None;
28900 return resultobj;
28901 fail:
28902 return NULL;
28903 }
28904
28905
28906 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28907 PyObject *resultobj;
28908 wxWindow *arg1 = (wxWindow *) 0 ;
28909 PyObject * obj0 = 0 ;
28910 char *kwnames[] = {
28911 (char *) "self", NULL
28912 };
28913
28914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28916 if (SWIG_arg_fail(1)) SWIG_fail;
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 (arg1)->Thaw();
28920
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 Py_INCREF(Py_None); resultobj = Py_None;
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxWindow *arg1 = (wxWindow *) 0 ;
28934 wxDC *arg2 = 0 ;
28935 PyObject * obj0 = 0 ;
28936 PyObject * obj1 = 0 ;
28937 char *kwnames[] = {
28938 (char *) "self",(char *) "dc", NULL
28939 };
28940
28941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28943 if (SWIG_arg_fail(1)) SWIG_fail;
28944 {
28945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28946 if (SWIG_arg_fail(2)) SWIG_fail;
28947 if (arg2 == NULL) {
28948 SWIG_null_ref("wxDC");
28949 }
28950 if (SWIG_arg_fail(2)) SWIG_fail;
28951 }
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 (arg1)->PrepareDC(*arg2);
28955
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 Py_INCREF(Py_None); resultobj = Py_None;
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28967 PyObject *resultobj;
28968 wxWindow *arg1 = (wxWindow *) 0 ;
28969 wxRegion *result;
28970 PyObject * obj0 = 0 ;
28971 char *kwnames[] = {
28972 (char *) "self", NULL
28973 };
28974
28975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28977 if (SWIG_arg_fail(1)) SWIG_fail;
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 {
28981 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28982 result = (wxRegion *) &_result_ref;
28983 }
28984
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj;
28997 wxWindow *arg1 = (wxWindow *) 0 ;
28998 wxRect result;
28999 PyObject * obj0 = 0 ;
29000 char *kwnames[] = {
29001 (char *) "self", NULL
29002 };
29003
29004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29006 if (SWIG_arg_fail(1)) SWIG_fail;
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 {
29015 wxRect * resultptr;
29016 resultptr = new wxRect((wxRect &)(result));
29017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29018 }
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29026 PyObject *resultobj;
29027 wxWindow *arg1 = (wxWindow *) 0 ;
29028 int arg2 ;
29029 int arg3 ;
29030 int arg4 = (int) 1 ;
29031 int arg5 = (int) 1 ;
29032 bool result;
29033 PyObject * obj0 = 0 ;
29034 PyObject * obj1 = 0 ;
29035 PyObject * obj2 = 0 ;
29036 PyObject * obj3 = 0 ;
29037 PyObject * obj4 = 0 ;
29038 char *kwnames[] = {
29039 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29040 };
29041
29042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29044 if (SWIG_arg_fail(1)) SWIG_fail;
29045 {
29046 arg2 = (int)(SWIG_As_int(obj1));
29047 if (SWIG_arg_fail(2)) SWIG_fail;
29048 }
29049 {
29050 arg3 = (int)(SWIG_As_int(obj2));
29051 if (SWIG_arg_fail(3)) SWIG_fail;
29052 }
29053 if (obj3) {
29054 {
29055 arg4 = (int)(SWIG_As_int(obj3));
29056 if (SWIG_arg_fail(4)) SWIG_fail;
29057 }
29058 }
29059 if (obj4) {
29060 {
29061 arg5 = (int)(SWIG_As_int(obj4));
29062 if (SWIG_arg_fail(5)) SWIG_fail;
29063 }
29064 }
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29068
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 {
29073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29074 }
29075 return resultobj;
29076 fail:
29077 return NULL;
29078 }
29079
29080
29081 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29082 PyObject *resultobj;
29083 wxWindow *arg1 = (wxWindow *) 0 ;
29084 wxPoint *arg2 = 0 ;
29085 bool result;
29086 wxPoint temp2 ;
29087 PyObject * obj0 = 0 ;
29088 PyObject * obj1 = 0 ;
29089 char *kwnames[] = {
29090 (char *) "self",(char *) "pt", NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29095 if (SWIG_arg_fail(1)) SWIG_fail;
29096 {
29097 arg2 = &temp2;
29098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29099 }
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj;
29118 wxWindow *arg1 = (wxWindow *) 0 ;
29119 wxRect *arg2 = 0 ;
29120 bool result;
29121 wxRect temp2 ;
29122 PyObject * obj0 = 0 ;
29123 PyObject * obj1 = 0 ;
29124 char *kwnames[] = {
29125 (char *) "self",(char *) "rect", NULL
29126 };
29127
29128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29130 if (SWIG_arg_fail(1)) SWIG_fail;
29131 {
29132 arg2 = &temp2;
29133 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29134 }
29135 {
29136 PyThreadState* __tstate = wxPyBeginAllowThreads();
29137 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29138
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 {
29143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29144 }
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29152 PyObject *resultobj;
29153 wxWindow *arg1 = (wxWindow *) 0 ;
29154 wxVisualAttributes result;
29155 PyObject * obj0 = 0 ;
29156 char *kwnames[] = {
29157 (char *) "self", NULL
29158 };
29159
29160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29162 if (SWIG_arg_fail(1)) SWIG_fail;
29163 {
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29166
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 {
29171 wxVisualAttributes * resultptr;
29172 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29174 }
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj;
29183 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29184 wxVisualAttributes result;
29185 PyObject * obj0 = 0 ;
29186 char *kwnames[] = {
29187 (char *) "variant", NULL
29188 };
29189
29190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29191 if (obj0) {
29192 {
29193 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29194 if (SWIG_arg_fail(1)) SWIG_fail;
29195 }
29196 }
29197 {
29198 if (!wxPyCheckForApp()) SWIG_fail;
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 wxVisualAttributes * resultptr;
29207 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxWindow *arg1 = (wxWindow *) 0 ;
29219 wxColour *arg2 = 0 ;
29220 bool result;
29221 wxColour temp2 ;
29222 PyObject * obj0 = 0 ;
29223 PyObject * obj1 = 0 ;
29224 char *kwnames[] = {
29225 (char *) "self",(char *) "colour", NULL
29226 };
29227
29228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29230 if (SWIG_arg_fail(1)) SWIG_fail;
29231 {
29232 arg2 = &temp2;
29233 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29234 }
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29238
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 {
29243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29244 }
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj;
29253 wxWindow *arg1 = (wxWindow *) 0 ;
29254 wxColour *arg2 = 0 ;
29255 wxColour temp2 ;
29256 PyObject * obj0 = 0 ;
29257 PyObject * obj1 = 0 ;
29258 char *kwnames[] = {
29259 (char *) "self",(char *) "colour", NULL
29260 };
29261
29262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29264 if (SWIG_arg_fail(1)) SWIG_fail;
29265 {
29266 arg2 = &temp2;
29267 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29268 }
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 Py_INCREF(Py_None); resultobj = Py_None;
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj;
29285 wxWindow *arg1 = (wxWindow *) 0 ;
29286 wxColour *arg2 = 0 ;
29287 bool result;
29288 wxColour temp2 ;
29289 PyObject * obj0 = 0 ;
29290 PyObject * obj1 = 0 ;
29291 char *kwnames[] = {
29292 (char *) "self",(char *) "colour", NULL
29293 };
29294
29295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29297 if (SWIG_arg_fail(1)) SWIG_fail;
29298 {
29299 arg2 = &temp2;
29300 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29301 }
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29305
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 {
29310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29311 }
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29319 PyObject *resultobj;
29320 wxWindow *arg1 = (wxWindow *) 0 ;
29321 wxColour *arg2 = 0 ;
29322 wxColour temp2 ;
29323 PyObject * obj0 = 0 ;
29324 PyObject * obj1 = 0 ;
29325 char *kwnames[] = {
29326 (char *) "self",(char *) "colour", NULL
29327 };
29328
29329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29331 if (SWIG_arg_fail(1)) SWIG_fail;
29332 {
29333 arg2 = &temp2;
29334 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29335 }
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29339
29340 wxPyEndAllowThreads(__tstate);
29341 if (PyErr_Occurred()) SWIG_fail;
29342 }
29343 Py_INCREF(Py_None); resultobj = Py_None;
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29351 PyObject *resultobj;
29352 wxWindow *arg1 = (wxWindow *) 0 ;
29353 wxColour result;
29354 PyObject * obj0 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(1)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 {
29370 wxColour * resultptr;
29371 resultptr = new wxColour((wxColour &)(result));
29372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29373 }
29374 return resultobj;
29375 fail:
29376 return NULL;
29377 }
29378
29379
29380 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj;
29382 wxWindow *arg1 = (wxWindow *) 0 ;
29383 wxColour result;
29384 PyObject * obj0 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = ((wxWindow const *)arg1)->GetForegroundColour();
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 {
29400 wxColour * resultptr;
29401 resultptr = new wxColour((wxColour &)(result));
29402 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29403 }
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29411 PyObject *resultobj;
29412 wxWindow *arg1 = (wxWindow *) 0 ;
29413 wxBackgroundStyle arg2 ;
29414 bool result;
29415 PyObject * obj0 = 0 ;
29416 PyObject * obj1 = 0 ;
29417 char *kwnames[] = {
29418 (char *) "self",(char *) "style", NULL
29419 };
29420
29421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29423 if (SWIG_arg_fail(1)) SWIG_fail;
29424 {
29425 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29426 if (SWIG_arg_fail(2)) SWIG_fail;
29427 }
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29431
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 {
29436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29437 }
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj;
29446 wxWindow *arg1 = (wxWindow *) 0 ;
29447 wxBackgroundStyle result;
29448 PyObject * obj0 = 0 ;
29449 char *kwnames[] = {
29450 (char *) "self", NULL
29451 };
29452
29453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29455 if (SWIG_arg_fail(1)) SWIG_fail;
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29459
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 resultobj = SWIG_From_int((result));
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29471 PyObject *resultobj;
29472 wxWindow *arg1 = (wxWindow *) 0 ;
29473 bool result;
29474 PyObject * obj0 = 0 ;
29475 char *kwnames[] = {
29476 (char *) "self", NULL
29477 };
29478
29479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29481 if (SWIG_arg_fail(1)) SWIG_fail;
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = (bool)(arg1)->HasTransparentBackground();
29485
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 {
29490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29491 }
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29499 PyObject *resultobj;
29500 wxWindow *arg1 = (wxWindow *) 0 ;
29501 wxCursor *arg2 = 0 ;
29502 bool result;
29503 PyObject * obj0 = 0 ;
29504 PyObject * obj1 = 0 ;
29505 char *kwnames[] = {
29506 (char *) "self",(char *) "cursor", NULL
29507 };
29508
29509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29511 if (SWIG_arg_fail(1)) SWIG_fail;
29512 {
29513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29514 if (SWIG_arg_fail(2)) SWIG_fail;
29515 if (arg2 == NULL) {
29516 SWIG_null_ref("wxCursor");
29517 }
29518 if (SWIG_arg_fail(2)) SWIG_fail;
29519 }
29520 {
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29523
29524 wxPyEndAllowThreads(__tstate);
29525 if (PyErr_Occurred()) SWIG_fail;
29526 }
29527 {
29528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29529 }
29530 return resultobj;
29531 fail:
29532 return NULL;
29533 }
29534
29535
29536 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29537 PyObject *resultobj;
29538 wxWindow *arg1 = (wxWindow *) 0 ;
29539 wxCursor result;
29540 PyObject * obj0 = 0 ;
29541 char *kwnames[] = {
29542 (char *) "self", NULL
29543 };
29544
29545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29547 if (SWIG_arg_fail(1)) SWIG_fail;
29548 {
29549 PyThreadState* __tstate = wxPyBeginAllowThreads();
29550 result = (arg1)->GetCursor();
29551
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 {
29556 wxCursor * resultptr;
29557 resultptr = new wxCursor((wxCursor &)(result));
29558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29559 }
29560 return resultobj;
29561 fail:
29562 return NULL;
29563 }
29564
29565
29566 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29567 PyObject *resultobj;
29568 wxWindow *arg1 = (wxWindow *) 0 ;
29569 wxFont *arg2 = 0 ;
29570 bool result;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char *kwnames[] = {
29574 (char *) "self",(char *) "font", NULL
29575 };
29576
29577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29579 if (SWIG_arg_fail(1)) SWIG_fail;
29580 {
29581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29582 if (SWIG_arg_fail(2)) SWIG_fail;
29583 if (arg2 == NULL) {
29584 SWIG_null_ref("wxFont");
29585 }
29586 if (SWIG_arg_fail(2)) SWIG_fail;
29587 }
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29591
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 {
29596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29597 }
29598 return resultobj;
29599 fail:
29600 return NULL;
29601 }
29602
29603
29604 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29605 PyObject *resultobj;
29606 wxWindow *arg1 = (wxWindow *) 0 ;
29607 wxFont *arg2 = 0 ;
29608 PyObject * obj0 = 0 ;
29609 PyObject * obj1 = 0 ;
29610 char *kwnames[] = {
29611 (char *) "self",(char *) "font", NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29616 if (SWIG_arg_fail(1)) SWIG_fail;
29617 {
29618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29619 if (SWIG_arg_fail(2)) SWIG_fail;
29620 if (arg2 == NULL) {
29621 SWIG_null_ref("wxFont");
29622 }
29623 if (SWIG_arg_fail(2)) SWIG_fail;
29624 }
29625 {
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 (arg1)->SetOwnFont((wxFont const &)*arg2);
29628
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 Py_INCREF(Py_None); resultobj = Py_None;
29633 return resultobj;
29634 fail:
29635 return NULL;
29636 }
29637
29638
29639 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29640 PyObject *resultobj;
29641 wxWindow *arg1 = (wxWindow *) 0 ;
29642 wxFont result;
29643 PyObject * obj0 = 0 ;
29644 char *kwnames[] = {
29645 (char *) "self", NULL
29646 };
29647
29648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29650 if (SWIG_arg_fail(1)) SWIG_fail;
29651 {
29652 PyThreadState* __tstate = wxPyBeginAllowThreads();
29653 result = (arg1)->GetFont();
29654
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 {
29659 wxFont * resultptr;
29660 resultptr = new wxFont((wxFont &)(result));
29661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29662 }
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj;
29671 wxWindow *arg1 = (wxWindow *) 0 ;
29672 wxCaret *arg2 = (wxCaret *) 0 ;
29673 PyObject * obj0 = 0 ;
29674 PyObject * obj1 = 0 ;
29675 char *kwnames[] = {
29676 (char *) "self",(char *) "caret", NULL
29677 };
29678
29679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29681 if (SWIG_arg_fail(1)) SWIG_fail;
29682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(2)) SWIG_fail;
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 (arg1)->SetCaret(arg2);
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 Py_INCREF(Py_None); resultobj = Py_None;
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj;
29700 wxWindow *arg1 = (wxWindow *) 0 ;
29701 wxCaret *result;
29702 PyObject * obj0 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 PyThreadState* __tstate = wxPyBeginAllowThreads();
29712 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29713
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 int result;
29728 PyObject * obj0 = 0 ;
29729 char *kwnames[] = {
29730 (char *) "self", NULL
29731 };
29732
29733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29735 if (SWIG_arg_fail(1)) SWIG_fail;
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29739
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 {
29744 resultobj = SWIG_From_int((int)(result));
29745 }
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29753 PyObject *resultobj;
29754 wxWindow *arg1 = (wxWindow *) 0 ;
29755 int result;
29756 PyObject * obj0 = 0 ;
29757 char *kwnames[] = {
29758 (char *) "self", NULL
29759 };
29760
29761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29763 if (SWIG_arg_fail(1)) SWIG_fail;
29764 {
29765 PyThreadState* __tstate = wxPyBeginAllowThreads();
29766 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29767
29768 wxPyEndAllowThreads(__tstate);
29769 if (PyErr_Occurred()) SWIG_fail;
29770 }
29771 {
29772 resultobj = SWIG_From_int((int)(result));
29773 }
29774 return resultobj;
29775 fail:
29776 return NULL;
29777 }
29778
29779
29780 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29781 PyObject *resultobj;
29782 wxWindow *arg1 = (wxWindow *) 0 ;
29783 wxString *arg2 = 0 ;
29784 int *arg3 = (int *) 0 ;
29785 int *arg4 = (int *) 0 ;
29786 bool temp2 = false ;
29787 int temp3 ;
29788 int res3 = 0 ;
29789 int temp4 ;
29790 int res4 = 0 ;
29791 PyObject * obj0 = 0 ;
29792 PyObject * obj1 = 0 ;
29793 char *kwnames[] = {
29794 (char *) "self",(char *) "string", NULL
29795 };
29796
29797 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29798 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29801 if (SWIG_arg_fail(1)) SWIG_fail;
29802 {
29803 arg2 = wxString_in_helper(obj1);
29804 if (arg2 == NULL) SWIG_fail;
29805 temp2 = true;
29806 }
29807 {
29808 PyThreadState* __tstate = wxPyBeginAllowThreads();
29809 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29810
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 Py_INCREF(Py_None); resultobj = Py_None;
29815 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29816 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29817 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29818 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29819 {
29820 if (temp2)
29821 delete arg2;
29822 }
29823 return resultobj;
29824 fail:
29825 {
29826 if (temp2)
29827 delete arg2;
29828 }
29829 return NULL;
29830 }
29831
29832
29833 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29834 PyObject *resultobj;
29835 wxWindow *arg1 = (wxWindow *) 0 ;
29836 wxString *arg2 = 0 ;
29837 int *arg3 = (int *) 0 ;
29838 int *arg4 = (int *) 0 ;
29839 int *arg5 = (int *) 0 ;
29840 int *arg6 = (int *) 0 ;
29841 wxFont *arg7 = (wxFont *) NULL ;
29842 bool temp2 = false ;
29843 int temp3 ;
29844 int res3 = 0 ;
29845 int temp4 ;
29846 int res4 = 0 ;
29847 int temp5 ;
29848 int res5 = 0 ;
29849 int temp6 ;
29850 int res6 = 0 ;
29851 PyObject * obj0 = 0 ;
29852 PyObject * obj1 = 0 ;
29853 PyObject * obj2 = 0 ;
29854 char *kwnames[] = {
29855 (char *) "self",(char *) "string",(char *) "font", NULL
29856 };
29857
29858 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29859 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29860 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29861 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29864 if (SWIG_arg_fail(1)) SWIG_fail;
29865 {
29866 arg2 = wxString_in_helper(obj1);
29867 if (arg2 == NULL) SWIG_fail;
29868 temp2 = true;
29869 }
29870 if (obj2) {
29871 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29872 if (SWIG_arg_fail(7)) SWIG_fail;
29873 }
29874 {
29875 PyThreadState* __tstate = wxPyBeginAllowThreads();
29876 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29877
29878 wxPyEndAllowThreads(__tstate);
29879 if (PyErr_Occurred()) SWIG_fail;
29880 }
29881 Py_INCREF(Py_None); resultobj = Py_None;
29882 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29883 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29884 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29885 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29886 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29887 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29888 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29889 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29890 {
29891 if (temp2)
29892 delete arg2;
29893 }
29894 return resultobj;
29895 fail:
29896 {
29897 if (temp2)
29898 delete arg2;
29899 }
29900 return NULL;
29901 }
29902
29903
29904 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29905 PyObject *resultobj;
29906 wxWindow *arg1 = (wxWindow *) 0 ;
29907 int *arg2 = (int *) 0 ;
29908 int *arg3 = (int *) 0 ;
29909 int temp2 ;
29910 int res2 = 0 ;
29911 int temp3 ;
29912 int res3 = 0 ;
29913 PyObject * obj0 = 0 ;
29914 PyObject * obj1 = 0 ;
29915 PyObject * obj2 = 0 ;
29916 char *kwnames[] = {
29917 (char *) "self",(char *) "x",(char *) "y", NULL
29918 };
29919
29920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29922 if (SWIG_arg_fail(1)) SWIG_fail;
29923 {
29924 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29925 temp2 = SWIG_As_int(obj1);
29926 if (SWIG_arg_fail(2)) SWIG_fail;
29927 arg2 = &temp2;
29928 res2 = SWIG_NEWOBJ;
29929 }
29930 }
29931 {
29932 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29933 temp3 = SWIG_As_int(obj2);
29934 if (SWIG_arg_fail(3)) SWIG_fail;
29935 arg3 = &temp3;
29936 res3 = SWIG_NEWOBJ;
29937 }
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29942
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 Py_INCREF(Py_None); resultobj = Py_None;
29947 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29948 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29949 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29950 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29958 PyObject *resultobj;
29959 wxWindow *arg1 = (wxWindow *) 0 ;
29960 int *arg2 = (int *) 0 ;
29961 int *arg3 = (int *) 0 ;
29962 int temp2 ;
29963 int res2 = 0 ;
29964 int temp3 ;
29965 int res3 = 0 ;
29966 PyObject * obj0 = 0 ;
29967 PyObject * obj1 = 0 ;
29968 PyObject * obj2 = 0 ;
29969 char *kwnames[] = {
29970 (char *) "self",(char *) "x",(char *) "y", NULL
29971 };
29972
29973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29975 if (SWIG_arg_fail(1)) SWIG_fail;
29976 {
29977 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29978 temp2 = SWIG_As_int(obj1);
29979 if (SWIG_arg_fail(2)) SWIG_fail;
29980 arg2 = &temp2;
29981 res2 = SWIG_NEWOBJ;
29982 }
29983 }
29984 {
29985 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29986 temp3 = SWIG_As_int(obj2);
29987 if (SWIG_arg_fail(3)) SWIG_fail;
29988 arg3 = &temp3;
29989 res3 = SWIG_NEWOBJ;
29990 }
29991 }
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29995
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 Py_INCREF(Py_None); resultobj = Py_None;
30000 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30001 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30002 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30003 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30011 PyObject *resultobj;
30012 wxWindow *arg1 = (wxWindow *) 0 ;
30013 wxPoint *arg2 = 0 ;
30014 wxPoint result;
30015 wxPoint temp2 ;
30016 PyObject * obj0 = 0 ;
30017 PyObject * obj1 = 0 ;
30018 char *kwnames[] = {
30019 (char *) "self",(char *) "pt", NULL
30020 };
30021
30022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30024 if (SWIG_arg_fail(1)) SWIG_fail;
30025 {
30026 arg2 = &temp2;
30027 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30028 }
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30032
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 wxPoint * resultptr;
30038 resultptr = new wxPoint((wxPoint &)(result));
30039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30040 }
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj;
30049 wxWindow *arg1 = (wxWindow *) 0 ;
30050 wxPoint *arg2 = 0 ;
30051 wxPoint result;
30052 wxPoint temp2 ;
30053 PyObject * obj0 = 0 ;
30054 PyObject * obj1 = 0 ;
30055 char *kwnames[] = {
30056 (char *) "self",(char *) "pt", NULL
30057 };
30058
30059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30061 if (SWIG_arg_fail(1)) SWIG_fail;
30062 {
30063 arg2 = &temp2;
30064 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30065 }
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30069
30070 wxPyEndAllowThreads(__tstate);
30071 if (PyErr_Occurred()) SWIG_fail;
30072 }
30073 {
30074 wxPoint * resultptr;
30075 resultptr = new wxPoint((wxPoint &)(result));
30076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30077 }
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30085 PyObject *resultobj;
30086 wxWindow *arg1 = (wxWindow *) 0 ;
30087 int arg2 ;
30088 int arg3 ;
30089 wxHitTest result;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 PyObject * obj2 = 0 ;
30093 char *kwnames[] = {
30094 (char *) "self",(char *) "x",(char *) "y", NULL
30095 };
30096
30097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30099 if (SWIG_arg_fail(1)) SWIG_fail;
30100 {
30101 arg2 = (int)(SWIG_As_int(obj1));
30102 if (SWIG_arg_fail(2)) SWIG_fail;
30103 }
30104 {
30105 arg3 = (int)(SWIG_As_int(obj2));
30106 if (SWIG_arg_fail(3)) SWIG_fail;
30107 }
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30111
30112 wxPyEndAllowThreads(__tstate);
30113 if (PyErr_Occurred()) SWIG_fail;
30114 }
30115 resultobj = SWIG_From_int((result));
30116 return resultobj;
30117 fail:
30118 return NULL;
30119 }
30120
30121
30122 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30123 PyObject *resultobj;
30124 wxWindow *arg1 = (wxWindow *) 0 ;
30125 wxPoint *arg2 = 0 ;
30126 wxHitTest result;
30127 wxPoint temp2 ;
30128 PyObject * obj0 = 0 ;
30129 PyObject * obj1 = 0 ;
30130 char *kwnames[] = {
30131 (char *) "self",(char *) "pt", NULL
30132 };
30133
30134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 {
30138 arg2 = &temp2;
30139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30140 }
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30144
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_From_int((result));
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30156 PyObject *resultobj;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 long arg2 ;
30159 wxBorder result;
30160 PyObject * obj0 = 0 ;
30161 PyObject * obj1 = 0 ;
30162
30163 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30165 if (SWIG_arg_fail(1)) SWIG_fail;
30166 {
30167 arg2 = (long)(SWIG_As_long(obj1));
30168 if (SWIG_arg_fail(2)) SWIG_fail;
30169 }
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30173
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 resultobj = SWIG_From_int((result));
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30185 PyObject *resultobj;
30186 wxWindow *arg1 = (wxWindow *) 0 ;
30187 wxBorder result;
30188 PyObject * obj0 = 0 ;
30189
30190 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30192 if (SWIG_arg_fail(1)) SWIG_fail;
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30196
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 resultobj = SWIG_From_int((result));
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30208 int argc;
30209 PyObject *argv[3];
30210 int ii;
30211
30212 argc = PyObject_Length(args);
30213 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30214 argv[ii] = PyTuple_GetItem(args,ii);
30215 }
30216 if (argc == 1) {
30217 int _v;
30218 {
30219 void *ptr;
30220 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30221 _v = 0;
30222 PyErr_Clear();
30223 } else {
30224 _v = 1;
30225 }
30226 }
30227 if (_v) {
30228 return _wrap_Window_GetBorder__SWIG_1(self,args);
30229 }
30230 }
30231 if (argc == 2) {
30232 int _v;
30233 {
30234 void *ptr;
30235 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30236 _v = 0;
30237 PyErr_Clear();
30238 } else {
30239 _v = 1;
30240 }
30241 }
30242 if (_v) {
30243 _v = SWIG_Check_long(argv[1]);
30244 if (_v) {
30245 return _wrap_Window_GetBorder__SWIG_0(self,args);
30246 }
30247 }
30248 }
30249
30250 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30251 return NULL;
30252 }
30253
30254
30255 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30256 PyObject *resultobj;
30257 wxWindow *arg1 = (wxWindow *) 0 ;
30258 long arg2 = (long) wxUPDATE_UI_NONE ;
30259 PyObject * obj0 = 0 ;
30260 PyObject * obj1 = 0 ;
30261 char *kwnames[] = {
30262 (char *) "self",(char *) "flags", NULL
30263 };
30264
30265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30267 if (SWIG_arg_fail(1)) SWIG_fail;
30268 if (obj1) {
30269 {
30270 arg2 = (long)(SWIG_As_long(obj1));
30271 if (SWIG_arg_fail(2)) SWIG_fail;
30272 }
30273 }
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 (arg1)->UpdateWindowUI(arg2);
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 Py_INCREF(Py_None); resultobj = Py_None;
30282 return resultobj;
30283 fail:
30284 return NULL;
30285 }
30286
30287
30288 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30289 PyObject *resultobj;
30290 wxWindow *arg1 = (wxWindow *) 0 ;
30291 wxMenu *arg2 = (wxMenu *) 0 ;
30292 int arg3 = (int) -1 ;
30293 int arg4 = (int) -1 ;
30294 bool result;
30295 PyObject * obj0 = 0 ;
30296 PyObject * obj1 = 0 ;
30297 PyObject * obj2 = 0 ;
30298 PyObject * obj3 = 0 ;
30299 char *kwnames[] = {
30300 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30301 };
30302
30303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30305 if (SWIG_arg_fail(1)) SWIG_fail;
30306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30307 if (SWIG_arg_fail(2)) SWIG_fail;
30308 if (obj2) {
30309 {
30310 arg3 = (int)(SWIG_As_int(obj2));
30311 if (SWIG_arg_fail(3)) SWIG_fail;
30312 }
30313 }
30314 if (obj3) {
30315 {
30316 arg4 = (int)(SWIG_As_int(obj3));
30317 if (SWIG_arg_fail(4)) SWIG_fail;
30318 }
30319 }
30320 {
30321 PyThreadState* __tstate = wxPyBeginAllowThreads();
30322 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30323
30324 wxPyEndAllowThreads(__tstate);
30325 if (PyErr_Occurred()) SWIG_fail;
30326 }
30327 {
30328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30329 }
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30337 PyObject *resultobj;
30338 wxWindow *arg1 = (wxWindow *) 0 ;
30339 wxMenu *arg2 = (wxMenu *) 0 ;
30340 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30341 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30342 bool result;
30343 wxPoint temp3 ;
30344 PyObject * obj0 = 0 ;
30345 PyObject * obj1 = 0 ;
30346 PyObject * obj2 = 0 ;
30347 char *kwnames[] = {
30348 (char *) "self",(char *) "menu",(char *) "pos", NULL
30349 };
30350
30351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30353 if (SWIG_arg_fail(1)) SWIG_fail;
30354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30355 if (SWIG_arg_fail(2)) SWIG_fail;
30356 if (obj2) {
30357 {
30358 arg3 = &temp3;
30359 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30360 }
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30365
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 {
30370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30371 }
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30379 PyObject *resultobj;
30380 wxWindow *arg1 = (wxWindow *) 0 ;
30381 long result;
30382 PyObject * obj0 = 0 ;
30383 char *kwnames[] = {
30384 (char *) "self", NULL
30385 };
30386
30387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30389 if (SWIG_arg_fail(1)) SWIG_fail;
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 result = (long)wxWindow_GetHandle(arg1);
30393
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 {
30398 resultobj = SWIG_From_long((long)(result));
30399 }
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30407 PyObject *resultobj;
30408 wxWindow *arg1 = (wxWindow *) 0 ;
30409 long arg2 ;
30410 PyObject * obj0 = 0 ;
30411 PyObject * obj1 = 0 ;
30412 char *kwnames[] = {
30413 (char *) "self",(char *) "handle", NULL
30414 };
30415
30416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30418 if (SWIG_arg_fail(1)) SWIG_fail;
30419 {
30420 arg2 = (long)(SWIG_As_long(obj1));
30421 if (SWIG_arg_fail(2)) SWIG_fail;
30422 }
30423 {
30424 PyThreadState* __tstate = wxPyBeginAllowThreads();
30425 wxWindow_AssociateHandle(arg1,arg2);
30426
30427 wxPyEndAllowThreads(__tstate);
30428 if (PyErr_Occurred()) SWIG_fail;
30429 }
30430 Py_INCREF(Py_None); resultobj = Py_None;
30431 return resultobj;
30432 fail:
30433 return NULL;
30434 }
30435
30436
30437 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30438 PyObject *resultobj;
30439 wxWindow *arg1 = (wxWindow *) 0 ;
30440 PyObject * obj0 = 0 ;
30441 char *kwnames[] = {
30442 (char *) "self", NULL
30443 };
30444
30445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30447 if (SWIG_arg_fail(1)) SWIG_fail;
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 (arg1)->DissociateHandle();
30451
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 Py_INCREF(Py_None); resultobj = Py_None;
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30463 PyObject *resultobj;
30464 wxWindow *arg1 = (wxWindow *) 0 ;
30465 int arg2 ;
30466 bool result;
30467 PyObject * obj0 = 0 ;
30468 PyObject * obj1 = 0 ;
30469 char *kwnames[] = {
30470 (char *) "self",(char *) "orient", NULL
30471 };
30472
30473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30475 if (SWIG_arg_fail(1)) SWIG_fail;
30476 {
30477 arg2 = (int)(SWIG_As_int(obj1));
30478 if (SWIG_arg_fail(2)) SWIG_fail;
30479 }
30480 {
30481 PyThreadState* __tstate = wxPyBeginAllowThreads();
30482 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30483
30484 wxPyEndAllowThreads(__tstate);
30485 if (PyErr_Occurred()) SWIG_fail;
30486 }
30487 {
30488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj;
30498 wxWindow *arg1 = (wxWindow *) 0 ;
30499 int arg2 ;
30500 int arg3 ;
30501 int arg4 ;
30502 int arg5 ;
30503 bool arg6 = (bool) true ;
30504 PyObject * obj0 = 0 ;
30505 PyObject * obj1 = 0 ;
30506 PyObject * obj2 = 0 ;
30507 PyObject * obj3 = 0 ;
30508 PyObject * obj4 = 0 ;
30509 PyObject * obj5 = 0 ;
30510 char *kwnames[] = {
30511 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30512 };
30513
30514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30516 if (SWIG_arg_fail(1)) SWIG_fail;
30517 {
30518 arg2 = (int)(SWIG_As_int(obj1));
30519 if (SWIG_arg_fail(2)) SWIG_fail;
30520 }
30521 {
30522 arg3 = (int)(SWIG_As_int(obj2));
30523 if (SWIG_arg_fail(3)) SWIG_fail;
30524 }
30525 {
30526 arg4 = (int)(SWIG_As_int(obj3));
30527 if (SWIG_arg_fail(4)) SWIG_fail;
30528 }
30529 {
30530 arg5 = (int)(SWIG_As_int(obj4));
30531 if (SWIG_arg_fail(5)) SWIG_fail;
30532 }
30533 if (obj5) {
30534 {
30535 arg6 = (bool)(SWIG_As_bool(obj5));
30536 if (SWIG_arg_fail(6)) SWIG_fail;
30537 }
30538 }
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30542
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 Py_INCREF(Py_None); resultobj = Py_None;
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30554 PyObject *resultobj;
30555 wxWindow *arg1 = (wxWindow *) 0 ;
30556 int arg2 ;
30557 int arg3 ;
30558 bool arg4 = (bool) true ;
30559 PyObject * obj0 = 0 ;
30560 PyObject * obj1 = 0 ;
30561 PyObject * obj2 = 0 ;
30562 PyObject * obj3 = 0 ;
30563 char *kwnames[] = {
30564 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30565 };
30566
30567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30569 if (SWIG_arg_fail(1)) SWIG_fail;
30570 {
30571 arg2 = (int)(SWIG_As_int(obj1));
30572 if (SWIG_arg_fail(2)) SWIG_fail;
30573 }
30574 {
30575 arg3 = (int)(SWIG_As_int(obj2));
30576 if (SWIG_arg_fail(3)) SWIG_fail;
30577 }
30578 if (obj3) {
30579 {
30580 arg4 = (bool)(SWIG_As_bool(obj3));
30581 if (SWIG_arg_fail(4)) SWIG_fail;
30582 }
30583 }
30584 {
30585 PyThreadState* __tstate = wxPyBeginAllowThreads();
30586 (arg1)->SetScrollPos(arg2,arg3,arg4);
30587
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 Py_INCREF(Py_None); resultobj = Py_None;
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj;
30600 wxWindow *arg1 = (wxWindow *) 0 ;
30601 int arg2 ;
30602 int result;
30603 PyObject * obj0 = 0 ;
30604 PyObject * obj1 = 0 ;
30605 char *kwnames[] = {
30606 (char *) "self",(char *) "orientation", NULL
30607 };
30608
30609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30611 if (SWIG_arg_fail(1)) SWIG_fail;
30612 {
30613 arg2 = (int)(SWIG_As_int(obj1));
30614 if (SWIG_arg_fail(2)) SWIG_fail;
30615 }
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30619
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 {
30624 resultobj = SWIG_From_int((int)(result));
30625 }
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj;
30634 wxWindow *arg1 = (wxWindow *) 0 ;
30635 int arg2 ;
30636 int result;
30637 PyObject * obj0 = 0 ;
30638 PyObject * obj1 = 0 ;
30639 char *kwnames[] = {
30640 (char *) "self",(char *) "orientation", NULL
30641 };
30642
30643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30645 if (SWIG_arg_fail(1)) SWIG_fail;
30646 {
30647 arg2 = (int)(SWIG_As_int(obj1));
30648 if (SWIG_arg_fail(2)) SWIG_fail;
30649 }
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30653
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 {
30658 resultobj = SWIG_From_int((int)(result));
30659 }
30660 return resultobj;
30661 fail:
30662 return NULL;
30663 }
30664
30665
30666 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30667 PyObject *resultobj;
30668 wxWindow *arg1 = (wxWindow *) 0 ;
30669 int arg2 ;
30670 int result;
30671 PyObject * obj0 = 0 ;
30672 PyObject * obj1 = 0 ;
30673 char *kwnames[] = {
30674 (char *) "self",(char *) "orientation", NULL
30675 };
30676
30677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30679 if (SWIG_arg_fail(1)) SWIG_fail;
30680 {
30681 arg2 = (int)(SWIG_As_int(obj1));
30682 if (SWIG_arg_fail(2)) SWIG_fail;
30683 }
30684 {
30685 PyThreadState* __tstate = wxPyBeginAllowThreads();
30686 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30687
30688 wxPyEndAllowThreads(__tstate);
30689 if (PyErr_Occurred()) SWIG_fail;
30690 }
30691 {
30692 resultobj = SWIG_From_int((int)(result));
30693 }
30694 return resultobj;
30695 fail:
30696 return NULL;
30697 }
30698
30699
30700 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30701 PyObject *resultobj;
30702 wxWindow *arg1 = (wxWindow *) 0 ;
30703 int arg2 ;
30704 int arg3 ;
30705 wxRect *arg4 = (wxRect *) NULL ;
30706 PyObject * obj0 = 0 ;
30707 PyObject * obj1 = 0 ;
30708 PyObject * obj2 = 0 ;
30709 PyObject * obj3 = 0 ;
30710 char *kwnames[] = {
30711 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30712 };
30713
30714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30716 if (SWIG_arg_fail(1)) SWIG_fail;
30717 {
30718 arg2 = (int)(SWIG_As_int(obj1));
30719 if (SWIG_arg_fail(2)) SWIG_fail;
30720 }
30721 {
30722 arg3 = (int)(SWIG_As_int(obj2));
30723 if (SWIG_arg_fail(3)) SWIG_fail;
30724 }
30725 if (obj3) {
30726 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30727 if (SWIG_arg_fail(4)) SWIG_fail;
30728 }
30729 {
30730 PyThreadState* __tstate = wxPyBeginAllowThreads();
30731 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30732
30733 wxPyEndAllowThreads(__tstate);
30734 if (PyErr_Occurred()) SWIG_fail;
30735 }
30736 Py_INCREF(Py_None); resultobj = Py_None;
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30744 PyObject *resultobj;
30745 wxWindow *arg1 = (wxWindow *) 0 ;
30746 int arg2 ;
30747 bool result;
30748 PyObject * obj0 = 0 ;
30749 PyObject * obj1 = 0 ;
30750 char *kwnames[] = {
30751 (char *) "self",(char *) "lines", NULL
30752 };
30753
30754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30756 if (SWIG_arg_fail(1)) SWIG_fail;
30757 {
30758 arg2 = (int)(SWIG_As_int(obj1));
30759 if (SWIG_arg_fail(2)) SWIG_fail;
30760 }
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 result = (bool)(arg1)->ScrollLines(arg2);
30764
30765 wxPyEndAllowThreads(__tstate);
30766 if (PyErr_Occurred()) SWIG_fail;
30767 }
30768 {
30769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30770 }
30771 return resultobj;
30772 fail:
30773 return NULL;
30774 }
30775
30776
30777 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30778 PyObject *resultobj;
30779 wxWindow *arg1 = (wxWindow *) 0 ;
30780 int arg2 ;
30781 bool result;
30782 PyObject * obj0 = 0 ;
30783 PyObject * obj1 = 0 ;
30784 char *kwnames[] = {
30785 (char *) "self",(char *) "pages", NULL
30786 };
30787
30788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30790 if (SWIG_arg_fail(1)) SWIG_fail;
30791 {
30792 arg2 = (int)(SWIG_As_int(obj1));
30793 if (SWIG_arg_fail(2)) SWIG_fail;
30794 }
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = (bool)(arg1)->ScrollPages(arg2);
30798
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 {
30803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30804 }
30805 return resultobj;
30806 fail:
30807 return NULL;
30808 }
30809
30810
30811 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30812 PyObject *resultobj;
30813 wxWindow *arg1 = (wxWindow *) 0 ;
30814 bool result;
30815 PyObject * obj0 = 0 ;
30816 char *kwnames[] = {
30817 (char *) "self", NULL
30818 };
30819
30820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(1)) SWIG_fail;
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = (bool)(arg1)->LineUp();
30826
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 {
30831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30832 }
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj;
30841 wxWindow *arg1 = (wxWindow *) 0 ;
30842 bool result;
30843 PyObject * obj0 = 0 ;
30844 char *kwnames[] = {
30845 (char *) "self", NULL
30846 };
30847
30848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(1)) SWIG_fail;
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (bool)(arg1)->LineDown();
30854
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 {
30859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj;
30869 wxWindow *arg1 = (wxWindow *) 0 ;
30870 bool result;
30871 PyObject * obj0 = 0 ;
30872 char *kwnames[] = {
30873 (char *) "self", NULL
30874 };
30875
30876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30878 if (SWIG_arg_fail(1)) SWIG_fail;
30879 {
30880 PyThreadState* __tstate = wxPyBeginAllowThreads();
30881 result = (bool)(arg1)->PageUp();
30882
30883 wxPyEndAllowThreads(__tstate);
30884 if (PyErr_Occurred()) SWIG_fail;
30885 }
30886 {
30887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30888 }
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30896 PyObject *resultobj;
30897 wxWindow *arg1 = (wxWindow *) 0 ;
30898 bool result;
30899 PyObject * obj0 = 0 ;
30900 char *kwnames[] = {
30901 (char *) "self", NULL
30902 };
30903
30904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30906 if (SWIG_arg_fail(1)) SWIG_fail;
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (bool)(arg1)->PageDown();
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 {
30915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30916 }
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30924 PyObject *resultobj;
30925 wxWindow *arg1 = (wxWindow *) 0 ;
30926 wxString *arg2 = 0 ;
30927 bool temp2 = false ;
30928 PyObject * obj0 = 0 ;
30929 PyObject * obj1 = 0 ;
30930 char *kwnames[] = {
30931 (char *) "self",(char *) "text", NULL
30932 };
30933
30934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30936 if (SWIG_arg_fail(1)) SWIG_fail;
30937 {
30938 arg2 = wxString_in_helper(obj1);
30939 if (arg2 == NULL) SWIG_fail;
30940 temp2 = true;
30941 }
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 (arg1)->SetHelpText((wxString const &)*arg2);
30945
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 Py_INCREF(Py_None); resultobj = Py_None;
30950 {
30951 if (temp2)
30952 delete arg2;
30953 }
30954 return resultobj;
30955 fail:
30956 {
30957 if (temp2)
30958 delete arg2;
30959 }
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 wxString *arg2 = 0 ;
30968 bool temp2 = false ;
30969 PyObject * obj0 = 0 ;
30970 PyObject * obj1 = 0 ;
30971 char *kwnames[] = {
30972 (char *) "self",(char *) "text", NULL
30973 };
30974
30975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30977 if (SWIG_arg_fail(1)) SWIG_fail;
30978 {
30979 arg2 = wxString_in_helper(obj1);
30980 if (arg2 == NULL) SWIG_fail;
30981 temp2 = true;
30982 }
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30986
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 Py_INCREF(Py_None); resultobj = Py_None;
30991 {
30992 if (temp2)
30993 delete arg2;
30994 }
30995 return resultobj;
30996 fail:
30997 {
30998 if (temp2)
30999 delete arg2;
31000 }
31001 return NULL;
31002 }
31003
31004
31005 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31006 PyObject *resultobj;
31007 wxWindow *arg1 = (wxWindow *) 0 ;
31008 wxString result;
31009 PyObject * obj0 = 0 ;
31010 char *kwnames[] = {
31011 (char *) "self", NULL
31012 };
31013
31014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31016 if (SWIG_arg_fail(1)) SWIG_fail;
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 result = ((wxWindow const *)arg1)->GetHelpText();
31020
31021 wxPyEndAllowThreads(__tstate);
31022 if (PyErr_Occurred()) SWIG_fail;
31023 }
31024 {
31025 #if wxUSE_UNICODE
31026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31027 #else
31028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31029 #endif
31030 }
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31038 PyObject *resultobj;
31039 wxWindow *arg1 = (wxWindow *) 0 ;
31040 wxString *arg2 = 0 ;
31041 bool temp2 = false ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 char *kwnames[] = {
31045 (char *) "self",(char *) "tip", NULL
31046 };
31047
31048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31050 if (SWIG_arg_fail(1)) SWIG_fail;
31051 {
31052 arg2 = wxString_in_helper(obj1);
31053 if (arg2 == NULL) SWIG_fail;
31054 temp2 = true;
31055 }
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 (arg1)->SetToolTip((wxString const &)*arg2);
31059
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 Py_INCREF(Py_None); resultobj = Py_None;
31064 {
31065 if (temp2)
31066 delete arg2;
31067 }
31068 return resultobj;
31069 fail:
31070 {
31071 if (temp2)
31072 delete arg2;
31073 }
31074 return NULL;
31075 }
31076
31077
31078 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31079 PyObject *resultobj;
31080 wxWindow *arg1 = (wxWindow *) 0 ;
31081 wxToolTip *arg2 = (wxToolTip *) 0 ;
31082 PyObject * obj0 = 0 ;
31083 PyObject * obj1 = 0 ;
31084 char *kwnames[] = {
31085 (char *) "self",(char *) "tip", NULL
31086 };
31087
31088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(1)) SWIG_fail;
31091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31092 if (SWIG_arg_fail(2)) SWIG_fail;
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 (arg1)->SetToolTip(arg2);
31096
31097 wxPyEndAllowThreads(__tstate);
31098 if (PyErr_Occurred()) SWIG_fail;
31099 }
31100 Py_INCREF(Py_None); resultobj = Py_None;
31101 return resultobj;
31102 fail:
31103 return NULL;
31104 }
31105
31106
31107 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31108 PyObject *resultobj;
31109 wxWindow *arg1 = (wxWindow *) 0 ;
31110 wxToolTip *result;
31111 PyObject * obj0 = 0 ;
31112 char *kwnames[] = {
31113 (char *) "self", NULL
31114 };
31115
31116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31118 if (SWIG_arg_fail(1)) SWIG_fail;
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31122
31123 wxPyEndAllowThreads(__tstate);
31124 if (PyErr_Occurred()) SWIG_fail;
31125 }
31126 {
31127 resultobj = wxPyMake_wxObject(result, 0);
31128 }
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31136 PyObject *resultobj;
31137 wxWindow *arg1 = (wxWindow *) 0 ;
31138 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31139 PyObject * obj0 = 0 ;
31140 PyObject * obj1 = 0 ;
31141 char *kwnames[] = {
31142 (char *) "self",(char *) "dropTarget", NULL
31143 };
31144
31145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31147 if (SWIG_arg_fail(1)) SWIG_fail;
31148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31149 if (SWIG_arg_fail(2)) SWIG_fail;
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 (arg1)->SetDropTarget(arg2);
31153
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 Py_INCREF(Py_None); resultobj = Py_None;
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 wxPyDropTarget *result;
31168 PyObject * obj0 = 0 ;
31169 char *kwnames[] = {
31170 (char *) "self", NULL
31171 };
31172
31173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",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 = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31179
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31191 PyObject *resultobj;
31192 wxWindow *arg1 = (wxWindow *) 0 ;
31193 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31194 PyObject * obj0 = 0 ;
31195 PyObject * obj1 = 0 ;
31196 char *kwnames[] = {
31197 (char *) "self",(char *) "constraints", NULL
31198 };
31199
31200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31202 if (SWIG_arg_fail(1)) SWIG_fail;
31203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31204 if (SWIG_arg_fail(2)) SWIG_fail;
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 (arg1)->SetConstraints(arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 Py_INCREF(Py_None); resultobj = Py_None;
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 wxLayoutConstraints *result;
31223 PyObject * obj0 = 0 ;
31224 char *kwnames[] = {
31225 (char *) "self", NULL
31226 };
31227
31228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31230 if (SWIG_arg_fail(1)) SWIG_fail;
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31234
31235 wxPyEndAllowThreads(__tstate);
31236 if (PyErr_Occurred()) SWIG_fail;
31237 }
31238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31239 return resultobj;
31240 fail:
31241 return NULL;
31242 }
31243
31244
31245 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31246 PyObject *resultobj;
31247 wxWindow *arg1 = (wxWindow *) 0 ;
31248 bool arg2 ;
31249 PyObject * obj0 = 0 ;
31250 PyObject * obj1 = 0 ;
31251 char *kwnames[] = {
31252 (char *) "self",(char *) "autoLayout", NULL
31253 };
31254
31255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31257 if (SWIG_arg_fail(1)) SWIG_fail;
31258 {
31259 arg2 = (bool)(SWIG_As_bool(obj1));
31260 if (SWIG_arg_fail(2)) SWIG_fail;
31261 }
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 (arg1)->SetAutoLayout(arg2);
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 Py_INCREF(Py_None); resultobj = Py_None;
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj;
31278 wxWindow *arg1 = (wxWindow *) 0 ;
31279 bool result;
31280 PyObject * obj0 = 0 ;
31281 char *kwnames[] = {
31282 (char *) "self", NULL
31283 };
31284
31285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31287 if (SWIG_arg_fail(1)) SWIG_fail;
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31291
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 {
31296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31297 }
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31305 PyObject *resultobj;
31306 wxWindow *arg1 = (wxWindow *) 0 ;
31307 bool result;
31308 PyObject * obj0 = 0 ;
31309 char *kwnames[] = {
31310 (char *) "self", NULL
31311 };
31312
31313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31315 if (SWIG_arg_fail(1)) SWIG_fail;
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = (bool)(arg1)->Layout();
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 wxSizer *arg2 = (wxSizer *) 0 ;
31336 bool arg3 = (bool) true ;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 PyObject * obj2 = 0 ;
31340 char *kwnames[] = {
31341 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31342 };
31343
31344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31346 if (SWIG_arg_fail(1)) SWIG_fail;
31347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31348 if (SWIG_arg_fail(2)) SWIG_fail;
31349 if (obj2) {
31350 {
31351 arg3 = (bool)(SWIG_As_bool(obj2));
31352 if (SWIG_arg_fail(3)) SWIG_fail;
31353 }
31354 }
31355 {
31356 PyThreadState* __tstate = wxPyBeginAllowThreads();
31357 (arg1)->SetSizer(arg2,arg3);
31358
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 Py_INCREF(Py_None); resultobj = Py_None;
31363 return resultobj;
31364 fail:
31365 return NULL;
31366 }
31367
31368
31369 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31370 PyObject *resultobj;
31371 wxWindow *arg1 = (wxWindow *) 0 ;
31372 wxSizer *arg2 = (wxSizer *) 0 ;
31373 bool arg3 = (bool) true ;
31374 PyObject * obj0 = 0 ;
31375 PyObject * obj1 = 0 ;
31376 PyObject * obj2 = 0 ;
31377 char *kwnames[] = {
31378 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31379 };
31380
31381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31383 if (SWIG_arg_fail(1)) SWIG_fail;
31384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31385 if (SWIG_arg_fail(2)) SWIG_fail;
31386 if (obj2) {
31387 {
31388 arg3 = (bool)(SWIG_As_bool(obj2));
31389 if (SWIG_arg_fail(3)) SWIG_fail;
31390 }
31391 }
31392 {
31393 PyThreadState* __tstate = wxPyBeginAllowThreads();
31394 (arg1)->SetSizerAndFit(arg2,arg3);
31395
31396 wxPyEndAllowThreads(__tstate);
31397 if (PyErr_Occurred()) SWIG_fail;
31398 }
31399 Py_INCREF(Py_None); resultobj = Py_None;
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31407 PyObject *resultobj;
31408 wxWindow *arg1 = (wxWindow *) 0 ;
31409 wxSizer *result;
31410 PyObject * obj0 = 0 ;
31411 char *kwnames[] = {
31412 (char *) "self", NULL
31413 };
31414
31415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31417 if (SWIG_arg_fail(1)) SWIG_fail;
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31421
31422 wxPyEndAllowThreads(__tstate);
31423 if (PyErr_Occurred()) SWIG_fail;
31424 }
31425 {
31426 resultobj = wxPyMake_wxSizer(result, 0);
31427 }
31428 return resultobj;
31429 fail:
31430 return NULL;
31431 }
31432
31433
31434 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31435 PyObject *resultobj;
31436 wxWindow *arg1 = (wxWindow *) 0 ;
31437 wxSizer *arg2 = (wxSizer *) 0 ;
31438 PyObject * obj0 = 0 ;
31439 PyObject * obj1 = 0 ;
31440 char *kwnames[] = {
31441 (char *) "self",(char *) "sizer", NULL
31442 };
31443
31444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31446 if (SWIG_arg_fail(1)) SWIG_fail;
31447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31448 if (SWIG_arg_fail(2)) SWIG_fail;
31449 {
31450 PyThreadState* __tstate = wxPyBeginAllowThreads();
31451 (arg1)->SetContainingSizer(arg2);
31452
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 Py_INCREF(Py_None); resultobj = Py_None;
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31464 PyObject *resultobj;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 wxSizer *result;
31467 PyObject * obj0 = 0 ;
31468 char *kwnames[] = {
31469 (char *) "self", NULL
31470 };
31471
31472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31474 if (SWIG_arg_fail(1)) SWIG_fail;
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31478
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 {
31483 resultobj = wxPyMake_wxSizer(result, 0);
31484 }
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31492 PyObject *resultobj;
31493 wxWindow *arg1 = (wxWindow *) 0 ;
31494 PyObject * obj0 = 0 ;
31495 char *kwnames[] = {
31496 (char *) "self", NULL
31497 };
31498
31499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31501 if (SWIG_arg_fail(1)) SWIG_fail;
31502 {
31503 PyThreadState* __tstate = wxPyBeginAllowThreads();
31504 (arg1)->InheritAttributes();
31505
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 Py_INCREF(Py_None); resultobj = Py_None;
31510 return resultobj;
31511 fail:
31512 return NULL;
31513 }
31514
31515
31516 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31517 PyObject *resultobj;
31518 wxWindow *arg1 = (wxWindow *) 0 ;
31519 bool result;
31520 PyObject * obj0 = 0 ;
31521 char *kwnames[] = {
31522 (char *) "self", NULL
31523 };
31524
31525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31527 if (SWIG_arg_fail(1)) SWIG_fail;
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31531
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 {
31536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31537 }
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31545 PyObject *obj;
31546 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31547 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31548 Py_INCREF(obj);
31549 return Py_BuildValue((char *)"");
31550 }
31551 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31552 PyObject *resultobj;
31553 long arg1 ;
31554 wxWindow *arg2 = (wxWindow *) NULL ;
31555 wxWindow *result;
31556 PyObject * obj0 = 0 ;
31557 PyObject * obj1 = 0 ;
31558 char *kwnames[] = {
31559 (char *) "id",(char *) "parent", NULL
31560 };
31561
31562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31563 {
31564 arg1 = (long)(SWIG_As_long(obj0));
31565 if (SWIG_arg_fail(1)) SWIG_fail;
31566 }
31567 if (obj1) {
31568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31569 if (SWIG_arg_fail(2)) SWIG_fail;
31570 }
31571 {
31572 if (!wxPyCheckForApp()) SWIG_fail;
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 {
31580 resultobj = wxPyMake_wxObject(result, 0);
31581 }
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31589 PyObject *resultobj;
31590 wxString *arg1 = 0 ;
31591 wxWindow *arg2 = (wxWindow *) NULL ;
31592 wxWindow *result;
31593 bool temp1 = false ;
31594 PyObject * obj0 = 0 ;
31595 PyObject * obj1 = 0 ;
31596 char *kwnames[] = {
31597 (char *) "name",(char *) "parent", NULL
31598 };
31599
31600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31601 {
31602 arg1 = wxString_in_helper(obj0);
31603 if (arg1 == NULL) SWIG_fail;
31604 temp1 = true;
31605 }
31606 if (obj1) {
31607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31608 if (SWIG_arg_fail(2)) SWIG_fail;
31609 }
31610 {
31611 if (!wxPyCheckForApp()) SWIG_fail;
31612 PyThreadState* __tstate = wxPyBeginAllowThreads();
31613 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31614
31615 wxPyEndAllowThreads(__tstate);
31616 if (PyErr_Occurred()) SWIG_fail;
31617 }
31618 {
31619 resultobj = wxPyMake_wxObject(result, 0);
31620 }
31621 {
31622 if (temp1)
31623 delete arg1;
31624 }
31625 return resultobj;
31626 fail:
31627 {
31628 if (temp1)
31629 delete arg1;
31630 }
31631 return NULL;
31632 }
31633
31634
31635 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31636 PyObject *resultobj;
31637 wxString *arg1 = 0 ;
31638 wxWindow *arg2 = (wxWindow *) NULL ;
31639 wxWindow *result;
31640 bool temp1 = false ;
31641 PyObject * obj0 = 0 ;
31642 PyObject * obj1 = 0 ;
31643 char *kwnames[] = {
31644 (char *) "label",(char *) "parent", NULL
31645 };
31646
31647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31648 {
31649 arg1 = wxString_in_helper(obj0);
31650 if (arg1 == NULL) SWIG_fail;
31651 temp1 = true;
31652 }
31653 if (obj1) {
31654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31655 if (SWIG_arg_fail(2)) SWIG_fail;
31656 }
31657 {
31658 if (!wxPyCheckForApp()) SWIG_fail;
31659 PyThreadState* __tstate = wxPyBeginAllowThreads();
31660 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31661
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 {
31666 resultobj = wxPyMake_wxObject(result, 0);
31667 }
31668 {
31669 if (temp1)
31670 delete arg1;
31671 }
31672 return resultobj;
31673 fail:
31674 {
31675 if (temp1)
31676 delete arg1;
31677 }
31678 return NULL;
31679 }
31680
31681
31682 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31683 PyObject *resultobj;
31684 wxWindow *arg1 = (wxWindow *) 0 ;
31685 unsigned long arg2 ;
31686 wxWindow *result;
31687 PyObject * obj0 = 0 ;
31688 PyObject * obj1 = 0 ;
31689 char *kwnames[] = {
31690 (char *) "parent",(char *) "_hWnd", NULL
31691 };
31692
31693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31695 if (SWIG_arg_fail(1)) SWIG_fail;
31696 {
31697 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31698 if (SWIG_arg_fail(2)) SWIG_fail;
31699 }
31700 {
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = wxPyMake_wxObject(result, 0);
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj;
31718 wxValidator *result;
31719 char *kwnames[] = {
31720 NULL
31721 };
31722
31723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (wxValidator *)new wxValidator();
31727
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31739 PyObject *resultobj;
31740 wxValidator *arg1 = (wxValidator *) 0 ;
31741 wxValidator *result;
31742 PyObject * obj0 = 0 ;
31743 char *kwnames[] = {
31744 (char *) "self", NULL
31745 };
31746
31747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31749 if (SWIG_arg_fail(1)) SWIG_fail;
31750 {
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 result = (wxValidator *)(arg1)->Clone();
31753
31754 wxPyEndAllowThreads(__tstate);
31755 if (PyErr_Occurred()) SWIG_fail;
31756 }
31757 {
31758 resultobj = wxPyMake_wxObject(result, 0);
31759 }
31760 return resultobj;
31761 fail:
31762 return NULL;
31763 }
31764
31765
31766 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31767 PyObject *resultobj;
31768 wxValidator *arg1 = (wxValidator *) 0 ;
31769 wxWindow *arg2 = (wxWindow *) 0 ;
31770 bool result;
31771 PyObject * obj0 = 0 ;
31772 PyObject * obj1 = 0 ;
31773 char *kwnames[] = {
31774 (char *) "self",(char *) "parent", NULL
31775 };
31776
31777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31779 if (SWIG_arg_fail(1)) SWIG_fail;
31780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31781 if (SWIG_arg_fail(2)) SWIG_fail;
31782 {
31783 PyThreadState* __tstate = wxPyBeginAllowThreads();
31784 result = (bool)(arg1)->Validate(arg2);
31785
31786 wxPyEndAllowThreads(__tstate);
31787 if (PyErr_Occurred()) SWIG_fail;
31788 }
31789 {
31790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31791 }
31792 return resultobj;
31793 fail:
31794 return NULL;
31795 }
31796
31797
31798 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31799 PyObject *resultobj;
31800 wxValidator *arg1 = (wxValidator *) 0 ;
31801 bool result;
31802 PyObject * obj0 = 0 ;
31803 char *kwnames[] = {
31804 (char *) "self", NULL
31805 };
31806
31807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31809 if (SWIG_arg_fail(1)) SWIG_fail;
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (bool)(arg1)->TransferToWindow();
31813
31814 wxPyEndAllowThreads(__tstate);
31815 if (PyErr_Occurred()) SWIG_fail;
31816 }
31817 {
31818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31819 }
31820 return resultobj;
31821 fail:
31822 return NULL;
31823 }
31824
31825
31826 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31827 PyObject *resultobj;
31828 wxValidator *arg1 = (wxValidator *) 0 ;
31829 bool result;
31830 PyObject * obj0 = 0 ;
31831 char *kwnames[] = {
31832 (char *) "self", NULL
31833 };
31834
31835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31837 if (SWIG_arg_fail(1)) SWIG_fail;
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 result = (bool)(arg1)->TransferFromWindow();
31841
31842 wxPyEndAllowThreads(__tstate);
31843 if (PyErr_Occurred()) SWIG_fail;
31844 }
31845 {
31846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31847 }
31848 return resultobj;
31849 fail:
31850 return NULL;
31851 }
31852
31853
31854 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31855 PyObject *resultobj;
31856 wxValidator *arg1 = (wxValidator *) 0 ;
31857 wxWindow *result;
31858 PyObject * obj0 = 0 ;
31859 char *kwnames[] = {
31860 (char *) "self", NULL
31861 };
31862
31863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31865 if (SWIG_arg_fail(1)) SWIG_fail;
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (wxWindow *)(arg1)->GetWindow();
31869
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 {
31874 resultobj = wxPyMake_wxObject(result, 0);
31875 }
31876 return resultobj;
31877 fail:
31878 return NULL;
31879 }
31880
31881
31882 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31883 PyObject *resultobj;
31884 wxValidator *arg1 = (wxValidator *) 0 ;
31885 wxWindow *arg2 = (wxWindow *) 0 ;
31886 PyObject * obj0 = 0 ;
31887 PyObject * obj1 = 0 ;
31888 char *kwnames[] = {
31889 (char *) "self",(char *) "window", NULL
31890 };
31891
31892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31894 if (SWIG_arg_fail(1)) SWIG_fail;
31895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31896 if (SWIG_arg_fail(2)) SWIG_fail;
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 (arg1)->SetWindow(arg2);
31900
31901 wxPyEndAllowThreads(__tstate);
31902 if (PyErr_Occurred()) SWIG_fail;
31903 }
31904 Py_INCREF(Py_None); resultobj = Py_None;
31905 return resultobj;
31906 fail:
31907 return NULL;
31908 }
31909
31910
31911 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31912 PyObject *resultobj;
31913 bool result;
31914 char *kwnames[] = {
31915 NULL
31916 };
31917
31918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31919 {
31920 PyThreadState* __tstate = wxPyBeginAllowThreads();
31921 result = (bool)wxValidator::IsSilent();
31922
31923 wxPyEndAllowThreads(__tstate);
31924 if (PyErr_Occurred()) SWIG_fail;
31925 }
31926 {
31927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31928 }
31929 return resultobj;
31930 fail:
31931 return NULL;
31932 }
31933
31934
31935 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31936 PyObject *resultobj;
31937 int arg1 = (int) true ;
31938 PyObject * obj0 = 0 ;
31939 char *kwnames[] = {
31940 (char *) "doIt", NULL
31941 };
31942
31943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31944 if (obj0) {
31945 {
31946 arg1 = (int)(SWIG_As_int(obj0));
31947 if (SWIG_arg_fail(1)) SWIG_fail;
31948 }
31949 }
31950 {
31951 PyThreadState* __tstate = wxPyBeginAllowThreads();
31952 wxValidator::SetBellOnError(arg1);
31953
31954 wxPyEndAllowThreads(__tstate);
31955 if (PyErr_Occurred()) SWIG_fail;
31956 }
31957 Py_INCREF(Py_None); resultobj = Py_None;
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31965 PyObject *obj;
31966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31967 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31968 Py_INCREF(obj);
31969 return Py_BuildValue((char *)"");
31970 }
31971 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31972 PyObject *resultobj;
31973 wxPyValidator *result;
31974 char *kwnames[] = {
31975 NULL
31976 };
31977
31978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 result = (wxPyValidator *)new wxPyValidator();
31982
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31994 PyObject *resultobj;
31995 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31996 PyObject *arg2 = (PyObject *) 0 ;
31997 PyObject *arg3 = (PyObject *) 0 ;
31998 int arg4 = (int) true ;
31999 PyObject * obj0 = 0 ;
32000 PyObject * obj1 = 0 ;
32001 PyObject * obj2 = 0 ;
32002 PyObject * obj3 = 0 ;
32003 char *kwnames[] = {
32004 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32005 };
32006
32007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32009 if (SWIG_arg_fail(1)) SWIG_fail;
32010 arg2 = obj1;
32011 arg3 = obj2;
32012 if (obj3) {
32013 {
32014 arg4 = (int)(SWIG_As_int(obj3));
32015 if (SWIG_arg_fail(4)) SWIG_fail;
32016 }
32017 }
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32021
32022 wxPyEndAllowThreads(__tstate);
32023 if (PyErr_Occurred()) SWIG_fail;
32024 }
32025 Py_INCREF(Py_None); resultobj = Py_None;
32026 return resultobj;
32027 fail:
32028 return NULL;
32029 }
32030
32031
32032 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32033 PyObject *obj;
32034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32035 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32036 Py_INCREF(obj);
32037 return Py_BuildValue((char *)"");
32038 }
32039 static int _wrap_DefaultValidator_set(PyObject *) {
32040 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32041 return 1;
32042 }
32043
32044
32045 static PyObject *_wrap_DefaultValidator_get(void) {
32046 PyObject *pyobj;
32047
32048 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32049 return pyobj;
32050 }
32051
32052
32053 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32054 PyObject *resultobj;
32055 wxString const &arg1_defvalue = wxPyEmptyString ;
32056 wxString *arg1 = (wxString *) &arg1_defvalue ;
32057 long arg2 = (long) 0 ;
32058 wxMenu *result;
32059 bool temp1 = false ;
32060 PyObject * obj0 = 0 ;
32061 PyObject * obj1 = 0 ;
32062 char *kwnames[] = {
32063 (char *) "title",(char *) "style", NULL
32064 };
32065
32066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32067 if (obj0) {
32068 {
32069 arg1 = wxString_in_helper(obj0);
32070 if (arg1 == NULL) SWIG_fail;
32071 temp1 = true;
32072 }
32073 }
32074 if (obj1) {
32075 {
32076 arg2 = (long)(SWIG_As_long(obj1));
32077 if (SWIG_arg_fail(2)) SWIG_fail;
32078 }
32079 }
32080 {
32081 if (!wxPyCheckForApp()) SWIG_fail;
32082 PyThreadState* __tstate = wxPyBeginAllowThreads();
32083 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32084
32085 wxPyEndAllowThreads(__tstate);
32086 if (PyErr_Occurred()) SWIG_fail;
32087 }
32088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32089 {
32090 if (temp1)
32091 delete arg1;
32092 }
32093 return resultobj;
32094 fail:
32095 {
32096 if (temp1)
32097 delete arg1;
32098 }
32099 return NULL;
32100 }
32101
32102
32103 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj;
32105 wxMenu *arg1 = (wxMenu *) 0 ;
32106 int arg2 ;
32107 wxString *arg3 = 0 ;
32108 wxString const &arg4_defvalue = wxPyEmptyString ;
32109 wxString *arg4 = (wxString *) &arg4_defvalue ;
32110 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32111 wxMenuItem *result;
32112 bool temp3 = false ;
32113 bool temp4 = false ;
32114 PyObject * obj0 = 0 ;
32115 PyObject * obj1 = 0 ;
32116 PyObject * obj2 = 0 ;
32117 PyObject * obj3 = 0 ;
32118 PyObject * obj4 = 0 ;
32119 char *kwnames[] = {
32120 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32121 };
32122
32123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32125 if (SWIG_arg_fail(1)) SWIG_fail;
32126 {
32127 arg2 = (int)(SWIG_As_int(obj1));
32128 if (SWIG_arg_fail(2)) SWIG_fail;
32129 }
32130 {
32131 arg3 = wxString_in_helper(obj2);
32132 if (arg3 == NULL) SWIG_fail;
32133 temp3 = true;
32134 }
32135 if (obj3) {
32136 {
32137 arg4 = wxString_in_helper(obj3);
32138 if (arg4 == NULL) SWIG_fail;
32139 temp4 = true;
32140 }
32141 }
32142 if (obj4) {
32143 {
32144 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32145 if (SWIG_arg_fail(5)) SWIG_fail;
32146 }
32147 }
32148 {
32149 PyThreadState* __tstate = wxPyBeginAllowThreads();
32150 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32151
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 {
32156 resultobj = wxPyMake_wxObject(result, 0);
32157 }
32158 {
32159 if (temp3)
32160 delete arg3;
32161 }
32162 {
32163 if (temp4)
32164 delete arg4;
32165 }
32166 return resultobj;
32167 fail:
32168 {
32169 if (temp3)
32170 delete arg3;
32171 }
32172 {
32173 if (temp4)
32174 delete arg4;
32175 }
32176 return NULL;
32177 }
32178
32179
32180 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32181 PyObject *resultobj;
32182 wxMenu *arg1 = (wxMenu *) 0 ;
32183 wxMenuItem *result;
32184 PyObject * obj0 = 0 ;
32185 char *kwnames[] = {
32186 (char *) "self", NULL
32187 };
32188
32189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32191 if (SWIG_arg_fail(1)) SWIG_fail;
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (wxMenuItem *)(arg1)->AppendSeparator();
32195
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 {
32200 resultobj = wxPyMake_wxObject(result, 0);
32201 }
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32209 PyObject *resultobj;
32210 wxMenu *arg1 = (wxMenu *) 0 ;
32211 int arg2 ;
32212 wxString *arg3 = 0 ;
32213 wxString const &arg4_defvalue = wxPyEmptyString ;
32214 wxString *arg4 = (wxString *) &arg4_defvalue ;
32215 wxMenuItem *result;
32216 bool temp3 = false ;
32217 bool temp4 = false ;
32218 PyObject * obj0 = 0 ;
32219 PyObject * obj1 = 0 ;
32220 PyObject * obj2 = 0 ;
32221 PyObject * obj3 = 0 ;
32222 char *kwnames[] = {
32223 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32224 };
32225
32226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32228 if (SWIG_arg_fail(1)) SWIG_fail;
32229 {
32230 arg2 = (int)(SWIG_As_int(obj1));
32231 if (SWIG_arg_fail(2)) SWIG_fail;
32232 }
32233 {
32234 arg3 = wxString_in_helper(obj2);
32235 if (arg3 == NULL) SWIG_fail;
32236 temp3 = true;
32237 }
32238 if (obj3) {
32239 {
32240 arg4 = wxString_in_helper(obj3);
32241 if (arg4 == NULL) SWIG_fail;
32242 temp4 = true;
32243 }
32244 }
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32248
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 {
32253 resultobj = wxPyMake_wxObject(result, 0);
32254 }
32255 {
32256 if (temp3)
32257 delete arg3;
32258 }
32259 {
32260 if (temp4)
32261 delete arg4;
32262 }
32263 return resultobj;
32264 fail:
32265 {
32266 if (temp3)
32267 delete arg3;
32268 }
32269 {
32270 if (temp4)
32271 delete arg4;
32272 }
32273 return NULL;
32274 }
32275
32276
32277 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32278 PyObject *resultobj;
32279 wxMenu *arg1 = (wxMenu *) 0 ;
32280 int arg2 ;
32281 wxString *arg3 = 0 ;
32282 wxString const &arg4_defvalue = wxPyEmptyString ;
32283 wxString *arg4 = (wxString *) &arg4_defvalue ;
32284 wxMenuItem *result;
32285 bool temp3 = false ;
32286 bool temp4 = false ;
32287 PyObject * obj0 = 0 ;
32288 PyObject * obj1 = 0 ;
32289 PyObject * obj2 = 0 ;
32290 PyObject * obj3 = 0 ;
32291 char *kwnames[] = {
32292 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32293 };
32294
32295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32297 if (SWIG_arg_fail(1)) SWIG_fail;
32298 {
32299 arg2 = (int)(SWIG_As_int(obj1));
32300 if (SWIG_arg_fail(2)) SWIG_fail;
32301 }
32302 {
32303 arg3 = wxString_in_helper(obj2);
32304 if (arg3 == NULL) SWIG_fail;
32305 temp3 = true;
32306 }
32307 if (obj3) {
32308 {
32309 arg4 = wxString_in_helper(obj3);
32310 if (arg4 == NULL) SWIG_fail;
32311 temp4 = true;
32312 }
32313 }
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32317
32318 wxPyEndAllowThreads(__tstate);
32319 if (PyErr_Occurred()) SWIG_fail;
32320 }
32321 {
32322 resultobj = wxPyMake_wxObject(result, 0);
32323 }
32324 {
32325 if (temp3)
32326 delete arg3;
32327 }
32328 {
32329 if (temp4)
32330 delete arg4;
32331 }
32332 return resultobj;
32333 fail:
32334 {
32335 if (temp3)
32336 delete arg3;
32337 }
32338 {
32339 if (temp4)
32340 delete arg4;
32341 }
32342 return NULL;
32343 }
32344
32345
32346 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32347 PyObject *resultobj;
32348 wxMenu *arg1 = (wxMenu *) 0 ;
32349 int arg2 ;
32350 wxString *arg3 = 0 ;
32351 wxMenu *arg4 = (wxMenu *) 0 ;
32352 wxString const &arg5_defvalue = wxPyEmptyString ;
32353 wxString *arg5 = (wxString *) &arg5_defvalue ;
32354 wxMenuItem *result;
32355 bool temp3 = false ;
32356 bool temp5 = false ;
32357 PyObject * obj0 = 0 ;
32358 PyObject * obj1 = 0 ;
32359 PyObject * obj2 = 0 ;
32360 PyObject * obj3 = 0 ;
32361 PyObject * obj4 = 0 ;
32362 char *kwnames[] = {
32363 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32364 };
32365
32366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32368 if (SWIG_arg_fail(1)) SWIG_fail;
32369 {
32370 arg2 = (int)(SWIG_As_int(obj1));
32371 if (SWIG_arg_fail(2)) SWIG_fail;
32372 }
32373 {
32374 arg3 = wxString_in_helper(obj2);
32375 if (arg3 == NULL) SWIG_fail;
32376 temp3 = true;
32377 }
32378 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32379 if (SWIG_arg_fail(4)) SWIG_fail;
32380 if (obj4) {
32381 {
32382 arg5 = wxString_in_helper(obj4);
32383 if (arg5 == NULL) SWIG_fail;
32384 temp5 = true;
32385 }
32386 }
32387 {
32388 PyThreadState* __tstate = wxPyBeginAllowThreads();
32389 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32390
32391 wxPyEndAllowThreads(__tstate);
32392 if (PyErr_Occurred()) SWIG_fail;
32393 }
32394 {
32395 resultobj = wxPyMake_wxObject(result, 0);
32396 }
32397 {
32398 if (temp3)
32399 delete arg3;
32400 }
32401 {
32402 if (temp5)
32403 delete arg5;
32404 }
32405 return resultobj;
32406 fail:
32407 {
32408 if (temp3)
32409 delete arg3;
32410 }
32411 {
32412 if (temp5)
32413 delete arg5;
32414 }
32415 return NULL;
32416 }
32417
32418
32419 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32420 PyObject *resultobj;
32421 wxMenu *arg1 = (wxMenu *) 0 ;
32422 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32423 wxMenuItem *result;
32424 PyObject * obj0 = 0 ;
32425 PyObject * obj1 = 0 ;
32426 char *kwnames[] = {
32427 (char *) "self",(char *) "item", NULL
32428 };
32429
32430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32432 if (SWIG_arg_fail(1)) SWIG_fail;
32433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32434 if (SWIG_arg_fail(2)) SWIG_fail;
32435 {
32436 PyThreadState* __tstate = wxPyBeginAllowThreads();
32437 result = (wxMenuItem *)(arg1)->Append(arg2);
32438
32439 wxPyEndAllowThreads(__tstate);
32440 if (PyErr_Occurred()) SWIG_fail;
32441 }
32442 {
32443 resultobj = wxPyMake_wxObject(result, 0);
32444 }
32445 return resultobj;
32446 fail:
32447 return NULL;
32448 }
32449
32450
32451 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32452 PyObject *resultobj;
32453 wxMenu *arg1 = (wxMenu *) 0 ;
32454 PyObject * obj0 = 0 ;
32455 char *kwnames[] = {
32456 (char *) "self", NULL
32457 };
32458
32459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32461 if (SWIG_arg_fail(1)) SWIG_fail;
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 (arg1)->Break();
32465
32466 wxPyEndAllowThreads(__tstate);
32467 if (PyErr_Occurred()) SWIG_fail;
32468 }
32469 Py_INCREF(Py_None); resultobj = Py_None;
32470 return resultobj;
32471 fail:
32472 return NULL;
32473 }
32474
32475
32476 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32477 PyObject *resultobj;
32478 wxMenu *arg1 = (wxMenu *) 0 ;
32479 size_t arg2 ;
32480 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32481 wxMenuItem *result;
32482 PyObject * obj0 = 0 ;
32483 PyObject * obj1 = 0 ;
32484 PyObject * obj2 = 0 ;
32485 char *kwnames[] = {
32486 (char *) "self",(char *) "pos",(char *) "item", NULL
32487 };
32488
32489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32491 if (SWIG_arg_fail(1)) SWIG_fail;
32492 {
32493 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32494 if (SWIG_arg_fail(2)) SWIG_fail;
32495 }
32496 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32497 if (SWIG_arg_fail(3)) SWIG_fail;
32498 {
32499 PyThreadState* __tstate = wxPyBeginAllowThreads();
32500 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32501
32502 wxPyEndAllowThreads(__tstate);
32503 if (PyErr_Occurred()) SWIG_fail;
32504 }
32505 {
32506 resultobj = wxPyMake_wxObject(result, 0);
32507 }
32508 return resultobj;
32509 fail:
32510 return NULL;
32511 }
32512
32513
32514 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32515 PyObject *resultobj;
32516 wxMenu *arg1 = (wxMenu *) 0 ;
32517 size_t arg2 ;
32518 int arg3 ;
32519 wxString *arg4 = 0 ;
32520 wxString const &arg5_defvalue = wxPyEmptyString ;
32521 wxString *arg5 = (wxString *) &arg5_defvalue ;
32522 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32523 wxMenuItem *result;
32524 bool temp4 = false ;
32525 bool temp5 = false ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 PyObject * obj2 = 0 ;
32529 PyObject * obj3 = 0 ;
32530 PyObject * obj4 = 0 ;
32531 PyObject * obj5 = 0 ;
32532 char *kwnames[] = {
32533 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32534 };
32535
32536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32538 if (SWIG_arg_fail(1)) SWIG_fail;
32539 {
32540 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32541 if (SWIG_arg_fail(2)) SWIG_fail;
32542 }
32543 {
32544 arg3 = (int)(SWIG_As_int(obj2));
32545 if (SWIG_arg_fail(3)) SWIG_fail;
32546 }
32547 {
32548 arg4 = wxString_in_helper(obj3);
32549 if (arg4 == NULL) SWIG_fail;
32550 temp4 = true;
32551 }
32552 if (obj4) {
32553 {
32554 arg5 = wxString_in_helper(obj4);
32555 if (arg5 == NULL) SWIG_fail;
32556 temp5 = true;
32557 }
32558 }
32559 if (obj5) {
32560 {
32561 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32562 if (SWIG_arg_fail(6)) SWIG_fail;
32563 }
32564 }
32565 {
32566 PyThreadState* __tstate = wxPyBeginAllowThreads();
32567 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32568
32569 wxPyEndAllowThreads(__tstate);
32570 if (PyErr_Occurred()) SWIG_fail;
32571 }
32572 {
32573 resultobj = wxPyMake_wxObject(result, 0);
32574 }
32575 {
32576 if (temp4)
32577 delete arg4;
32578 }
32579 {
32580 if (temp5)
32581 delete arg5;
32582 }
32583 return resultobj;
32584 fail:
32585 {
32586 if (temp4)
32587 delete arg4;
32588 }
32589 {
32590 if (temp5)
32591 delete arg5;
32592 }
32593 return NULL;
32594 }
32595
32596
32597 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32598 PyObject *resultobj;
32599 wxMenu *arg1 = (wxMenu *) 0 ;
32600 size_t arg2 ;
32601 wxMenuItem *result;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 char *kwnames[] = {
32605 (char *) "self",(char *) "pos", NULL
32606 };
32607
32608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32610 if (SWIG_arg_fail(1)) SWIG_fail;
32611 {
32612 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32613 if (SWIG_arg_fail(2)) SWIG_fail;
32614 }
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32618
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 {
32623 resultobj = wxPyMake_wxObject(result, 0);
32624 }
32625 return resultobj;
32626 fail:
32627 return NULL;
32628 }
32629
32630
32631 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32632 PyObject *resultobj;
32633 wxMenu *arg1 = (wxMenu *) 0 ;
32634 size_t arg2 ;
32635 int arg3 ;
32636 wxString *arg4 = 0 ;
32637 wxString const &arg5_defvalue = wxPyEmptyString ;
32638 wxString *arg5 = (wxString *) &arg5_defvalue ;
32639 wxMenuItem *result;
32640 bool temp4 = false ;
32641 bool temp5 = false ;
32642 PyObject * obj0 = 0 ;
32643 PyObject * obj1 = 0 ;
32644 PyObject * obj2 = 0 ;
32645 PyObject * obj3 = 0 ;
32646 PyObject * obj4 = 0 ;
32647 char *kwnames[] = {
32648 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32649 };
32650
32651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32653 if (SWIG_arg_fail(1)) SWIG_fail;
32654 {
32655 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32656 if (SWIG_arg_fail(2)) SWIG_fail;
32657 }
32658 {
32659 arg3 = (int)(SWIG_As_int(obj2));
32660 if (SWIG_arg_fail(3)) SWIG_fail;
32661 }
32662 {
32663 arg4 = wxString_in_helper(obj3);
32664 if (arg4 == NULL) SWIG_fail;
32665 temp4 = true;
32666 }
32667 if (obj4) {
32668 {
32669 arg5 = wxString_in_helper(obj4);
32670 if (arg5 == NULL) SWIG_fail;
32671 temp5 = true;
32672 }
32673 }
32674 {
32675 PyThreadState* __tstate = wxPyBeginAllowThreads();
32676 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32677
32678 wxPyEndAllowThreads(__tstate);
32679 if (PyErr_Occurred()) SWIG_fail;
32680 }
32681 {
32682 resultobj = wxPyMake_wxObject(result, 0);
32683 }
32684 {
32685 if (temp4)
32686 delete arg4;
32687 }
32688 {
32689 if (temp5)
32690 delete arg5;
32691 }
32692 return resultobj;
32693 fail:
32694 {
32695 if (temp4)
32696 delete arg4;
32697 }
32698 {
32699 if (temp5)
32700 delete arg5;
32701 }
32702 return NULL;
32703 }
32704
32705
32706 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32707 PyObject *resultobj;
32708 wxMenu *arg1 = (wxMenu *) 0 ;
32709 size_t arg2 ;
32710 int arg3 ;
32711 wxString *arg4 = 0 ;
32712 wxString const &arg5_defvalue = wxPyEmptyString ;
32713 wxString *arg5 = (wxString *) &arg5_defvalue ;
32714 wxMenuItem *result;
32715 bool temp4 = false ;
32716 bool temp5 = false ;
32717 PyObject * obj0 = 0 ;
32718 PyObject * obj1 = 0 ;
32719 PyObject * obj2 = 0 ;
32720 PyObject * obj3 = 0 ;
32721 PyObject * obj4 = 0 ;
32722 char *kwnames[] = {
32723 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32724 };
32725
32726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32728 if (SWIG_arg_fail(1)) SWIG_fail;
32729 {
32730 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32731 if (SWIG_arg_fail(2)) SWIG_fail;
32732 }
32733 {
32734 arg3 = (int)(SWIG_As_int(obj2));
32735 if (SWIG_arg_fail(3)) SWIG_fail;
32736 }
32737 {
32738 arg4 = wxString_in_helper(obj3);
32739 if (arg4 == NULL) SWIG_fail;
32740 temp4 = true;
32741 }
32742 if (obj4) {
32743 {
32744 arg5 = wxString_in_helper(obj4);
32745 if (arg5 == NULL) SWIG_fail;
32746 temp5 = true;
32747 }
32748 }
32749 {
32750 PyThreadState* __tstate = wxPyBeginAllowThreads();
32751 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32752
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 {
32757 resultobj = wxPyMake_wxObject(result, 0);
32758 }
32759 {
32760 if (temp4)
32761 delete arg4;
32762 }
32763 {
32764 if (temp5)
32765 delete arg5;
32766 }
32767 return resultobj;
32768 fail:
32769 {
32770 if (temp4)
32771 delete arg4;
32772 }
32773 {
32774 if (temp5)
32775 delete arg5;
32776 }
32777 return NULL;
32778 }
32779
32780
32781 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32782 PyObject *resultobj;
32783 wxMenu *arg1 = (wxMenu *) 0 ;
32784 size_t arg2 ;
32785 int arg3 ;
32786 wxString *arg4 = 0 ;
32787 wxMenu *arg5 = (wxMenu *) 0 ;
32788 wxString const &arg6_defvalue = wxPyEmptyString ;
32789 wxString *arg6 = (wxString *) &arg6_defvalue ;
32790 wxMenuItem *result;
32791 bool temp4 = false ;
32792 bool temp6 = false ;
32793 PyObject * obj0 = 0 ;
32794 PyObject * obj1 = 0 ;
32795 PyObject * obj2 = 0 ;
32796 PyObject * obj3 = 0 ;
32797 PyObject * obj4 = 0 ;
32798 PyObject * obj5 = 0 ;
32799 char *kwnames[] = {
32800 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32801 };
32802
32803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32805 if (SWIG_arg_fail(1)) SWIG_fail;
32806 {
32807 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32808 if (SWIG_arg_fail(2)) SWIG_fail;
32809 }
32810 {
32811 arg3 = (int)(SWIG_As_int(obj2));
32812 if (SWIG_arg_fail(3)) SWIG_fail;
32813 }
32814 {
32815 arg4 = wxString_in_helper(obj3);
32816 if (arg4 == NULL) SWIG_fail;
32817 temp4 = true;
32818 }
32819 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32820 if (SWIG_arg_fail(5)) SWIG_fail;
32821 if (obj5) {
32822 {
32823 arg6 = wxString_in_helper(obj5);
32824 if (arg6 == NULL) SWIG_fail;
32825 temp6 = true;
32826 }
32827 }
32828 {
32829 PyThreadState* __tstate = wxPyBeginAllowThreads();
32830 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32831
32832 wxPyEndAllowThreads(__tstate);
32833 if (PyErr_Occurred()) SWIG_fail;
32834 }
32835 {
32836 resultobj = wxPyMake_wxObject(result, 0);
32837 }
32838 {
32839 if (temp4)
32840 delete arg4;
32841 }
32842 {
32843 if (temp6)
32844 delete arg6;
32845 }
32846 return resultobj;
32847 fail:
32848 {
32849 if (temp4)
32850 delete arg4;
32851 }
32852 {
32853 if (temp6)
32854 delete arg6;
32855 }
32856 return NULL;
32857 }
32858
32859
32860 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32861 PyObject *resultobj;
32862 wxMenu *arg1 = (wxMenu *) 0 ;
32863 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32864 wxMenuItem *result;
32865 PyObject * obj0 = 0 ;
32866 PyObject * obj1 = 0 ;
32867 char *kwnames[] = {
32868 (char *) "self",(char *) "item", NULL
32869 };
32870
32871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32873 if (SWIG_arg_fail(1)) SWIG_fail;
32874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32875 if (SWIG_arg_fail(2)) SWIG_fail;
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32879
32880 wxPyEndAllowThreads(__tstate);
32881 if (PyErr_Occurred()) SWIG_fail;
32882 }
32883 {
32884 resultobj = wxPyMake_wxObject(result, 0);
32885 }
32886 return resultobj;
32887 fail:
32888 return NULL;
32889 }
32890
32891
32892 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32893 PyObject *resultobj;
32894 wxMenu *arg1 = (wxMenu *) 0 ;
32895 int arg2 ;
32896 wxString *arg3 = 0 ;
32897 wxString const &arg4_defvalue = wxPyEmptyString ;
32898 wxString *arg4 = (wxString *) &arg4_defvalue ;
32899 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32900 wxMenuItem *result;
32901 bool temp3 = false ;
32902 bool temp4 = false ;
32903 PyObject * obj0 = 0 ;
32904 PyObject * obj1 = 0 ;
32905 PyObject * obj2 = 0 ;
32906 PyObject * obj3 = 0 ;
32907 PyObject * obj4 = 0 ;
32908 char *kwnames[] = {
32909 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32910 };
32911
32912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32914 if (SWIG_arg_fail(1)) SWIG_fail;
32915 {
32916 arg2 = (int)(SWIG_As_int(obj1));
32917 if (SWIG_arg_fail(2)) SWIG_fail;
32918 }
32919 {
32920 arg3 = wxString_in_helper(obj2);
32921 if (arg3 == NULL) SWIG_fail;
32922 temp3 = true;
32923 }
32924 if (obj3) {
32925 {
32926 arg4 = wxString_in_helper(obj3);
32927 if (arg4 == NULL) SWIG_fail;
32928 temp4 = true;
32929 }
32930 }
32931 if (obj4) {
32932 {
32933 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32934 if (SWIG_arg_fail(5)) SWIG_fail;
32935 }
32936 }
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32940
32941 wxPyEndAllowThreads(__tstate);
32942 if (PyErr_Occurred()) SWIG_fail;
32943 }
32944 {
32945 resultobj = wxPyMake_wxObject(result, 0);
32946 }
32947 {
32948 if (temp3)
32949 delete arg3;
32950 }
32951 {
32952 if (temp4)
32953 delete arg4;
32954 }
32955 return resultobj;
32956 fail:
32957 {
32958 if (temp3)
32959 delete arg3;
32960 }
32961 {
32962 if (temp4)
32963 delete arg4;
32964 }
32965 return NULL;
32966 }
32967
32968
32969 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32970 PyObject *resultobj;
32971 wxMenu *arg1 = (wxMenu *) 0 ;
32972 wxMenuItem *result;
32973 PyObject * obj0 = 0 ;
32974 char *kwnames[] = {
32975 (char *) "self", NULL
32976 };
32977
32978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32980 if (SWIG_arg_fail(1)) SWIG_fail;
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (wxMenuItem *)(arg1)->PrependSeparator();
32984
32985 wxPyEndAllowThreads(__tstate);
32986 if (PyErr_Occurred()) SWIG_fail;
32987 }
32988 {
32989 resultobj = wxPyMake_wxObject(result, 0);
32990 }
32991 return resultobj;
32992 fail:
32993 return NULL;
32994 }
32995
32996
32997 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32998 PyObject *resultobj;
32999 wxMenu *arg1 = (wxMenu *) 0 ;
33000 int arg2 ;
33001 wxString *arg3 = 0 ;
33002 wxString const &arg4_defvalue = wxPyEmptyString ;
33003 wxString *arg4 = (wxString *) &arg4_defvalue ;
33004 wxMenuItem *result;
33005 bool temp3 = false ;
33006 bool temp4 = false ;
33007 PyObject * obj0 = 0 ;
33008 PyObject * obj1 = 0 ;
33009 PyObject * obj2 = 0 ;
33010 PyObject * obj3 = 0 ;
33011 char *kwnames[] = {
33012 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33013 };
33014
33015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33017 if (SWIG_arg_fail(1)) SWIG_fail;
33018 {
33019 arg2 = (int)(SWIG_As_int(obj1));
33020 if (SWIG_arg_fail(2)) SWIG_fail;
33021 }
33022 {
33023 arg3 = wxString_in_helper(obj2);
33024 if (arg3 == NULL) SWIG_fail;
33025 temp3 = true;
33026 }
33027 if (obj3) {
33028 {
33029 arg4 = wxString_in_helper(obj3);
33030 if (arg4 == NULL) SWIG_fail;
33031 temp4 = true;
33032 }
33033 }
33034 {
33035 PyThreadState* __tstate = wxPyBeginAllowThreads();
33036 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33037
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 {
33042 resultobj = wxPyMake_wxObject(result, 0);
33043 }
33044 {
33045 if (temp3)
33046 delete arg3;
33047 }
33048 {
33049 if (temp4)
33050 delete arg4;
33051 }
33052 return resultobj;
33053 fail:
33054 {
33055 if (temp3)
33056 delete arg3;
33057 }
33058 {
33059 if (temp4)
33060 delete arg4;
33061 }
33062 return NULL;
33063 }
33064
33065
33066 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33067 PyObject *resultobj;
33068 wxMenu *arg1 = (wxMenu *) 0 ;
33069 int arg2 ;
33070 wxString *arg3 = 0 ;
33071 wxString const &arg4_defvalue = wxPyEmptyString ;
33072 wxString *arg4 = (wxString *) &arg4_defvalue ;
33073 wxMenuItem *result;
33074 bool temp3 = false ;
33075 bool temp4 = false ;
33076 PyObject * obj0 = 0 ;
33077 PyObject * obj1 = 0 ;
33078 PyObject * obj2 = 0 ;
33079 PyObject * obj3 = 0 ;
33080 char *kwnames[] = {
33081 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33082 };
33083
33084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33086 if (SWIG_arg_fail(1)) SWIG_fail;
33087 {
33088 arg2 = (int)(SWIG_As_int(obj1));
33089 if (SWIG_arg_fail(2)) SWIG_fail;
33090 }
33091 {
33092 arg3 = wxString_in_helper(obj2);
33093 if (arg3 == NULL) SWIG_fail;
33094 temp3 = true;
33095 }
33096 if (obj3) {
33097 {
33098 arg4 = wxString_in_helper(obj3);
33099 if (arg4 == NULL) SWIG_fail;
33100 temp4 = true;
33101 }
33102 }
33103 {
33104 PyThreadState* __tstate = wxPyBeginAllowThreads();
33105 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33106
33107 wxPyEndAllowThreads(__tstate);
33108 if (PyErr_Occurred()) SWIG_fail;
33109 }
33110 {
33111 resultobj = wxPyMake_wxObject(result, 0);
33112 }
33113 {
33114 if (temp3)
33115 delete arg3;
33116 }
33117 {
33118 if (temp4)
33119 delete arg4;
33120 }
33121 return resultobj;
33122 fail:
33123 {
33124 if (temp3)
33125 delete arg3;
33126 }
33127 {
33128 if (temp4)
33129 delete arg4;
33130 }
33131 return NULL;
33132 }
33133
33134
33135 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33136 PyObject *resultobj;
33137 wxMenu *arg1 = (wxMenu *) 0 ;
33138 int arg2 ;
33139 wxString *arg3 = 0 ;
33140 wxMenu *arg4 = (wxMenu *) 0 ;
33141 wxString const &arg5_defvalue = wxPyEmptyString ;
33142 wxString *arg5 = (wxString *) &arg5_defvalue ;
33143 wxMenuItem *result;
33144 bool temp3 = false ;
33145 bool temp5 = false ;
33146 PyObject * obj0 = 0 ;
33147 PyObject * obj1 = 0 ;
33148 PyObject * obj2 = 0 ;
33149 PyObject * obj3 = 0 ;
33150 PyObject * obj4 = 0 ;
33151 char *kwnames[] = {
33152 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33153 };
33154
33155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33157 if (SWIG_arg_fail(1)) SWIG_fail;
33158 {
33159 arg2 = (int)(SWIG_As_int(obj1));
33160 if (SWIG_arg_fail(2)) SWIG_fail;
33161 }
33162 {
33163 arg3 = wxString_in_helper(obj2);
33164 if (arg3 == NULL) SWIG_fail;
33165 temp3 = true;
33166 }
33167 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(4)) SWIG_fail;
33169 if (obj4) {
33170 {
33171 arg5 = wxString_in_helper(obj4);
33172 if (arg5 == NULL) SWIG_fail;
33173 temp5 = true;
33174 }
33175 }
33176 {
33177 PyThreadState* __tstate = wxPyBeginAllowThreads();
33178 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33179
33180 wxPyEndAllowThreads(__tstate);
33181 if (PyErr_Occurred()) SWIG_fail;
33182 }
33183 {
33184 resultobj = wxPyMake_wxObject(result, 0);
33185 }
33186 {
33187 if (temp3)
33188 delete arg3;
33189 }
33190 {
33191 if (temp5)
33192 delete arg5;
33193 }
33194 return resultobj;
33195 fail:
33196 {
33197 if (temp3)
33198 delete arg3;
33199 }
33200 {
33201 if (temp5)
33202 delete arg5;
33203 }
33204 return NULL;
33205 }
33206
33207
33208 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33209 PyObject *resultobj;
33210 wxMenu *arg1 = (wxMenu *) 0 ;
33211 int arg2 ;
33212 wxMenuItem *result;
33213 PyObject * obj0 = 0 ;
33214 PyObject * obj1 = 0 ;
33215 char *kwnames[] = {
33216 (char *) "self",(char *) "id", NULL
33217 };
33218
33219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33221 if (SWIG_arg_fail(1)) SWIG_fail;
33222 {
33223 arg2 = (int)(SWIG_As_int(obj1));
33224 if (SWIG_arg_fail(2)) SWIG_fail;
33225 }
33226 {
33227 PyThreadState* __tstate = wxPyBeginAllowThreads();
33228 result = (wxMenuItem *)(arg1)->Remove(arg2);
33229
33230 wxPyEndAllowThreads(__tstate);
33231 if (PyErr_Occurred()) SWIG_fail;
33232 }
33233 {
33234 resultobj = wxPyMake_wxObject(result, 0);
33235 }
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33243 PyObject *resultobj;
33244 wxMenu *arg1 = (wxMenu *) 0 ;
33245 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33246 wxMenuItem *result;
33247 PyObject * obj0 = 0 ;
33248 PyObject * obj1 = 0 ;
33249 char *kwnames[] = {
33250 (char *) "self",(char *) "item", NULL
33251 };
33252
33253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33255 if (SWIG_arg_fail(1)) SWIG_fail;
33256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33257 if (SWIG_arg_fail(2)) SWIG_fail;
33258 {
33259 PyThreadState* __tstate = wxPyBeginAllowThreads();
33260 result = (wxMenuItem *)(arg1)->Remove(arg2);
33261
33262 wxPyEndAllowThreads(__tstate);
33263 if (PyErr_Occurred()) SWIG_fail;
33264 }
33265 {
33266 resultobj = wxPyMake_wxObject(result, 0);
33267 }
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33275 PyObject *resultobj;
33276 wxMenu *arg1 = (wxMenu *) 0 ;
33277 int arg2 ;
33278 bool result;
33279 PyObject * obj0 = 0 ;
33280 PyObject * obj1 = 0 ;
33281 char *kwnames[] = {
33282 (char *) "self",(char *) "id", NULL
33283 };
33284
33285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33287 if (SWIG_arg_fail(1)) SWIG_fail;
33288 {
33289 arg2 = (int)(SWIG_As_int(obj1));
33290 if (SWIG_arg_fail(2)) SWIG_fail;
33291 }
33292 {
33293 PyThreadState* __tstate = wxPyBeginAllowThreads();
33294 result = (bool)(arg1)->Delete(arg2);
33295
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 {
33300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33301 }
33302 return resultobj;
33303 fail:
33304 return NULL;
33305 }
33306
33307
33308 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33309 PyObject *resultobj;
33310 wxMenu *arg1 = (wxMenu *) 0 ;
33311 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33312 bool result;
33313 PyObject * obj0 = 0 ;
33314 PyObject * obj1 = 0 ;
33315 char *kwnames[] = {
33316 (char *) "self",(char *) "item", NULL
33317 };
33318
33319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33321 if (SWIG_arg_fail(1)) SWIG_fail;
33322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33323 if (SWIG_arg_fail(2)) SWIG_fail;
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 result = (bool)(arg1)->Delete(arg2);
33327
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 {
33332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33333 }
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj;
33342 wxMenu *arg1 = (wxMenu *) 0 ;
33343 PyObject * obj0 = 0 ;
33344 char *kwnames[] = {
33345 (char *) "self", NULL
33346 };
33347
33348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33350 if (SWIG_arg_fail(1)) SWIG_fail;
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 wxMenu_Destroy(arg1);
33354
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 Py_INCREF(Py_None); resultobj = Py_None;
33359 return resultobj;
33360 fail:
33361 return NULL;
33362 }
33363
33364
33365 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33366 PyObject *resultobj;
33367 wxMenu *arg1 = (wxMenu *) 0 ;
33368 int arg2 ;
33369 bool result;
33370 PyObject * obj0 = 0 ;
33371 PyObject * obj1 = 0 ;
33372 char *kwnames[] = {
33373 (char *) "self",(char *) "id", NULL
33374 };
33375
33376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33378 if (SWIG_arg_fail(1)) SWIG_fail;
33379 {
33380 arg2 = (int)(SWIG_As_int(obj1));
33381 if (SWIG_arg_fail(2)) SWIG_fail;
33382 }
33383 {
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 result = (bool)(arg1)->Destroy(arg2);
33386
33387 wxPyEndAllowThreads(__tstate);
33388 if (PyErr_Occurred()) SWIG_fail;
33389 }
33390 {
33391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33392 }
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33400 PyObject *resultobj;
33401 wxMenu *arg1 = (wxMenu *) 0 ;
33402 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33403 bool result;
33404 PyObject * obj0 = 0 ;
33405 PyObject * obj1 = 0 ;
33406 char *kwnames[] = {
33407 (char *) "self",(char *) "item", NULL
33408 };
33409
33410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33412 if (SWIG_arg_fail(1)) SWIG_fail;
33413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33414 if (SWIG_arg_fail(2)) SWIG_fail;
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 result = (bool)(arg1)->Destroy(arg2);
33418
33419 wxPyEndAllowThreads(__tstate);
33420 if (PyErr_Occurred()) SWIG_fail;
33421 }
33422 {
33423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33424 }
33425 return resultobj;
33426 fail:
33427 return NULL;
33428 }
33429
33430
33431 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33432 PyObject *resultobj;
33433 wxMenu *arg1 = (wxMenu *) 0 ;
33434 size_t result;
33435 PyObject * obj0 = 0 ;
33436 char *kwnames[] = {
33437 (char *) "self", NULL
33438 };
33439
33440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33442 if (SWIG_arg_fail(1)) SWIG_fail;
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33446
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 {
33451 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33452 }
33453 return resultobj;
33454 fail:
33455 return NULL;
33456 }
33457
33458
33459 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33460 PyObject *resultobj;
33461 wxMenu *arg1 = (wxMenu *) 0 ;
33462 PyObject *result;
33463 PyObject * obj0 = 0 ;
33464 char *kwnames[] = {
33465 (char *) "self", NULL
33466 };
33467
33468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
33473 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33474
33475 wxPyEndAllowThreads(__tstate);
33476 if (PyErr_Occurred()) SWIG_fail;
33477 }
33478 resultobj = result;
33479 return resultobj;
33480 fail:
33481 return NULL;
33482 }
33483
33484
33485 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33486 PyObject *resultobj;
33487 wxMenu *arg1 = (wxMenu *) 0 ;
33488 wxString *arg2 = 0 ;
33489 int result;
33490 bool temp2 = false ;
33491 PyObject * obj0 = 0 ;
33492 PyObject * obj1 = 0 ;
33493 char *kwnames[] = {
33494 (char *) "self",(char *) "item", NULL
33495 };
33496
33497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33499 if (SWIG_arg_fail(1)) SWIG_fail;
33500 {
33501 arg2 = wxString_in_helper(obj1);
33502 if (arg2 == NULL) SWIG_fail;
33503 temp2 = true;
33504 }
33505 {
33506 PyThreadState* __tstate = wxPyBeginAllowThreads();
33507 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33508
33509 wxPyEndAllowThreads(__tstate);
33510 if (PyErr_Occurred()) SWIG_fail;
33511 }
33512 {
33513 resultobj = SWIG_From_int((int)(result));
33514 }
33515 {
33516 if (temp2)
33517 delete arg2;
33518 }
33519 return resultobj;
33520 fail:
33521 {
33522 if (temp2)
33523 delete arg2;
33524 }
33525 return NULL;
33526 }
33527
33528
33529 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33530 PyObject *resultobj;
33531 wxMenu *arg1 = (wxMenu *) 0 ;
33532 int arg2 ;
33533 wxMenuItem *result;
33534 PyObject * obj0 = 0 ;
33535 PyObject * obj1 = 0 ;
33536 char *kwnames[] = {
33537 (char *) "self",(char *) "id", NULL
33538 };
33539
33540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33542 if (SWIG_arg_fail(1)) SWIG_fail;
33543 {
33544 arg2 = (int)(SWIG_As_int(obj1));
33545 if (SWIG_arg_fail(2)) SWIG_fail;
33546 }
33547 {
33548 PyThreadState* __tstate = wxPyBeginAllowThreads();
33549 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33550
33551 wxPyEndAllowThreads(__tstate);
33552 if (PyErr_Occurred()) SWIG_fail;
33553 }
33554 {
33555 resultobj = wxPyMake_wxObject(result, 0);
33556 }
33557 return resultobj;
33558 fail:
33559 return NULL;
33560 }
33561
33562
33563 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33564 PyObject *resultobj;
33565 wxMenu *arg1 = (wxMenu *) 0 ;
33566 size_t arg2 ;
33567 wxMenuItem *result;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 char *kwnames[] = {
33571 (char *) "self",(char *) "position", NULL
33572 };
33573
33574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33576 if (SWIG_arg_fail(1)) SWIG_fail;
33577 {
33578 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33579 if (SWIG_arg_fail(2)) SWIG_fail;
33580 }
33581 {
33582 PyThreadState* __tstate = wxPyBeginAllowThreads();
33583 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33584
33585 wxPyEndAllowThreads(__tstate);
33586 if (PyErr_Occurred()) SWIG_fail;
33587 }
33588 {
33589 resultobj = wxPyMake_wxObject(result, 0);
33590 }
33591 return resultobj;
33592 fail:
33593 return NULL;
33594 }
33595
33596
33597 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33598 PyObject *resultobj;
33599 wxMenu *arg1 = (wxMenu *) 0 ;
33600 int arg2 ;
33601 bool arg3 ;
33602 PyObject * obj0 = 0 ;
33603 PyObject * obj1 = 0 ;
33604 PyObject * obj2 = 0 ;
33605 char *kwnames[] = {
33606 (char *) "self",(char *) "id",(char *) "enable", NULL
33607 };
33608
33609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33611 if (SWIG_arg_fail(1)) SWIG_fail;
33612 {
33613 arg2 = (int)(SWIG_As_int(obj1));
33614 if (SWIG_arg_fail(2)) SWIG_fail;
33615 }
33616 {
33617 arg3 = (bool)(SWIG_As_bool(obj2));
33618 if (SWIG_arg_fail(3)) SWIG_fail;
33619 }
33620 {
33621 PyThreadState* __tstate = wxPyBeginAllowThreads();
33622 (arg1)->Enable(arg2,arg3);
33623
33624 wxPyEndAllowThreads(__tstate);
33625 if (PyErr_Occurred()) SWIG_fail;
33626 }
33627 Py_INCREF(Py_None); resultobj = Py_None;
33628 return resultobj;
33629 fail:
33630 return NULL;
33631 }
33632
33633
33634 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33635 PyObject *resultobj;
33636 wxMenu *arg1 = (wxMenu *) 0 ;
33637 int arg2 ;
33638 bool result;
33639 PyObject * obj0 = 0 ;
33640 PyObject * obj1 = 0 ;
33641 char *kwnames[] = {
33642 (char *) "self",(char *) "id", NULL
33643 };
33644
33645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33647 if (SWIG_arg_fail(1)) SWIG_fail;
33648 {
33649 arg2 = (int)(SWIG_As_int(obj1));
33650 if (SWIG_arg_fail(2)) SWIG_fail;
33651 }
33652 {
33653 PyThreadState* __tstate = wxPyBeginAllowThreads();
33654 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33655
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 {
33660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33661 }
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj;
33670 wxMenu *arg1 = (wxMenu *) 0 ;
33671 int arg2 ;
33672 bool arg3 ;
33673 PyObject * obj0 = 0 ;
33674 PyObject * obj1 = 0 ;
33675 PyObject * obj2 = 0 ;
33676 char *kwnames[] = {
33677 (char *) "self",(char *) "id",(char *) "check", NULL
33678 };
33679
33680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33682 if (SWIG_arg_fail(1)) SWIG_fail;
33683 {
33684 arg2 = (int)(SWIG_As_int(obj1));
33685 if (SWIG_arg_fail(2)) SWIG_fail;
33686 }
33687 {
33688 arg3 = (bool)(SWIG_As_bool(obj2));
33689 if (SWIG_arg_fail(3)) SWIG_fail;
33690 }
33691 {
33692 PyThreadState* __tstate = wxPyBeginAllowThreads();
33693 (arg1)->Check(arg2,arg3);
33694
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 Py_INCREF(Py_None); resultobj = Py_None;
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj;
33707 wxMenu *arg1 = (wxMenu *) 0 ;
33708 int arg2 ;
33709 bool result;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 char *kwnames[] = {
33713 (char *) "self",(char *) "id", NULL
33714 };
33715
33716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33718 if (SWIG_arg_fail(1)) SWIG_fail;
33719 {
33720 arg2 = (int)(SWIG_As_int(obj1));
33721 if (SWIG_arg_fail(2)) SWIG_fail;
33722 }
33723 {
33724 PyThreadState* __tstate = wxPyBeginAllowThreads();
33725 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33726
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 {
33731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33732 }
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj;
33741 wxMenu *arg1 = (wxMenu *) 0 ;
33742 int arg2 ;
33743 wxString *arg3 = 0 ;
33744 bool temp3 = false ;
33745 PyObject * obj0 = 0 ;
33746 PyObject * obj1 = 0 ;
33747 PyObject * obj2 = 0 ;
33748 char *kwnames[] = {
33749 (char *) "self",(char *) "id",(char *) "label", NULL
33750 };
33751
33752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33754 if (SWIG_arg_fail(1)) SWIG_fail;
33755 {
33756 arg2 = (int)(SWIG_As_int(obj1));
33757 if (SWIG_arg_fail(2)) SWIG_fail;
33758 }
33759 {
33760 arg3 = wxString_in_helper(obj2);
33761 if (arg3 == NULL) SWIG_fail;
33762 temp3 = true;
33763 }
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33767
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 Py_INCREF(Py_None); resultobj = Py_None;
33772 {
33773 if (temp3)
33774 delete arg3;
33775 }
33776 return resultobj;
33777 fail:
33778 {
33779 if (temp3)
33780 delete arg3;
33781 }
33782 return NULL;
33783 }
33784
33785
33786 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33787 PyObject *resultobj;
33788 wxMenu *arg1 = (wxMenu *) 0 ;
33789 int arg2 ;
33790 wxString result;
33791 PyObject * obj0 = 0 ;
33792 PyObject * obj1 = 0 ;
33793 char *kwnames[] = {
33794 (char *) "self",(char *) "id", NULL
33795 };
33796
33797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33799 if (SWIG_arg_fail(1)) SWIG_fail;
33800 {
33801 arg2 = (int)(SWIG_As_int(obj1));
33802 if (SWIG_arg_fail(2)) SWIG_fail;
33803 }
33804 {
33805 PyThreadState* __tstate = wxPyBeginAllowThreads();
33806 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33807
33808 wxPyEndAllowThreads(__tstate);
33809 if (PyErr_Occurred()) SWIG_fail;
33810 }
33811 {
33812 #if wxUSE_UNICODE
33813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33814 #else
33815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33816 #endif
33817 }
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33825 PyObject *resultobj;
33826 wxMenu *arg1 = (wxMenu *) 0 ;
33827 int arg2 ;
33828 wxString *arg3 = 0 ;
33829 bool temp3 = false ;
33830 PyObject * obj0 = 0 ;
33831 PyObject * obj1 = 0 ;
33832 PyObject * obj2 = 0 ;
33833 char *kwnames[] = {
33834 (char *) "self",(char *) "id",(char *) "helpString", NULL
33835 };
33836
33837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33839 if (SWIG_arg_fail(1)) SWIG_fail;
33840 {
33841 arg2 = (int)(SWIG_As_int(obj1));
33842 if (SWIG_arg_fail(2)) SWIG_fail;
33843 }
33844 {
33845 arg3 = wxString_in_helper(obj2);
33846 if (arg3 == NULL) SWIG_fail;
33847 temp3 = true;
33848 }
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33852
33853 wxPyEndAllowThreads(__tstate);
33854 if (PyErr_Occurred()) SWIG_fail;
33855 }
33856 Py_INCREF(Py_None); resultobj = Py_None;
33857 {
33858 if (temp3)
33859 delete arg3;
33860 }
33861 return resultobj;
33862 fail:
33863 {
33864 if (temp3)
33865 delete arg3;
33866 }
33867 return NULL;
33868 }
33869
33870
33871 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33872 PyObject *resultobj;
33873 wxMenu *arg1 = (wxMenu *) 0 ;
33874 int arg2 ;
33875 wxString result;
33876 PyObject * obj0 = 0 ;
33877 PyObject * obj1 = 0 ;
33878 char *kwnames[] = {
33879 (char *) "self",(char *) "id", NULL
33880 };
33881
33882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33884 if (SWIG_arg_fail(1)) SWIG_fail;
33885 {
33886 arg2 = (int)(SWIG_As_int(obj1));
33887 if (SWIG_arg_fail(2)) SWIG_fail;
33888 }
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33892
33893 wxPyEndAllowThreads(__tstate);
33894 if (PyErr_Occurred()) SWIG_fail;
33895 }
33896 {
33897 #if wxUSE_UNICODE
33898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33899 #else
33900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33901 #endif
33902 }
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj;
33911 wxMenu *arg1 = (wxMenu *) 0 ;
33912 wxString *arg2 = 0 ;
33913 bool temp2 = false ;
33914 PyObject * obj0 = 0 ;
33915 PyObject * obj1 = 0 ;
33916 char *kwnames[] = {
33917 (char *) "self",(char *) "title", NULL
33918 };
33919
33920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33922 if (SWIG_arg_fail(1)) SWIG_fail;
33923 {
33924 arg2 = wxString_in_helper(obj1);
33925 if (arg2 == NULL) SWIG_fail;
33926 temp2 = true;
33927 }
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 (arg1)->SetTitle((wxString const &)*arg2);
33931
33932 wxPyEndAllowThreads(__tstate);
33933 if (PyErr_Occurred()) SWIG_fail;
33934 }
33935 Py_INCREF(Py_None); resultobj = Py_None;
33936 {
33937 if (temp2)
33938 delete arg2;
33939 }
33940 return resultobj;
33941 fail:
33942 {
33943 if (temp2)
33944 delete arg2;
33945 }
33946 return NULL;
33947 }
33948
33949
33950 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj;
33952 wxMenu *arg1 = (wxMenu *) 0 ;
33953 wxString result;
33954 PyObject * obj0 = 0 ;
33955 char *kwnames[] = {
33956 (char *) "self", NULL
33957 };
33958
33959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33961 if (SWIG_arg_fail(1)) SWIG_fail;
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 result = ((wxMenu const *)arg1)->GetTitle();
33965
33966 wxPyEndAllowThreads(__tstate);
33967 if (PyErr_Occurred()) SWIG_fail;
33968 }
33969 {
33970 #if wxUSE_UNICODE
33971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33972 #else
33973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33974 #endif
33975 }
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33983 PyObject *resultobj;
33984 wxMenu *arg1 = (wxMenu *) 0 ;
33985 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33986 PyObject * obj0 = 0 ;
33987 PyObject * obj1 = 0 ;
33988 char *kwnames[] = {
33989 (char *) "self",(char *) "handler", NULL
33990 };
33991
33992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33994 if (SWIG_arg_fail(1)) SWIG_fail;
33995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33996 if (SWIG_arg_fail(2)) SWIG_fail;
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->SetEventHandler(arg2);
34000
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 Py_INCREF(Py_None); resultobj = Py_None;
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj;
34013 wxMenu *arg1 = (wxMenu *) 0 ;
34014 wxEvtHandler *result;
34015 PyObject * obj0 = 0 ;
34016 char *kwnames[] = {
34017 (char *) "self", NULL
34018 };
34019
34020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34022 if (SWIG_arg_fail(1)) SWIG_fail;
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34026
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 {
34031 resultobj = wxPyMake_wxObject(result, 0);
34032 }
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 wxWindow *arg2 = (wxWindow *) 0 ;
34043 PyObject * obj0 = 0 ;
34044 PyObject * obj1 = 0 ;
34045 char *kwnames[] = {
34046 (char *) "self",(char *) "win", NULL
34047 };
34048
34049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34051 if (SWIG_arg_fail(1)) SWIG_fail;
34052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34053 if (SWIG_arg_fail(2)) SWIG_fail;
34054 {
34055 PyThreadState* __tstate = wxPyBeginAllowThreads();
34056 (arg1)->SetInvokingWindow(arg2);
34057
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 Py_INCREF(Py_None); resultobj = Py_None;
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj;
34070 wxMenu *arg1 = (wxMenu *) 0 ;
34071 wxWindow *result;
34072 PyObject * obj0 = 0 ;
34073 char *kwnames[] = {
34074 (char *) "self", NULL
34075 };
34076
34077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34079 if (SWIG_arg_fail(1)) SWIG_fail;
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34083
34084 wxPyEndAllowThreads(__tstate);
34085 if (PyErr_Occurred()) SWIG_fail;
34086 }
34087 {
34088 resultobj = wxPyMake_wxObject(result, 0);
34089 }
34090 return resultobj;
34091 fail:
34092 return NULL;
34093 }
34094
34095
34096 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34097 PyObject *resultobj;
34098 wxMenu *arg1 = (wxMenu *) 0 ;
34099 long result;
34100 PyObject * obj0 = 0 ;
34101 char *kwnames[] = {
34102 (char *) "self", NULL
34103 };
34104
34105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34107 if (SWIG_arg_fail(1)) SWIG_fail;
34108 {
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (long)((wxMenu const *)arg1)->GetStyle();
34111
34112 wxPyEndAllowThreads(__tstate);
34113 if (PyErr_Occurred()) SWIG_fail;
34114 }
34115 {
34116 resultobj = SWIG_From_long((long)(result));
34117 }
34118 return resultobj;
34119 fail:
34120 return NULL;
34121 }
34122
34123
34124 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34125 PyObject *resultobj;
34126 wxMenu *arg1 = (wxMenu *) 0 ;
34127 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34128 PyObject * obj0 = 0 ;
34129 PyObject * obj1 = 0 ;
34130 char *kwnames[] = {
34131 (char *) "self",(char *) "source", NULL
34132 };
34133
34134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34136 if (SWIG_arg_fail(1)) SWIG_fail;
34137 if (obj1) {
34138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34139 if (SWIG_arg_fail(2)) SWIG_fail;
34140 }
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 (arg1)->UpdateUI(arg2);
34144
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 Py_INCREF(Py_None); resultobj = Py_None;
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj;
34157 wxMenu *arg1 = (wxMenu *) 0 ;
34158 wxMenuBar *result;
34159 PyObject * obj0 = 0 ;
34160 char *kwnames[] = {
34161 (char *) "self", NULL
34162 };
34163
34164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34166 if (SWIG_arg_fail(1)) SWIG_fail;
34167 {
34168 PyThreadState* __tstate = wxPyBeginAllowThreads();
34169 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34170
34171 wxPyEndAllowThreads(__tstate);
34172 if (PyErr_Occurred()) SWIG_fail;
34173 }
34174 {
34175 resultobj = wxPyMake_wxObject(result, 0);
34176 }
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34184 PyObject *resultobj;
34185 wxMenu *arg1 = (wxMenu *) 0 ;
34186 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34187 PyObject * obj0 = 0 ;
34188 PyObject * obj1 = 0 ;
34189 char *kwnames[] = {
34190 (char *) "self",(char *) "menubar", NULL
34191 };
34192
34193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34195 if (SWIG_arg_fail(1)) SWIG_fail;
34196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34197 if (SWIG_arg_fail(2)) SWIG_fail;
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 (arg1)->Attach(arg2);
34201
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 Py_INCREF(Py_None); resultobj = Py_None;
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34213 PyObject *resultobj;
34214 wxMenu *arg1 = (wxMenu *) 0 ;
34215 PyObject * obj0 = 0 ;
34216 char *kwnames[] = {
34217 (char *) "self", NULL
34218 };
34219
34220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34222 if (SWIG_arg_fail(1)) SWIG_fail;
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 (arg1)->Detach();
34226
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 Py_INCREF(Py_None); resultobj = Py_None;
34231 return resultobj;
34232 fail:
34233 return NULL;
34234 }
34235
34236
34237 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34238 PyObject *resultobj;
34239 wxMenu *arg1 = (wxMenu *) 0 ;
34240 bool result;
34241 PyObject * obj0 = 0 ;
34242 char *kwnames[] = {
34243 (char *) "self", NULL
34244 };
34245
34246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34248 if (SWIG_arg_fail(1)) SWIG_fail;
34249 {
34250 PyThreadState* __tstate = wxPyBeginAllowThreads();
34251 result = (bool)((wxMenu const *)arg1)->IsAttached();
34252
34253 wxPyEndAllowThreads(__tstate);
34254 if (PyErr_Occurred()) SWIG_fail;
34255 }
34256 {
34257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34258 }
34259 return resultobj;
34260 fail:
34261 return NULL;
34262 }
34263
34264
34265 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34266 PyObject *resultobj;
34267 wxMenu *arg1 = (wxMenu *) 0 ;
34268 wxMenu *arg2 = (wxMenu *) 0 ;
34269 PyObject * obj0 = 0 ;
34270 PyObject * obj1 = 0 ;
34271 char *kwnames[] = {
34272 (char *) "self",(char *) "parent", NULL
34273 };
34274
34275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34277 if (SWIG_arg_fail(1)) SWIG_fail;
34278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34279 if (SWIG_arg_fail(2)) SWIG_fail;
34280 {
34281 PyThreadState* __tstate = wxPyBeginAllowThreads();
34282 (arg1)->SetParent(arg2);
34283
34284 wxPyEndAllowThreads(__tstate);
34285 if (PyErr_Occurred()) SWIG_fail;
34286 }
34287 Py_INCREF(Py_None); resultobj = Py_None;
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj;
34296 wxMenu *arg1 = (wxMenu *) 0 ;
34297 wxMenu *result;
34298 PyObject * obj0 = 0 ;
34299 char *kwnames[] = {
34300 (char *) "self", NULL
34301 };
34302
34303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34305 if (SWIG_arg_fail(1)) SWIG_fail;
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34309
34310 wxPyEndAllowThreads(__tstate);
34311 if (PyErr_Occurred()) SWIG_fail;
34312 }
34313 {
34314 resultobj = wxPyMake_wxObject(result, 0);
34315 }
34316 return resultobj;
34317 fail:
34318 return NULL;
34319 }
34320
34321
34322 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34323 PyObject *obj;
34324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34325 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34326 Py_INCREF(obj);
34327 return Py_BuildValue((char *)"");
34328 }
34329 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34330 PyObject *resultobj;
34331 long arg1 = (long) 0 ;
34332 wxMenuBar *result;
34333 PyObject * obj0 = 0 ;
34334 char *kwnames[] = {
34335 (char *) "style", NULL
34336 };
34337
34338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34339 if (obj0) {
34340 {
34341 arg1 = (long)(SWIG_As_long(obj0));
34342 if (SWIG_arg_fail(1)) SWIG_fail;
34343 }
34344 }
34345 {
34346 if (!wxPyCheckForApp()) SWIG_fail;
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 result = (wxMenuBar *)new wxMenuBar(arg1);
34349
34350 wxPyEndAllowThreads(__tstate);
34351 if (PyErr_Occurred()) SWIG_fail;
34352 }
34353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34361 PyObject *resultobj;
34362 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34363 wxMenu *arg2 = (wxMenu *) 0 ;
34364 wxString *arg3 = 0 ;
34365 bool result;
34366 bool temp3 = false ;
34367 PyObject * obj0 = 0 ;
34368 PyObject * obj1 = 0 ;
34369 PyObject * obj2 = 0 ;
34370 char *kwnames[] = {
34371 (char *) "self",(char *) "menu",(char *) "title", NULL
34372 };
34373
34374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34376 if (SWIG_arg_fail(1)) SWIG_fail;
34377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34378 if (SWIG_arg_fail(2)) SWIG_fail;
34379 {
34380 arg3 = wxString_in_helper(obj2);
34381 if (arg3 == NULL) SWIG_fail;
34382 temp3 = true;
34383 }
34384 {
34385 PyThreadState* __tstate = wxPyBeginAllowThreads();
34386 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34387
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 {
34392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34393 }
34394 {
34395 if (temp3)
34396 delete arg3;
34397 }
34398 return resultobj;
34399 fail:
34400 {
34401 if (temp3)
34402 delete arg3;
34403 }
34404 return NULL;
34405 }
34406
34407
34408 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34409 PyObject *resultobj;
34410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34411 size_t arg2 ;
34412 wxMenu *arg3 = (wxMenu *) 0 ;
34413 wxString *arg4 = 0 ;
34414 bool result;
34415 bool temp4 = false ;
34416 PyObject * obj0 = 0 ;
34417 PyObject * obj1 = 0 ;
34418 PyObject * obj2 = 0 ;
34419 PyObject * obj3 = 0 ;
34420 char *kwnames[] = {
34421 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34422 };
34423
34424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34426 if (SWIG_arg_fail(1)) SWIG_fail;
34427 {
34428 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34429 if (SWIG_arg_fail(2)) SWIG_fail;
34430 }
34431 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34432 if (SWIG_arg_fail(3)) SWIG_fail;
34433 {
34434 arg4 = wxString_in_helper(obj3);
34435 if (arg4 == NULL) SWIG_fail;
34436 temp4 = true;
34437 }
34438 {
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34441
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 {
34446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34447 }
34448 {
34449 if (temp4)
34450 delete arg4;
34451 }
34452 return resultobj;
34453 fail:
34454 {
34455 if (temp4)
34456 delete arg4;
34457 }
34458 return NULL;
34459 }
34460
34461
34462 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34463 PyObject *resultobj;
34464 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34465 size_t result;
34466 PyObject * obj0 = 0 ;
34467 char *kwnames[] = {
34468 (char *) "self", NULL
34469 };
34470
34471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34473 if (SWIG_arg_fail(1)) SWIG_fail;
34474 {
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34477
34478 wxPyEndAllowThreads(__tstate);
34479 if (PyErr_Occurred()) SWIG_fail;
34480 }
34481 {
34482 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34483 }
34484 return resultobj;
34485 fail:
34486 return NULL;
34487 }
34488
34489
34490 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34491 PyObject *resultobj;
34492 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34493 size_t arg2 ;
34494 wxMenu *result;
34495 PyObject * obj0 = 0 ;
34496 PyObject * obj1 = 0 ;
34497 char *kwnames[] = {
34498 (char *) "self",(char *) "pos", NULL
34499 };
34500
34501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34503 if (SWIG_arg_fail(1)) SWIG_fail;
34504 {
34505 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34506 if (SWIG_arg_fail(2)) SWIG_fail;
34507 }
34508 {
34509 PyThreadState* __tstate = wxPyBeginAllowThreads();
34510 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34511
34512 wxPyEndAllowThreads(__tstate);
34513 if (PyErr_Occurred()) SWIG_fail;
34514 }
34515 {
34516 resultobj = wxPyMake_wxObject(result, 0);
34517 }
34518 return resultobj;
34519 fail:
34520 return NULL;
34521 }
34522
34523
34524 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34525 PyObject *resultobj;
34526 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34527 size_t arg2 ;
34528 wxMenu *arg3 = (wxMenu *) 0 ;
34529 wxString *arg4 = 0 ;
34530 wxMenu *result;
34531 bool temp4 = false ;
34532 PyObject * obj0 = 0 ;
34533 PyObject * obj1 = 0 ;
34534 PyObject * obj2 = 0 ;
34535 PyObject * obj3 = 0 ;
34536 char *kwnames[] = {
34537 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34538 };
34539
34540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34542 if (SWIG_arg_fail(1)) SWIG_fail;
34543 {
34544 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34545 if (SWIG_arg_fail(2)) SWIG_fail;
34546 }
34547 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34548 if (SWIG_arg_fail(3)) SWIG_fail;
34549 {
34550 arg4 = wxString_in_helper(obj3);
34551 if (arg4 == NULL) SWIG_fail;
34552 temp4 = true;
34553 }
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34557
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = wxPyMake_wxObject(result, 0);
34563 }
34564 {
34565 if (temp4)
34566 delete arg4;
34567 }
34568 return resultobj;
34569 fail:
34570 {
34571 if (temp4)
34572 delete arg4;
34573 }
34574 return NULL;
34575 }
34576
34577
34578 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34579 PyObject *resultobj;
34580 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34581 size_t arg2 ;
34582 wxMenu *result;
34583 PyObject * obj0 = 0 ;
34584 PyObject * obj1 = 0 ;
34585 char *kwnames[] = {
34586 (char *) "self",(char *) "pos", NULL
34587 };
34588
34589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34591 if (SWIG_arg_fail(1)) SWIG_fail;
34592 {
34593 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34594 if (SWIG_arg_fail(2)) SWIG_fail;
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (wxMenu *)(arg1)->Remove(arg2);
34599
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 {
34604 resultobj = wxPyMake_wxObject(result, 0);
34605 }
34606 return resultobj;
34607 fail:
34608 return NULL;
34609 }
34610
34611
34612 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34613 PyObject *resultobj;
34614 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34615 size_t arg2 ;
34616 bool arg3 ;
34617 PyObject * obj0 = 0 ;
34618 PyObject * obj1 = 0 ;
34619 PyObject * obj2 = 0 ;
34620 char *kwnames[] = {
34621 (char *) "self",(char *) "pos",(char *) "enable", NULL
34622 };
34623
34624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34626 if (SWIG_arg_fail(1)) SWIG_fail;
34627 {
34628 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34629 if (SWIG_arg_fail(2)) SWIG_fail;
34630 }
34631 {
34632 arg3 = (bool)(SWIG_As_bool(obj2));
34633 if (SWIG_arg_fail(3)) SWIG_fail;
34634 }
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 (arg1)->EnableTop(arg2,arg3);
34638
34639 wxPyEndAllowThreads(__tstate);
34640 if (PyErr_Occurred()) SWIG_fail;
34641 }
34642 Py_INCREF(Py_None); resultobj = Py_None;
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj;
34651 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34652 size_t arg2 ;
34653 bool result;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 char *kwnames[] = {
34657 (char *) "self",(char *) "pos", NULL
34658 };
34659
34660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34662 if (SWIG_arg_fail(1)) SWIG_fail;
34663 {
34664 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34665 if (SWIG_arg_fail(2)) SWIG_fail;
34666 }
34667 {
34668 PyThreadState* __tstate = wxPyBeginAllowThreads();
34669 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34670
34671 wxPyEndAllowThreads(__tstate);
34672 if (PyErr_Occurred()) SWIG_fail;
34673 }
34674 {
34675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34676 }
34677 return resultobj;
34678 fail:
34679 return NULL;
34680 }
34681
34682
34683 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34684 PyObject *resultobj;
34685 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34686 size_t arg2 ;
34687 wxString *arg3 = 0 ;
34688 bool temp3 = false ;
34689 PyObject * obj0 = 0 ;
34690 PyObject * obj1 = 0 ;
34691 PyObject * obj2 = 0 ;
34692 char *kwnames[] = {
34693 (char *) "self",(char *) "pos",(char *) "label", NULL
34694 };
34695
34696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34698 if (SWIG_arg_fail(1)) SWIG_fail;
34699 {
34700 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34701 if (SWIG_arg_fail(2)) SWIG_fail;
34702 }
34703 {
34704 arg3 = wxString_in_helper(obj2);
34705 if (arg3 == NULL) SWIG_fail;
34706 temp3 = true;
34707 }
34708 {
34709 PyThreadState* __tstate = wxPyBeginAllowThreads();
34710 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34711
34712 wxPyEndAllowThreads(__tstate);
34713 if (PyErr_Occurred()) SWIG_fail;
34714 }
34715 Py_INCREF(Py_None); resultobj = Py_None;
34716 {
34717 if (temp3)
34718 delete arg3;
34719 }
34720 return resultobj;
34721 fail:
34722 {
34723 if (temp3)
34724 delete arg3;
34725 }
34726 return NULL;
34727 }
34728
34729
34730 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34731 PyObject *resultobj;
34732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34733 size_t arg2 ;
34734 wxString result;
34735 PyObject * obj0 = 0 ;
34736 PyObject * obj1 = 0 ;
34737 char *kwnames[] = {
34738 (char *) "self",(char *) "pos", NULL
34739 };
34740
34741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34743 if (SWIG_arg_fail(1)) SWIG_fail;
34744 {
34745 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34746 if (SWIG_arg_fail(2)) SWIG_fail;
34747 }
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34751
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 {
34756 #if wxUSE_UNICODE
34757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34758 #else
34759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34760 #endif
34761 }
34762 return resultobj;
34763 fail:
34764 return NULL;
34765 }
34766
34767
34768 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34769 PyObject *resultobj;
34770 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34771 wxString *arg2 = 0 ;
34772 wxString *arg3 = 0 ;
34773 int result;
34774 bool temp2 = false ;
34775 bool temp3 = false ;
34776 PyObject * obj0 = 0 ;
34777 PyObject * obj1 = 0 ;
34778 PyObject * obj2 = 0 ;
34779 char *kwnames[] = {
34780 (char *) "self",(char *) "menu",(char *) "item", NULL
34781 };
34782
34783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34785 if (SWIG_arg_fail(1)) SWIG_fail;
34786 {
34787 arg2 = wxString_in_helper(obj1);
34788 if (arg2 == NULL) SWIG_fail;
34789 temp2 = true;
34790 }
34791 {
34792 arg3 = wxString_in_helper(obj2);
34793 if (arg3 == NULL) SWIG_fail;
34794 temp3 = true;
34795 }
34796 {
34797 PyThreadState* __tstate = wxPyBeginAllowThreads();
34798 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34799
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 {
34804 resultobj = SWIG_From_int((int)(result));
34805 }
34806 {
34807 if (temp2)
34808 delete arg2;
34809 }
34810 {
34811 if (temp3)
34812 delete arg3;
34813 }
34814 return resultobj;
34815 fail:
34816 {
34817 if (temp2)
34818 delete arg2;
34819 }
34820 {
34821 if (temp3)
34822 delete arg3;
34823 }
34824 return NULL;
34825 }
34826
34827
34828 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34829 PyObject *resultobj;
34830 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34831 int arg2 ;
34832 wxMenuItem *result;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self",(char *) "id", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 {
34843 arg2 = (int)(SWIG_As_int(obj1));
34844 if (SWIG_arg_fail(2)) SWIG_fail;
34845 }
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34849
34850 wxPyEndAllowThreads(__tstate);
34851 if (PyErr_Occurred()) SWIG_fail;
34852 }
34853 {
34854 resultobj = wxPyMake_wxObject(result, 0);
34855 }
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34863 PyObject *resultobj;
34864 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34865 wxString *arg2 = 0 ;
34866 int result;
34867 bool temp2 = false ;
34868 PyObject * obj0 = 0 ;
34869 PyObject * obj1 = 0 ;
34870 char *kwnames[] = {
34871 (char *) "self",(char *) "title", NULL
34872 };
34873
34874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34876 if (SWIG_arg_fail(1)) SWIG_fail;
34877 {
34878 arg2 = wxString_in_helper(obj1);
34879 if (arg2 == NULL) SWIG_fail;
34880 temp2 = true;
34881 }
34882 {
34883 PyThreadState* __tstate = wxPyBeginAllowThreads();
34884 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34885
34886 wxPyEndAllowThreads(__tstate);
34887 if (PyErr_Occurred()) SWIG_fail;
34888 }
34889 {
34890 resultobj = SWIG_From_int((int)(result));
34891 }
34892 {
34893 if (temp2)
34894 delete arg2;
34895 }
34896 return resultobj;
34897 fail:
34898 {
34899 if (temp2)
34900 delete arg2;
34901 }
34902 return NULL;
34903 }
34904
34905
34906 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34907 PyObject *resultobj;
34908 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34909 int arg2 ;
34910 bool arg3 ;
34911 PyObject * obj0 = 0 ;
34912 PyObject * obj1 = 0 ;
34913 PyObject * obj2 = 0 ;
34914 char *kwnames[] = {
34915 (char *) "self",(char *) "id",(char *) "enable", NULL
34916 };
34917
34918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34920 if (SWIG_arg_fail(1)) SWIG_fail;
34921 {
34922 arg2 = (int)(SWIG_As_int(obj1));
34923 if (SWIG_arg_fail(2)) SWIG_fail;
34924 }
34925 {
34926 arg3 = (bool)(SWIG_As_bool(obj2));
34927 if (SWIG_arg_fail(3)) SWIG_fail;
34928 }
34929 {
34930 PyThreadState* __tstate = wxPyBeginAllowThreads();
34931 (arg1)->Enable(arg2,arg3);
34932
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 Py_INCREF(Py_None); resultobj = Py_None;
34937 return resultobj;
34938 fail:
34939 return NULL;
34940 }
34941
34942
34943 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34944 PyObject *resultobj;
34945 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34946 int arg2 ;
34947 bool arg3 ;
34948 PyObject * obj0 = 0 ;
34949 PyObject * obj1 = 0 ;
34950 PyObject * obj2 = 0 ;
34951 char *kwnames[] = {
34952 (char *) "self",(char *) "id",(char *) "check", NULL
34953 };
34954
34955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34957 if (SWIG_arg_fail(1)) SWIG_fail;
34958 {
34959 arg2 = (int)(SWIG_As_int(obj1));
34960 if (SWIG_arg_fail(2)) SWIG_fail;
34961 }
34962 {
34963 arg3 = (bool)(SWIG_As_bool(obj2));
34964 if (SWIG_arg_fail(3)) SWIG_fail;
34965 }
34966 {
34967 PyThreadState* __tstate = wxPyBeginAllowThreads();
34968 (arg1)->Check(arg2,arg3);
34969
34970 wxPyEndAllowThreads(__tstate);
34971 if (PyErr_Occurred()) SWIG_fail;
34972 }
34973 Py_INCREF(Py_None); resultobj = Py_None;
34974 return resultobj;
34975 fail:
34976 return NULL;
34977 }
34978
34979
34980 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34981 PyObject *resultobj;
34982 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34983 int arg2 ;
34984 bool result;
34985 PyObject * obj0 = 0 ;
34986 PyObject * obj1 = 0 ;
34987 char *kwnames[] = {
34988 (char *) "self",(char *) "id", NULL
34989 };
34990
34991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34993 if (SWIG_arg_fail(1)) SWIG_fail;
34994 {
34995 arg2 = (int)(SWIG_As_int(obj1));
34996 if (SWIG_arg_fail(2)) SWIG_fail;
34997 }
34998 {
34999 PyThreadState* __tstate = wxPyBeginAllowThreads();
35000 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35001
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 {
35006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35007 }
35008 return resultobj;
35009 fail:
35010 return NULL;
35011 }
35012
35013
35014 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35015 PyObject *resultobj;
35016 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35017 int arg2 ;
35018 bool result;
35019 PyObject * obj0 = 0 ;
35020 PyObject * obj1 = 0 ;
35021 char *kwnames[] = {
35022 (char *) "self",(char *) "id", NULL
35023 };
35024
35025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35027 if (SWIG_arg_fail(1)) SWIG_fail;
35028 {
35029 arg2 = (int)(SWIG_As_int(obj1));
35030 if (SWIG_arg_fail(2)) SWIG_fail;
35031 }
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35035
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 {
35040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35041 }
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj;
35050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35051 int arg2 ;
35052 wxString *arg3 = 0 ;
35053 bool temp3 = false ;
35054 PyObject * obj0 = 0 ;
35055 PyObject * obj1 = 0 ;
35056 PyObject * obj2 = 0 ;
35057 char *kwnames[] = {
35058 (char *) "self",(char *) "id",(char *) "label", NULL
35059 };
35060
35061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35063 if (SWIG_arg_fail(1)) SWIG_fail;
35064 {
35065 arg2 = (int)(SWIG_As_int(obj1));
35066 if (SWIG_arg_fail(2)) SWIG_fail;
35067 }
35068 {
35069 arg3 = wxString_in_helper(obj2);
35070 if (arg3 == NULL) SWIG_fail;
35071 temp3 = true;
35072 }
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35076
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 Py_INCREF(Py_None); resultobj = Py_None;
35081 {
35082 if (temp3)
35083 delete arg3;
35084 }
35085 return resultobj;
35086 fail:
35087 {
35088 if (temp3)
35089 delete arg3;
35090 }
35091 return NULL;
35092 }
35093
35094
35095 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35096 PyObject *resultobj;
35097 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35098 int arg2 ;
35099 wxString result;
35100 PyObject * obj0 = 0 ;
35101 PyObject * obj1 = 0 ;
35102 char *kwnames[] = {
35103 (char *) "self",(char *) "id", NULL
35104 };
35105
35106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35108 if (SWIG_arg_fail(1)) SWIG_fail;
35109 {
35110 arg2 = (int)(SWIG_As_int(obj1));
35111 if (SWIG_arg_fail(2)) SWIG_fail;
35112 }
35113 {
35114 PyThreadState* __tstate = wxPyBeginAllowThreads();
35115 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35116
35117 wxPyEndAllowThreads(__tstate);
35118 if (PyErr_Occurred()) SWIG_fail;
35119 }
35120 {
35121 #if wxUSE_UNICODE
35122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35123 #else
35124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35125 #endif
35126 }
35127 return resultobj;
35128 fail:
35129 return NULL;
35130 }
35131
35132
35133 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35134 PyObject *resultobj;
35135 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35136 int arg2 ;
35137 wxString *arg3 = 0 ;
35138 bool temp3 = false ;
35139 PyObject * obj0 = 0 ;
35140 PyObject * obj1 = 0 ;
35141 PyObject * obj2 = 0 ;
35142 char *kwnames[] = {
35143 (char *) "self",(char *) "id",(char *) "helpString", NULL
35144 };
35145
35146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35148 if (SWIG_arg_fail(1)) SWIG_fail;
35149 {
35150 arg2 = (int)(SWIG_As_int(obj1));
35151 if (SWIG_arg_fail(2)) SWIG_fail;
35152 }
35153 {
35154 arg3 = wxString_in_helper(obj2);
35155 if (arg3 == NULL) SWIG_fail;
35156 temp3 = true;
35157 }
35158 {
35159 PyThreadState* __tstate = wxPyBeginAllowThreads();
35160 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35161
35162 wxPyEndAllowThreads(__tstate);
35163 if (PyErr_Occurred()) SWIG_fail;
35164 }
35165 Py_INCREF(Py_None); resultobj = Py_None;
35166 {
35167 if (temp3)
35168 delete arg3;
35169 }
35170 return resultobj;
35171 fail:
35172 {
35173 if (temp3)
35174 delete arg3;
35175 }
35176 return NULL;
35177 }
35178
35179
35180 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35181 PyObject *resultobj;
35182 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35183 int arg2 ;
35184 wxString result;
35185 PyObject * obj0 = 0 ;
35186 PyObject * obj1 = 0 ;
35187 char *kwnames[] = {
35188 (char *) "self",(char *) "id", NULL
35189 };
35190
35191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35193 if (SWIG_arg_fail(1)) SWIG_fail;
35194 {
35195 arg2 = (int)(SWIG_As_int(obj1));
35196 if (SWIG_arg_fail(2)) SWIG_fail;
35197 }
35198 {
35199 PyThreadState* __tstate = wxPyBeginAllowThreads();
35200 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35201
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 {
35206 #if wxUSE_UNICODE
35207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35208 #else
35209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35210 #endif
35211 }
35212 return resultobj;
35213 fail:
35214 return NULL;
35215 }
35216
35217
35218 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35219 PyObject *resultobj;
35220 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35221 wxFrame *result;
35222 PyObject * obj0 = 0 ;
35223 char *kwnames[] = {
35224 (char *) "self", NULL
35225 };
35226
35227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35229 if (SWIG_arg_fail(1)) SWIG_fail;
35230 {
35231 PyThreadState* __tstate = wxPyBeginAllowThreads();
35232 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
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_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35247 PyObject *resultobj;
35248 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35249 bool result;
35250 PyObject * obj0 = 0 ;
35251 char *kwnames[] = {
35252 (char *) "self", NULL
35253 };
35254
35255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35257 if (SWIG_arg_fail(1)) SWIG_fail;
35258 {
35259 PyThreadState* __tstate = wxPyBeginAllowThreads();
35260 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35261
35262 wxPyEndAllowThreads(__tstate);
35263 if (PyErr_Occurred()) SWIG_fail;
35264 }
35265 {
35266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35267 }
35268 return resultobj;
35269 fail:
35270 return NULL;
35271 }
35272
35273
35274 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35275 PyObject *resultobj;
35276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35277 wxFrame *arg2 = (wxFrame *) 0 ;
35278 PyObject * obj0 = 0 ;
35279 PyObject * obj1 = 0 ;
35280 char *kwnames[] = {
35281 (char *) "self",(char *) "frame", NULL
35282 };
35283
35284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35286 if (SWIG_arg_fail(1)) SWIG_fail;
35287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35288 if (SWIG_arg_fail(2)) SWIG_fail;
35289 {
35290 PyThreadState* __tstate = wxPyBeginAllowThreads();
35291 (arg1)->Attach(arg2);
35292
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 Py_INCREF(Py_None); resultobj = Py_None;
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35304 PyObject *resultobj;
35305 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35306 PyObject * obj0 = 0 ;
35307 char *kwnames[] = {
35308 (char *) "self", NULL
35309 };
35310
35311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35313 if (SWIG_arg_fail(1)) SWIG_fail;
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 (arg1)->Detach();
35317
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 Py_INCREF(Py_None); resultobj = Py_None;
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35329 PyObject *obj;
35330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35331 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35332 Py_INCREF(obj);
35333 return Py_BuildValue((char *)"");
35334 }
35335 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35336 PyObject *resultobj;
35337 wxMenu *arg1 = (wxMenu *) NULL ;
35338 int arg2 = (int) wxID_ANY ;
35339 wxString const &arg3_defvalue = wxPyEmptyString ;
35340 wxString *arg3 = (wxString *) &arg3_defvalue ;
35341 wxString const &arg4_defvalue = wxPyEmptyString ;
35342 wxString *arg4 = (wxString *) &arg4_defvalue ;
35343 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35344 wxMenu *arg6 = (wxMenu *) NULL ;
35345 wxMenuItem *result;
35346 bool temp3 = false ;
35347 bool temp4 = false ;
35348 PyObject * obj0 = 0 ;
35349 PyObject * obj1 = 0 ;
35350 PyObject * obj2 = 0 ;
35351 PyObject * obj3 = 0 ;
35352 PyObject * obj4 = 0 ;
35353 PyObject * obj5 = 0 ;
35354 char *kwnames[] = {
35355 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35356 };
35357
35358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35359 if (obj0) {
35360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35361 if (SWIG_arg_fail(1)) SWIG_fail;
35362 }
35363 if (obj1) {
35364 {
35365 arg2 = (int)(SWIG_As_int(obj1));
35366 if (SWIG_arg_fail(2)) SWIG_fail;
35367 }
35368 }
35369 if (obj2) {
35370 {
35371 arg3 = wxString_in_helper(obj2);
35372 if (arg3 == NULL) SWIG_fail;
35373 temp3 = true;
35374 }
35375 }
35376 if (obj3) {
35377 {
35378 arg4 = wxString_in_helper(obj3);
35379 if (arg4 == NULL) SWIG_fail;
35380 temp4 = true;
35381 }
35382 }
35383 if (obj4) {
35384 {
35385 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35386 if (SWIG_arg_fail(5)) SWIG_fail;
35387 }
35388 }
35389 if (obj5) {
35390 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35391 if (SWIG_arg_fail(6)) SWIG_fail;
35392 }
35393 {
35394 PyThreadState* __tstate = wxPyBeginAllowThreads();
35395 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35396
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 {
35401 resultobj = wxPyMake_wxObject(result, 1);
35402 }
35403 {
35404 if (temp3)
35405 delete arg3;
35406 }
35407 {
35408 if (temp4)
35409 delete arg4;
35410 }
35411 return resultobj;
35412 fail:
35413 {
35414 if (temp3)
35415 delete arg3;
35416 }
35417 {
35418 if (temp4)
35419 delete arg4;
35420 }
35421 return NULL;
35422 }
35423
35424
35425 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35426 PyObject *resultobj;
35427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35428 wxMenu *result;
35429 PyObject * obj0 = 0 ;
35430 char *kwnames[] = {
35431 (char *) "self", NULL
35432 };
35433
35434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35436 if (SWIG_arg_fail(1)) SWIG_fail;
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35440
35441 wxPyEndAllowThreads(__tstate);
35442 if (PyErr_Occurred()) SWIG_fail;
35443 }
35444 {
35445 resultobj = wxPyMake_wxObject(result, 0);
35446 }
35447 return resultobj;
35448 fail:
35449 return NULL;
35450 }
35451
35452
35453 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35454 PyObject *resultobj;
35455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35456 wxMenu *arg2 = (wxMenu *) 0 ;
35457 PyObject * obj0 = 0 ;
35458 PyObject * obj1 = 0 ;
35459 char *kwnames[] = {
35460 (char *) "self",(char *) "menu", NULL
35461 };
35462
35463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35465 if (SWIG_arg_fail(1)) SWIG_fail;
35466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35467 if (SWIG_arg_fail(2)) SWIG_fail;
35468 {
35469 PyThreadState* __tstate = wxPyBeginAllowThreads();
35470 (arg1)->SetMenu(arg2);
35471
35472 wxPyEndAllowThreads(__tstate);
35473 if (PyErr_Occurred()) SWIG_fail;
35474 }
35475 Py_INCREF(Py_None); resultobj = Py_None;
35476 return resultobj;
35477 fail:
35478 return NULL;
35479 }
35480
35481
35482 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35483 PyObject *resultobj;
35484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35485 int arg2 ;
35486 PyObject * obj0 = 0 ;
35487 PyObject * obj1 = 0 ;
35488 char *kwnames[] = {
35489 (char *) "self",(char *) "id", NULL
35490 };
35491
35492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35494 if (SWIG_arg_fail(1)) SWIG_fail;
35495 {
35496 arg2 = (int)(SWIG_As_int(obj1));
35497 if (SWIG_arg_fail(2)) SWIG_fail;
35498 }
35499 {
35500 PyThreadState* __tstate = wxPyBeginAllowThreads();
35501 (arg1)->SetId(arg2);
35502
35503 wxPyEndAllowThreads(__tstate);
35504 if (PyErr_Occurred()) SWIG_fail;
35505 }
35506 Py_INCREF(Py_None); resultobj = Py_None;
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35514 PyObject *resultobj;
35515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35516 int result;
35517 PyObject * obj0 = 0 ;
35518 char *kwnames[] = {
35519 (char *) "self", NULL
35520 };
35521
35522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35524 if (SWIG_arg_fail(1)) SWIG_fail;
35525 {
35526 PyThreadState* __tstate = wxPyBeginAllowThreads();
35527 result = (int)((wxMenuItem const *)arg1)->GetId();
35528
35529 wxPyEndAllowThreads(__tstate);
35530 if (PyErr_Occurred()) SWIG_fail;
35531 }
35532 {
35533 resultobj = SWIG_From_int((int)(result));
35534 }
35535 return resultobj;
35536 fail:
35537 return NULL;
35538 }
35539
35540
35541 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35542 PyObject *resultobj;
35543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35544 bool result;
35545 PyObject * obj0 = 0 ;
35546 char *kwnames[] = {
35547 (char *) "self", NULL
35548 };
35549
35550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35552 if (SWIG_arg_fail(1)) SWIG_fail;
35553 {
35554 PyThreadState* __tstate = wxPyBeginAllowThreads();
35555 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35556
35557 wxPyEndAllowThreads(__tstate);
35558 if (PyErr_Occurred()) SWIG_fail;
35559 }
35560 {
35561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35562 }
35563 return resultobj;
35564 fail:
35565 return NULL;
35566 }
35567
35568
35569 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35570 PyObject *resultobj;
35571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35572 wxString *arg2 = 0 ;
35573 bool temp2 = false ;
35574 PyObject * obj0 = 0 ;
35575 PyObject * obj1 = 0 ;
35576 char *kwnames[] = {
35577 (char *) "self",(char *) "str", NULL
35578 };
35579
35580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35582 if (SWIG_arg_fail(1)) SWIG_fail;
35583 {
35584 arg2 = wxString_in_helper(obj1);
35585 if (arg2 == NULL) SWIG_fail;
35586 temp2 = true;
35587 }
35588 {
35589 PyThreadState* __tstate = wxPyBeginAllowThreads();
35590 (arg1)->SetText((wxString const &)*arg2);
35591
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 Py_INCREF(Py_None); resultobj = Py_None;
35596 {
35597 if (temp2)
35598 delete arg2;
35599 }
35600 return resultobj;
35601 fail:
35602 {
35603 if (temp2)
35604 delete arg2;
35605 }
35606 return NULL;
35607 }
35608
35609
35610 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35611 PyObject *resultobj;
35612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35613 wxString result;
35614 PyObject * obj0 = 0 ;
35615 char *kwnames[] = {
35616 (char *) "self", NULL
35617 };
35618
35619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35621 if (SWIG_arg_fail(1)) SWIG_fail;
35622 {
35623 PyThreadState* __tstate = wxPyBeginAllowThreads();
35624 result = ((wxMenuItem const *)arg1)->GetLabel();
35625
35626 wxPyEndAllowThreads(__tstate);
35627 if (PyErr_Occurred()) SWIG_fail;
35628 }
35629 {
35630 #if wxUSE_UNICODE
35631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35632 #else
35633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35634 #endif
35635 }
35636 return resultobj;
35637 fail:
35638 return NULL;
35639 }
35640
35641
35642 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35643 PyObject *resultobj;
35644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35645 wxString *result;
35646 PyObject * obj0 = 0 ;
35647 char *kwnames[] = {
35648 (char *) "self", NULL
35649 };
35650
35651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35653 if (SWIG_arg_fail(1)) SWIG_fail;
35654 {
35655 PyThreadState* __tstate = wxPyBeginAllowThreads();
35656 {
35657 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35658 result = (wxString *) &_result_ref;
35659 }
35660
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 {
35665 #if wxUSE_UNICODE
35666 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35667 #else
35668 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35669 #endif
35670 }
35671 return resultobj;
35672 fail:
35673 return NULL;
35674 }
35675
35676
35677 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35678 PyObject *resultobj;
35679 wxString *arg1 = 0 ;
35680 wxString result;
35681 bool temp1 = false ;
35682 PyObject * obj0 = 0 ;
35683 char *kwnames[] = {
35684 (char *) "text", NULL
35685 };
35686
35687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35688 {
35689 arg1 = wxString_in_helper(obj0);
35690 if (arg1 == NULL) SWIG_fail;
35691 temp1 = true;
35692 }
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35696
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 {
35701 #if wxUSE_UNICODE
35702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35703 #else
35704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35705 #endif
35706 }
35707 {
35708 if (temp1)
35709 delete arg1;
35710 }
35711 return resultobj;
35712 fail:
35713 {
35714 if (temp1)
35715 delete arg1;
35716 }
35717 return NULL;
35718 }
35719
35720
35721 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35722 PyObject *resultobj;
35723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35724 wxItemKind result;
35725 PyObject * obj0 = 0 ;
35726 char *kwnames[] = {
35727 (char *) "self", NULL
35728 };
35729
35730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35732 if (SWIG_arg_fail(1)) SWIG_fail;
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35736
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_From_int((result));
35741 return resultobj;
35742 fail:
35743 return NULL;
35744 }
35745
35746
35747 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35748 PyObject *resultobj;
35749 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35750 wxItemKind arg2 ;
35751 PyObject * obj0 = 0 ;
35752 PyObject * obj1 = 0 ;
35753 char *kwnames[] = {
35754 (char *) "self",(char *) "kind", NULL
35755 };
35756
35757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35759 if (SWIG_arg_fail(1)) SWIG_fail;
35760 {
35761 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35762 if (SWIG_arg_fail(2)) SWIG_fail;
35763 }
35764 {
35765 PyThreadState* __tstate = wxPyBeginAllowThreads();
35766 (arg1)->SetKind((wxItemKind )arg2);
35767
35768 wxPyEndAllowThreads(__tstate);
35769 if (PyErr_Occurred()) SWIG_fail;
35770 }
35771 Py_INCREF(Py_None); resultobj = Py_None;
35772 return resultobj;
35773 fail:
35774 return NULL;
35775 }
35776
35777
35778 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35779 PyObject *resultobj;
35780 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35781 bool arg2 ;
35782 PyObject * obj0 = 0 ;
35783 PyObject * obj1 = 0 ;
35784 char *kwnames[] = {
35785 (char *) "self",(char *) "checkable", NULL
35786 };
35787
35788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35790 if (SWIG_arg_fail(1)) SWIG_fail;
35791 {
35792 arg2 = (bool)(SWIG_As_bool(obj1));
35793 if (SWIG_arg_fail(2)) SWIG_fail;
35794 }
35795 {
35796 PyThreadState* __tstate = wxPyBeginAllowThreads();
35797 (arg1)->SetCheckable(arg2);
35798
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 Py_INCREF(Py_None); resultobj = Py_None;
35803 return resultobj;
35804 fail:
35805 return NULL;
35806 }
35807
35808
35809 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj;
35811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35812 bool result;
35813 PyObject * obj0 = 0 ;
35814 char *kwnames[] = {
35815 (char *) "self", NULL
35816 };
35817
35818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",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 = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35824
35825 wxPyEndAllowThreads(__tstate);
35826 if (PyErr_Occurred()) SWIG_fail;
35827 }
35828 {
35829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35830 }
35831 return resultobj;
35832 fail:
35833 return NULL;
35834 }
35835
35836
35837 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj;
35839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35840 bool result;
35841 PyObject * obj0 = 0 ;
35842 char *kwnames[] = {
35843 (char *) "self", NULL
35844 };
35845
35846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35848 if (SWIG_arg_fail(1)) SWIG_fail;
35849 {
35850 PyThreadState* __tstate = wxPyBeginAllowThreads();
35851 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35852
35853 wxPyEndAllowThreads(__tstate);
35854 if (PyErr_Occurred()) SWIG_fail;
35855 }
35856 {
35857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35858 }
35859 return resultobj;
35860 fail:
35861 return NULL;
35862 }
35863
35864
35865 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35866 PyObject *resultobj;
35867 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35868 wxMenu *arg2 = (wxMenu *) 0 ;
35869 PyObject * obj0 = 0 ;
35870 PyObject * obj1 = 0 ;
35871 char *kwnames[] = {
35872 (char *) "self",(char *) "menu", NULL
35873 };
35874
35875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35877 if (SWIG_arg_fail(1)) SWIG_fail;
35878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35879 if (SWIG_arg_fail(2)) SWIG_fail;
35880 {
35881 PyThreadState* __tstate = wxPyBeginAllowThreads();
35882 (arg1)->SetSubMenu(arg2);
35883
35884 wxPyEndAllowThreads(__tstate);
35885 if (PyErr_Occurred()) SWIG_fail;
35886 }
35887 Py_INCREF(Py_None); resultobj = Py_None;
35888 return resultobj;
35889 fail:
35890 return NULL;
35891 }
35892
35893
35894 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35895 PyObject *resultobj;
35896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35897 wxMenu *result;
35898 PyObject * obj0 = 0 ;
35899 char *kwnames[] = {
35900 (char *) "self", NULL
35901 };
35902
35903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35905 if (SWIG_arg_fail(1)) SWIG_fail;
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35909
35910 wxPyEndAllowThreads(__tstate);
35911 if (PyErr_Occurred()) SWIG_fail;
35912 }
35913 {
35914 resultobj = wxPyMake_wxObject(result, 0);
35915 }
35916 return resultobj;
35917 fail:
35918 return NULL;
35919 }
35920
35921
35922 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35923 PyObject *resultobj;
35924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35925 bool arg2 = (bool) true ;
35926 PyObject * obj0 = 0 ;
35927 PyObject * obj1 = 0 ;
35928 char *kwnames[] = {
35929 (char *) "self",(char *) "enable", NULL
35930 };
35931
35932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35934 if (SWIG_arg_fail(1)) SWIG_fail;
35935 if (obj1) {
35936 {
35937 arg2 = (bool)(SWIG_As_bool(obj1));
35938 if (SWIG_arg_fail(2)) SWIG_fail;
35939 }
35940 }
35941 {
35942 PyThreadState* __tstate = wxPyBeginAllowThreads();
35943 (arg1)->Enable(arg2);
35944
35945 wxPyEndAllowThreads(__tstate);
35946 if (PyErr_Occurred()) SWIG_fail;
35947 }
35948 Py_INCREF(Py_None); resultobj = Py_None;
35949 return resultobj;
35950 fail:
35951 return NULL;
35952 }
35953
35954
35955 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35956 PyObject *resultobj;
35957 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35958 bool result;
35959 PyObject * obj0 = 0 ;
35960 char *kwnames[] = {
35961 (char *) "self", NULL
35962 };
35963
35964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35970
35971 wxPyEndAllowThreads(__tstate);
35972 if (PyErr_Occurred()) SWIG_fail;
35973 }
35974 {
35975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35976 }
35977 return resultobj;
35978 fail:
35979 return NULL;
35980 }
35981
35982
35983 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35984 PyObject *resultobj;
35985 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35986 bool arg2 = (bool) true ;
35987 PyObject * obj0 = 0 ;
35988 PyObject * obj1 = 0 ;
35989 char *kwnames[] = {
35990 (char *) "self",(char *) "check", NULL
35991 };
35992
35993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35995 if (SWIG_arg_fail(1)) SWIG_fail;
35996 if (obj1) {
35997 {
35998 arg2 = (bool)(SWIG_As_bool(obj1));
35999 if (SWIG_arg_fail(2)) SWIG_fail;
36000 }
36001 }
36002 {
36003 PyThreadState* __tstate = wxPyBeginAllowThreads();
36004 (arg1)->Check(arg2);
36005
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 Py_INCREF(Py_None); resultobj = Py_None;
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36017 PyObject *resultobj;
36018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36019 bool result;
36020 PyObject * obj0 = 0 ;
36021 char *kwnames[] = {
36022 (char *) "self", NULL
36023 };
36024
36025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36027 if (SWIG_arg_fail(1)) SWIG_fail;
36028 {
36029 PyThreadState* __tstate = wxPyBeginAllowThreads();
36030 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36031
36032 wxPyEndAllowThreads(__tstate);
36033 if (PyErr_Occurred()) SWIG_fail;
36034 }
36035 {
36036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36037 }
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj;
36046 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36047 PyObject * obj0 = 0 ;
36048 char *kwnames[] = {
36049 (char *) "self", NULL
36050 };
36051
36052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36054 if (SWIG_arg_fail(1)) SWIG_fail;
36055 {
36056 PyThreadState* __tstate = wxPyBeginAllowThreads();
36057 (arg1)->Toggle();
36058
36059 wxPyEndAllowThreads(__tstate);
36060 if (PyErr_Occurred()) SWIG_fail;
36061 }
36062 Py_INCREF(Py_None); resultobj = Py_None;
36063 return resultobj;
36064 fail:
36065 return NULL;
36066 }
36067
36068
36069 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36070 PyObject *resultobj;
36071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36072 wxString *arg2 = 0 ;
36073 bool temp2 = false ;
36074 PyObject * obj0 = 0 ;
36075 PyObject * obj1 = 0 ;
36076 char *kwnames[] = {
36077 (char *) "self",(char *) "str", NULL
36078 };
36079
36080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(1)) SWIG_fail;
36083 {
36084 arg2 = wxString_in_helper(obj1);
36085 if (arg2 == NULL) SWIG_fail;
36086 temp2 = true;
36087 }
36088 {
36089 PyThreadState* __tstate = wxPyBeginAllowThreads();
36090 (arg1)->SetHelp((wxString const &)*arg2);
36091
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 Py_INCREF(Py_None); resultobj = Py_None;
36096 {
36097 if (temp2)
36098 delete arg2;
36099 }
36100 return resultobj;
36101 fail:
36102 {
36103 if (temp2)
36104 delete arg2;
36105 }
36106 return NULL;
36107 }
36108
36109
36110 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36111 PyObject *resultobj;
36112 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36113 wxString *result;
36114 PyObject * obj0 = 0 ;
36115 char *kwnames[] = {
36116 (char *) "self", NULL
36117 };
36118
36119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36121 if (SWIG_arg_fail(1)) SWIG_fail;
36122 {
36123 PyThreadState* __tstate = wxPyBeginAllowThreads();
36124 {
36125 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36126 result = (wxString *) &_result_ref;
36127 }
36128
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 {
36133 #if wxUSE_UNICODE
36134 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36135 #else
36136 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36137 #endif
36138 }
36139 return resultobj;
36140 fail:
36141 return NULL;
36142 }
36143
36144
36145 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36146 PyObject *resultobj;
36147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36148 wxAcceleratorEntry *result;
36149 PyObject * obj0 = 0 ;
36150 char *kwnames[] = {
36151 (char *) "self", NULL
36152 };
36153
36154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36156 if (SWIG_arg_fail(1)) SWIG_fail;
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36160
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36165 return resultobj;
36166 fail:
36167 return NULL;
36168 }
36169
36170
36171 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36172 PyObject *resultobj;
36173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36174 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36175 PyObject * obj0 = 0 ;
36176 PyObject * obj1 = 0 ;
36177 char *kwnames[] = {
36178 (char *) "self",(char *) "accel", NULL
36179 };
36180
36181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36183 if (SWIG_arg_fail(1)) SWIG_fail;
36184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36185 if (SWIG_arg_fail(2)) SWIG_fail;
36186 {
36187 PyThreadState* __tstate = wxPyBeginAllowThreads();
36188 (arg1)->SetAccel(arg2);
36189
36190 wxPyEndAllowThreads(__tstate);
36191 if (PyErr_Occurred()) SWIG_fail;
36192 }
36193 Py_INCREF(Py_None); resultobj = Py_None;
36194 return resultobj;
36195 fail:
36196 return NULL;
36197 }
36198
36199
36200 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36201 PyObject *resultobj;
36202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36203 wxFont *arg2 = 0 ;
36204 PyObject * obj0 = 0 ;
36205 PyObject * obj1 = 0 ;
36206 char *kwnames[] = {
36207 (char *) "self",(char *) "font", NULL
36208 };
36209
36210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36212 if (SWIG_arg_fail(1)) SWIG_fail;
36213 {
36214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36215 if (SWIG_arg_fail(2)) SWIG_fail;
36216 if (arg2 == NULL) {
36217 SWIG_null_ref("wxFont");
36218 }
36219 if (SWIG_arg_fail(2)) SWIG_fail;
36220 }
36221 {
36222 PyThreadState* __tstate = wxPyBeginAllowThreads();
36223 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36224
36225 wxPyEndAllowThreads(__tstate);
36226 if (PyErr_Occurred()) SWIG_fail;
36227 }
36228 Py_INCREF(Py_None); resultobj = Py_None;
36229 return resultobj;
36230 fail:
36231 return NULL;
36232 }
36233
36234
36235 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36236 PyObject *resultobj;
36237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36238 wxFont result;
36239 PyObject * obj0 = 0 ;
36240 char *kwnames[] = {
36241 (char *) "self", NULL
36242 };
36243
36244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36246 if (SWIG_arg_fail(1)) SWIG_fail;
36247 {
36248 PyThreadState* __tstate = wxPyBeginAllowThreads();
36249 result = wxMenuItem_GetFont(arg1);
36250
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 {
36255 wxFont * resultptr;
36256 resultptr = new wxFont((wxFont &)(result));
36257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36258 }
36259 return resultobj;
36260 fail:
36261 return NULL;
36262 }
36263
36264
36265 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36266 PyObject *resultobj;
36267 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36268 wxColour *arg2 = 0 ;
36269 wxColour temp2 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 char *kwnames[] = {
36273 (char *) "self",(char *) "colText", NULL
36274 };
36275
36276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36278 if (SWIG_arg_fail(1)) SWIG_fail;
36279 {
36280 arg2 = &temp2;
36281 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36282 }
36283 {
36284 PyThreadState* __tstate = wxPyBeginAllowThreads();
36285 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36286
36287 wxPyEndAllowThreads(__tstate);
36288 if (PyErr_Occurred()) SWIG_fail;
36289 }
36290 Py_INCREF(Py_None); resultobj = Py_None;
36291 return resultobj;
36292 fail:
36293 return NULL;
36294 }
36295
36296
36297 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36298 PyObject *resultobj;
36299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36300 wxColour result;
36301 PyObject * obj0 = 0 ;
36302 char *kwnames[] = {
36303 (char *) "self", NULL
36304 };
36305
36306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36308 if (SWIG_arg_fail(1)) SWIG_fail;
36309 {
36310 PyThreadState* __tstate = wxPyBeginAllowThreads();
36311 result = wxMenuItem_GetTextColour(arg1);
36312
36313 wxPyEndAllowThreads(__tstate);
36314 if (PyErr_Occurred()) SWIG_fail;
36315 }
36316 {
36317 wxColour * resultptr;
36318 resultptr = new wxColour((wxColour &)(result));
36319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36320 }
36321 return resultobj;
36322 fail:
36323 return NULL;
36324 }
36325
36326
36327 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36328 PyObject *resultobj;
36329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36330 wxColour *arg2 = 0 ;
36331 wxColour temp2 ;
36332 PyObject * obj0 = 0 ;
36333 PyObject * obj1 = 0 ;
36334 char *kwnames[] = {
36335 (char *) "self",(char *) "colBack", NULL
36336 };
36337
36338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36340 if (SWIG_arg_fail(1)) SWIG_fail;
36341 {
36342 arg2 = &temp2;
36343 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36344 }
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36348
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 Py_INCREF(Py_None); resultobj = Py_None;
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj;
36361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36362 wxColour result;
36363 PyObject * obj0 = 0 ;
36364 char *kwnames[] = {
36365 (char *) "self", NULL
36366 };
36367
36368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36370 if (SWIG_arg_fail(1)) SWIG_fail;
36371 {
36372 PyThreadState* __tstate = wxPyBeginAllowThreads();
36373 result = wxMenuItem_GetBackgroundColour(arg1);
36374
36375 wxPyEndAllowThreads(__tstate);
36376 if (PyErr_Occurred()) SWIG_fail;
36377 }
36378 {
36379 wxColour * resultptr;
36380 resultptr = new wxColour((wxColour &)(result));
36381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36382 }
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36390 PyObject *resultobj;
36391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36392 wxBitmap *arg2 = 0 ;
36393 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36394 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36395 PyObject * obj0 = 0 ;
36396 PyObject * obj1 = 0 ;
36397 PyObject * obj2 = 0 ;
36398 char *kwnames[] = {
36399 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36400 };
36401
36402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36404 if (SWIG_arg_fail(1)) SWIG_fail;
36405 {
36406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36407 if (SWIG_arg_fail(2)) SWIG_fail;
36408 if (arg2 == NULL) {
36409 SWIG_null_ref("wxBitmap");
36410 }
36411 if (SWIG_arg_fail(2)) SWIG_fail;
36412 }
36413 if (obj2) {
36414 {
36415 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36416 if (SWIG_arg_fail(3)) SWIG_fail;
36417 if (arg3 == NULL) {
36418 SWIG_null_ref("wxBitmap");
36419 }
36420 if (SWIG_arg_fail(3)) SWIG_fail;
36421 }
36422 }
36423 {
36424 PyThreadState* __tstate = wxPyBeginAllowThreads();
36425 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36426
36427 wxPyEndAllowThreads(__tstate);
36428 if (PyErr_Occurred()) SWIG_fail;
36429 }
36430 Py_INCREF(Py_None); resultobj = Py_None;
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36438 PyObject *resultobj;
36439 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36440 wxBitmap *arg2 = 0 ;
36441 PyObject * obj0 = 0 ;
36442 PyObject * obj1 = 0 ;
36443 char *kwnames[] = {
36444 (char *) "self",(char *) "bmpDisabled", NULL
36445 };
36446
36447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36449 if (SWIG_arg_fail(1)) SWIG_fail;
36450 {
36451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36452 if (SWIG_arg_fail(2)) SWIG_fail;
36453 if (arg2 == NULL) {
36454 SWIG_null_ref("wxBitmap");
36455 }
36456 if (SWIG_arg_fail(2)) SWIG_fail;
36457 }
36458 {
36459 PyThreadState* __tstate = wxPyBeginAllowThreads();
36460 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36461
36462 wxPyEndAllowThreads(__tstate);
36463 if (PyErr_Occurred()) SWIG_fail;
36464 }
36465 Py_INCREF(Py_None); resultobj = Py_None;
36466 return resultobj;
36467 fail:
36468 return NULL;
36469 }
36470
36471
36472 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36473 PyObject *resultobj;
36474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36475 wxBitmap *result;
36476 PyObject * obj0 = 0 ;
36477 char *kwnames[] = {
36478 (char *) "self", NULL
36479 };
36480
36481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36483 if (SWIG_arg_fail(1)) SWIG_fail;
36484 {
36485 PyThreadState* __tstate = wxPyBeginAllowThreads();
36486 {
36487 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36488 result = (wxBitmap *) &_result_ref;
36489 }
36490
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 {
36495 wxBitmap* resultptr = new wxBitmap(*result);
36496 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36497 }
36498 return resultobj;
36499 fail:
36500 return NULL;
36501 }
36502
36503
36504 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36505 PyObject *resultobj;
36506 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36507 int arg2 ;
36508 PyObject * obj0 = 0 ;
36509 PyObject * obj1 = 0 ;
36510 char *kwnames[] = {
36511 (char *) "self",(char *) "nWidth", NULL
36512 };
36513
36514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36516 if (SWIG_arg_fail(1)) SWIG_fail;
36517 {
36518 arg2 = (int)(SWIG_As_int(obj1));
36519 if (SWIG_arg_fail(2)) SWIG_fail;
36520 }
36521 {
36522 PyThreadState* __tstate = wxPyBeginAllowThreads();
36523 wxMenuItem_SetMarginWidth(arg1,arg2);
36524
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 Py_INCREF(Py_None); resultobj = Py_None;
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj;
36537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36538 int result;
36539 PyObject * obj0 = 0 ;
36540 char *kwnames[] = {
36541 (char *) "self", NULL
36542 };
36543
36544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36546 if (SWIG_arg_fail(1)) SWIG_fail;
36547 {
36548 PyThreadState* __tstate = wxPyBeginAllowThreads();
36549 result = (int)wxMenuItem_GetMarginWidth(arg1);
36550
36551 wxPyEndAllowThreads(__tstate);
36552 if (PyErr_Occurred()) SWIG_fail;
36553 }
36554 {
36555 resultobj = SWIG_From_int((int)(result));
36556 }
36557 return resultobj;
36558 fail:
36559 return NULL;
36560 }
36561
36562
36563 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36564 PyObject *resultobj;
36565 int result;
36566 char *kwnames[] = {
36567 NULL
36568 };
36569
36570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 result = (int)MenuItem_GetDefaultMarginWidth();
36574
36575 wxPyEndAllowThreads(__tstate);
36576 if (PyErr_Occurred()) SWIG_fail;
36577 }
36578 {
36579 resultobj = SWIG_From_int((int)(result));
36580 }
36581 return resultobj;
36582 fail:
36583 return NULL;
36584 }
36585
36586
36587 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36588 PyObject *resultobj;
36589 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36590 bool result;
36591 PyObject * obj0 = 0 ;
36592 char *kwnames[] = {
36593 (char *) "self", NULL
36594 };
36595
36596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36598 if (SWIG_arg_fail(1)) SWIG_fail;
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
36602
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 {
36607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36608 }
36609 return resultobj;
36610 fail:
36611 return NULL;
36612 }
36613
36614
36615 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36616 PyObject *resultobj;
36617 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36618 bool arg2 = (bool) true ;
36619 PyObject * obj0 = 0 ;
36620 PyObject * obj1 = 0 ;
36621 char *kwnames[] = {
36622 (char *) "self",(char *) "ownerDrawn", NULL
36623 };
36624
36625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36627 if (SWIG_arg_fail(1)) SWIG_fail;
36628 if (obj1) {
36629 {
36630 arg2 = (bool)(SWIG_As_bool(obj1));
36631 if (SWIG_arg_fail(2)) SWIG_fail;
36632 }
36633 }
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 wxMenuItem_SetOwnerDrawn(arg1,arg2);
36637
36638 wxPyEndAllowThreads(__tstate);
36639 if (PyErr_Occurred()) SWIG_fail;
36640 }
36641 Py_INCREF(Py_None); resultobj = Py_None;
36642 return resultobj;
36643 fail:
36644 return NULL;
36645 }
36646
36647
36648 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36649 PyObject *resultobj;
36650 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36651 PyObject * obj0 = 0 ;
36652 char *kwnames[] = {
36653 (char *) "self", NULL
36654 };
36655
36656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36658 if (SWIG_arg_fail(1)) SWIG_fail;
36659 {
36660 PyThreadState* __tstate = wxPyBeginAllowThreads();
36661 wxMenuItem_ResetOwnerDrawn(arg1);
36662
36663 wxPyEndAllowThreads(__tstate);
36664 if (PyErr_Occurred()) SWIG_fail;
36665 }
36666 Py_INCREF(Py_None); resultobj = Py_None;
36667 return resultobj;
36668 fail:
36669 return NULL;
36670 }
36671
36672
36673 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36674 PyObject *resultobj;
36675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36676 wxBitmap *arg2 = 0 ;
36677 PyObject * obj0 = 0 ;
36678 PyObject * obj1 = 0 ;
36679 char *kwnames[] = {
36680 (char *) "self",(char *) "bitmap", NULL
36681 };
36682
36683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36685 if (SWIG_arg_fail(1)) SWIG_fail;
36686 {
36687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36688 if (SWIG_arg_fail(2)) SWIG_fail;
36689 if (arg2 == NULL) {
36690 SWIG_null_ref("wxBitmap");
36691 }
36692 if (SWIG_arg_fail(2)) SWIG_fail;
36693 }
36694 {
36695 PyThreadState* __tstate = wxPyBeginAllowThreads();
36696 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36697
36698 wxPyEndAllowThreads(__tstate);
36699 if (PyErr_Occurred()) SWIG_fail;
36700 }
36701 Py_INCREF(Py_None); resultobj = Py_None;
36702 return resultobj;
36703 fail:
36704 return NULL;
36705 }
36706
36707
36708 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36709 PyObject *resultobj;
36710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36711 wxBitmap *result;
36712 PyObject * obj0 = 0 ;
36713 char *kwnames[] = {
36714 (char *) "self", NULL
36715 };
36716
36717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36719 if (SWIG_arg_fail(1)) SWIG_fail;
36720 {
36721 PyThreadState* __tstate = wxPyBeginAllowThreads();
36722 {
36723 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36724 result = (wxBitmap *) &_result_ref;
36725 }
36726
36727 wxPyEndAllowThreads(__tstate);
36728 if (PyErr_Occurred()) SWIG_fail;
36729 }
36730 {
36731 wxBitmap* resultptr = new wxBitmap(*result);
36732 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36733 }
36734 return resultobj;
36735 fail:
36736 return NULL;
36737 }
36738
36739
36740 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36741 PyObject *obj;
36742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36743 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36744 Py_INCREF(obj);
36745 return Py_BuildValue((char *)"");
36746 }
36747 static int _wrap_ControlNameStr_set(PyObject *) {
36748 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36749 return 1;
36750 }
36751
36752
36753 static PyObject *_wrap_ControlNameStr_get(void) {
36754 PyObject *pyobj;
36755
36756 {
36757 #if wxUSE_UNICODE
36758 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36759 #else
36760 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36761 #endif
36762 }
36763 return pyobj;
36764 }
36765
36766
36767 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36768 PyObject *resultobj;
36769 wxWindow *arg1 = (wxWindow *) 0 ;
36770 int arg2 = (int) -1 ;
36771 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36772 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36773 wxSize const &arg4_defvalue = wxDefaultSize ;
36774 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36775 long arg5 = (long) 0 ;
36776 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36777 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36778 wxString const &arg7_defvalue = wxPyControlNameStr ;
36779 wxString *arg7 = (wxString *) &arg7_defvalue ;
36780 wxControl *result;
36781 wxPoint temp3 ;
36782 wxSize temp4 ;
36783 bool temp7 = false ;
36784 PyObject * obj0 = 0 ;
36785 PyObject * obj1 = 0 ;
36786 PyObject * obj2 = 0 ;
36787 PyObject * obj3 = 0 ;
36788 PyObject * obj4 = 0 ;
36789 PyObject * obj5 = 0 ;
36790 PyObject * obj6 = 0 ;
36791 char *kwnames[] = {
36792 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36793 };
36794
36795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36797 if (SWIG_arg_fail(1)) SWIG_fail;
36798 if (obj1) {
36799 {
36800 arg2 = (int)(SWIG_As_int(obj1));
36801 if (SWIG_arg_fail(2)) SWIG_fail;
36802 }
36803 }
36804 if (obj2) {
36805 {
36806 arg3 = &temp3;
36807 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36808 }
36809 }
36810 if (obj3) {
36811 {
36812 arg4 = &temp4;
36813 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36814 }
36815 }
36816 if (obj4) {
36817 {
36818 arg5 = (long)(SWIG_As_long(obj4));
36819 if (SWIG_arg_fail(5)) SWIG_fail;
36820 }
36821 }
36822 if (obj5) {
36823 {
36824 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36825 if (SWIG_arg_fail(6)) SWIG_fail;
36826 if (arg6 == NULL) {
36827 SWIG_null_ref("wxValidator");
36828 }
36829 if (SWIG_arg_fail(6)) SWIG_fail;
36830 }
36831 }
36832 if (obj6) {
36833 {
36834 arg7 = wxString_in_helper(obj6);
36835 if (arg7 == NULL) SWIG_fail;
36836 temp7 = true;
36837 }
36838 }
36839 {
36840 if (!wxPyCheckForApp()) SWIG_fail;
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36843
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36848 {
36849 if (temp7)
36850 delete arg7;
36851 }
36852 return resultobj;
36853 fail:
36854 {
36855 if (temp7)
36856 delete arg7;
36857 }
36858 return NULL;
36859 }
36860
36861
36862 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36863 PyObject *resultobj;
36864 wxControl *result;
36865 char *kwnames[] = {
36866 NULL
36867 };
36868
36869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36870 {
36871 if (!wxPyCheckForApp()) SWIG_fail;
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (wxControl *)new wxControl();
36874
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj;
36887 wxControl *arg1 = (wxControl *) 0 ;
36888 wxWindow *arg2 = (wxWindow *) 0 ;
36889 int arg3 = (int) -1 ;
36890 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36891 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36892 wxSize const &arg5_defvalue = wxDefaultSize ;
36893 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36894 long arg6 = (long) 0 ;
36895 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36896 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36897 wxString const &arg8_defvalue = wxPyControlNameStr ;
36898 wxString *arg8 = (wxString *) &arg8_defvalue ;
36899 bool result;
36900 wxPoint temp4 ;
36901 wxSize temp5 ;
36902 bool temp8 = false ;
36903 PyObject * obj0 = 0 ;
36904 PyObject * obj1 = 0 ;
36905 PyObject * obj2 = 0 ;
36906 PyObject * obj3 = 0 ;
36907 PyObject * obj4 = 0 ;
36908 PyObject * obj5 = 0 ;
36909 PyObject * obj6 = 0 ;
36910 PyObject * obj7 = 0 ;
36911 char *kwnames[] = {
36912 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36913 };
36914
36915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36917 if (SWIG_arg_fail(1)) SWIG_fail;
36918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36919 if (SWIG_arg_fail(2)) SWIG_fail;
36920 if (obj2) {
36921 {
36922 arg3 = (int)(SWIG_As_int(obj2));
36923 if (SWIG_arg_fail(3)) SWIG_fail;
36924 }
36925 }
36926 if (obj3) {
36927 {
36928 arg4 = &temp4;
36929 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36930 }
36931 }
36932 if (obj4) {
36933 {
36934 arg5 = &temp5;
36935 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36936 }
36937 }
36938 if (obj5) {
36939 {
36940 arg6 = (long)(SWIG_As_long(obj5));
36941 if (SWIG_arg_fail(6)) SWIG_fail;
36942 }
36943 }
36944 if (obj6) {
36945 {
36946 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36947 if (SWIG_arg_fail(7)) SWIG_fail;
36948 if (arg7 == NULL) {
36949 SWIG_null_ref("wxValidator");
36950 }
36951 if (SWIG_arg_fail(7)) SWIG_fail;
36952 }
36953 }
36954 if (obj7) {
36955 {
36956 arg8 = wxString_in_helper(obj7);
36957 if (arg8 == NULL) SWIG_fail;
36958 temp8 = true;
36959 }
36960 }
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36964
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 {
36969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36970 }
36971 {
36972 if (temp8)
36973 delete arg8;
36974 }
36975 return resultobj;
36976 fail:
36977 {
36978 if (temp8)
36979 delete arg8;
36980 }
36981 return NULL;
36982 }
36983
36984
36985 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj;
36987 wxControl *arg1 = (wxControl *) 0 ;
36988 wxCommandEvent *arg2 = 0 ;
36989 PyObject * obj0 = 0 ;
36990 PyObject * obj1 = 0 ;
36991 char *kwnames[] = {
36992 (char *) "self",(char *) "event", NULL
36993 };
36994
36995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36997 if (SWIG_arg_fail(1)) SWIG_fail;
36998 {
36999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37000 if (SWIG_arg_fail(2)) SWIG_fail;
37001 if (arg2 == NULL) {
37002 SWIG_null_ref("wxCommandEvent");
37003 }
37004 if (SWIG_arg_fail(2)) SWIG_fail;
37005 }
37006 {
37007 PyThreadState* __tstate = wxPyBeginAllowThreads();
37008 (arg1)->Command(*arg2);
37009
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 Py_INCREF(Py_None); resultobj = Py_None;
37014 return resultobj;
37015 fail:
37016 return NULL;
37017 }
37018
37019
37020 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37021 PyObject *resultobj;
37022 wxControl *arg1 = (wxControl *) 0 ;
37023 wxString result;
37024 PyObject * obj0 = 0 ;
37025 char *kwnames[] = {
37026 (char *) "self", NULL
37027 };
37028
37029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(1)) SWIG_fail;
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = (arg1)->GetLabel();
37035
37036 wxPyEndAllowThreads(__tstate);
37037 if (PyErr_Occurred()) SWIG_fail;
37038 }
37039 {
37040 #if wxUSE_UNICODE
37041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37042 #else
37043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37044 #endif
37045 }
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj;
37054 wxControl *arg1 = (wxControl *) 0 ;
37055 wxString *arg2 = 0 ;
37056 bool temp2 = false ;
37057 PyObject * obj0 = 0 ;
37058 PyObject * obj1 = 0 ;
37059 char *kwnames[] = {
37060 (char *) "self",(char *) "label", NULL
37061 };
37062
37063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37065 if (SWIG_arg_fail(1)) SWIG_fail;
37066 {
37067 arg2 = wxString_in_helper(obj1);
37068 if (arg2 == NULL) SWIG_fail;
37069 temp2 = true;
37070 }
37071 {
37072 PyThreadState* __tstate = wxPyBeginAllowThreads();
37073 (arg1)->SetLabel((wxString const &)*arg2);
37074
37075 wxPyEndAllowThreads(__tstate);
37076 if (PyErr_Occurred()) SWIG_fail;
37077 }
37078 Py_INCREF(Py_None); resultobj = Py_None;
37079 {
37080 if (temp2)
37081 delete arg2;
37082 }
37083 return resultobj;
37084 fail:
37085 {
37086 if (temp2)
37087 delete arg2;
37088 }
37089 return NULL;
37090 }
37091
37092
37093 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37094 PyObject *resultobj;
37095 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37096 wxVisualAttributes result;
37097 PyObject * obj0 = 0 ;
37098 char *kwnames[] = {
37099 (char *) "variant", NULL
37100 };
37101
37102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37103 if (obj0) {
37104 {
37105 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37106 if (SWIG_arg_fail(1)) SWIG_fail;
37107 }
37108 }
37109 {
37110 if (!wxPyCheckForApp()) SWIG_fail;
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37113
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 {
37118 wxVisualAttributes * resultptr;
37119 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37121 }
37122 return resultobj;
37123 fail:
37124 return NULL;
37125 }
37126
37127
37128 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37129 PyObject *obj;
37130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37131 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37132 Py_INCREF(obj);
37133 return Py_BuildValue((char *)"");
37134 }
37135 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj;
37137 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37138 wxString *arg2 = 0 ;
37139 PyObject *arg3 = (PyObject *) NULL ;
37140 int result;
37141 bool temp2 = false ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 PyObject * obj2 = 0 ;
37145 char *kwnames[] = {
37146 (char *) "self",(char *) "item",(char *) "clientData", NULL
37147 };
37148
37149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37151 if (SWIG_arg_fail(1)) SWIG_fail;
37152 {
37153 arg2 = wxString_in_helper(obj1);
37154 if (arg2 == NULL) SWIG_fail;
37155 temp2 = true;
37156 }
37157 if (obj2) {
37158 arg3 = obj2;
37159 }
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37163
37164 wxPyEndAllowThreads(__tstate);
37165 if (PyErr_Occurred()) SWIG_fail;
37166 }
37167 {
37168 resultobj = SWIG_From_int((int)(result));
37169 }
37170 {
37171 if (temp2)
37172 delete arg2;
37173 }
37174 return resultobj;
37175 fail:
37176 {
37177 if (temp2)
37178 delete arg2;
37179 }
37180 return NULL;
37181 }
37182
37183
37184 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37185 PyObject *resultobj;
37186 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37187 wxArrayString *arg2 = 0 ;
37188 bool temp2 = false ;
37189 PyObject * obj0 = 0 ;
37190 PyObject * obj1 = 0 ;
37191 char *kwnames[] = {
37192 (char *) "self",(char *) "strings", NULL
37193 };
37194
37195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37197 if (SWIG_arg_fail(1)) SWIG_fail;
37198 {
37199 if (! PySequence_Check(obj1)) {
37200 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37201 SWIG_fail;
37202 }
37203 arg2 = new wxArrayString;
37204 temp2 = true;
37205 int i, len=PySequence_Length(obj1);
37206 for (i=0; i<len; i++) {
37207 PyObject* item = PySequence_GetItem(obj1, i);
37208 #if wxUSE_UNICODE
37209 PyObject* str = PyObject_Unicode(item);
37210 #else
37211 PyObject* str = PyObject_Str(item);
37212 #endif
37213 if (PyErr_Occurred()) SWIG_fail;
37214 arg2->Add(Py2wxString(str));
37215 Py_DECREF(item);
37216 Py_DECREF(str);
37217 }
37218 }
37219 {
37220 PyThreadState* __tstate = wxPyBeginAllowThreads();
37221 (arg1)->Append((wxArrayString const &)*arg2);
37222
37223 wxPyEndAllowThreads(__tstate);
37224 if (PyErr_Occurred()) SWIG_fail;
37225 }
37226 Py_INCREF(Py_None); resultobj = Py_None;
37227 {
37228 if (temp2) delete arg2;
37229 }
37230 return resultobj;
37231 fail:
37232 {
37233 if (temp2) delete arg2;
37234 }
37235 return NULL;
37236 }
37237
37238
37239 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37240 PyObject *resultobj;
37241 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37242 wxString *arg2 = 0 ;
37243 int arg3 ;
37244 PyObject *arg4 = (PyObject *) NULL ;
37245 int result;
37246 bool temp2 = false ;
37247 PyObject * obj0 = 0 ;
37248 PyObject * obj1 = 0 ;
37249 PyObject * obj2 = 0 ;
37250 PyObject * obj3 = 0 ;
37251 char *kwnames[] = {
37252 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37253 };
37254
37255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37257 if (SWIG_arg_fail(1)) SWIG_fail;
37258 {
37259 arg2 = wxString_in_helper(obj1);
37260 if (arg2 == NULL) SWIG_fail;
37261 temp2 = true;
37262 }
37263 {
37264 arg3 = (int)(SWIG_As_int(obj2));
37265 if (SWIG_arg_fail(3)) SWIG_fail;
37266 }
37267 if (obj3) {
37268 arg4 = obj3;
37269 }
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37273
37274 wxPyEndAllowThreads(__tstate);
37275 if (PyErr_Occurred()) SWIG_fail;
37276 }
37277 {
37278 resultobj = SWIG_From_int((int)(result));
37279 }
37280 {
37281 if (temp2)
37282 delete arg2;
37283 }
37284 return resultobj;
37285 fail:
37286 {
37287 if (temp2)
37288 delete arg2;
37289 }
37290 return NULL;
37291 }
37292
37293
37294 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37295 PyObject *resultobj;
37296 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37297 PyObject * obj0 = 0 ;
37298 char *kwnames[] = {
37299 (char *) "self", NULL
37300 };
37301
37302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37304 if (SWIG_arg_fail(1)) SWIG_fail;
37305 {
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 (arg1)->Clear();
37308
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 Py_INCREF(Py_None); resultobj = Py_None;
37313 return resultobj;
37314 fail:
37315 return NULL;
37316 }
37317
37318
37319 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37320 PyObject *resultobj;
37321 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37322 int arg2 ;
37323 PyObject * obj0 = 0 ;
37324 PyObject * obj1 = 0 ;
37325 char *kwnames[] = {
37326 (char *) "self",(char *) "n", NULL
37327 };
37328
37329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37331 if (SWIG_arg_fail(1)) SWIG_fail;
37332 {
37333 arg2 = (int)(SWIG_As_int(obj1));
37334 if (SWIG_arg_fail(2)) SWIG_fail;
37335 }
37336 {
37337 PyThreadState* __tstate = wxPyBeginAllowThreads();
37338 (arg1)->Delete(arg2);
37339
37340 wxPyEndAllowThreads(__tstate);
37341 if (PyErr_Occurred()) SWIG_fail;
37342 }
37343 Py_INCREF(Py_None); resultobj = Py_None;
37344 return resultobj;
37345 fail:
37346 return NULL;
37347 }
37348
37349
37350 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37351 PyObject *resultobj;
37352 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37353 int arg2 ;
37354 PyObject *result;
37355 PyObject * obj0 = 0 ;
37356 PyObject * obj1 = 0 ;
37357 char *kwnames[] = {
37358 (char *) "self",(char *) "n", NULL
37359 };
37360
37361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37363 if (SWIG_arg_fail(1)) SWIG_fail;
37364 {
37365 arg2 = (int)(SWIG_As_int(obj1));
37366 if (SWIG_arg_fail(2)) SWIG_fail;
37367 }
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37371
37372 wxPyEndAllowThreads(__tstate);
37373 if (PyErr_Occurred()) SWIG_fail;
37374 }
37375 resultobj = result;
37376 return resultobj;
37377 fail:
37378 return NULL;
37379 }
37380
37381
37382 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37383 PyObject *resultobj;
37384 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37385 int arg2 ;
37386 PyObject *arg3 = (PyObject *) 0 ;
37387 PyObject * obj0 = 0 ;
37388 PyObject * obj1 = 0 ;
37389 PyObject * obj2 = 0 ;
37390 char *kwnames[] = {
37391 (char *) "self",(char *) "n",(char *) "clientData", NULL
37392 };
37393
37394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37396 if (SWIG_arg_fail(1)) SWIG_fail;
37397 {
37398 arg2 = (int)(SWIG_As_int(obj1));
37399 if (SWIG_arg_fail(2)) SWIG_fail;
37400 }
37401 arg3 = obj2;
37402 {
37403 PyThreadState* __tstate = wxPyBeginAllowThreads();
37404 wxItemContainer_SetClientData(arg1,arg2,arg3);
37405
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 Py_INCREF(Py_None); resultobj = Py_None;
37410 return resultobj;
37411 fail:
37412 return NULL;
37413 }
37414
37415
37416 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37417 PyObject *resultobj;
37418 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37419 int result;
37420 PyObject * obj0 = 0 ;
37421 char *kwnames[] = {
37422 (char *) "self", NULL
37423 };
37424
37425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37427 if (SWIG_arg_fail(1)) SWIG_fail;
37428 {
37429 PyThreadState* __tstate = wxPyBeginAllowThreads();
37430 result = (int)((wxItemContainer const *)arg1)->GetCount();
37431
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 {
37436 resultobj = SWIG_From_int((int)(result));
37437 }
37438 return resultobj;
37439 fail:
37440 return NULL;
37441 }
37442
37443
37444 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37445 PyObject *resultobj;
37446 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37447 bool result;
37448 PyObject * obj0 = 0 ;
37449 char *kwnames[] = {
37450 (char *) "self", NULL
37451 };
37452
37453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37455 if (SWIG_arg_fail(1)) SWIG_fail;
37456 {
37457 PyThreadState* __tstate = wxPyBeginAllowThreads();
37458 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37459
37460 wxPyEndAllowThreads(__tstate);
37461 if (PyErr_Occurred()) SWIG_fail;
37462 }
37463 {
37464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37465 }
37466 return resultobj;
37467 fail:
37468 return NULL;
37469 }
37470
37471
37472 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37473 PyObject *resultobj;
37474 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37475 int arg2 ;
37476 wxString result;
37477 PyObject * obj0 = 0 ;
37478 PyObject * obj1 = 0 ;
37479 char *kwnames[] = {
37480 (char *) "self",(char *) "n", NULL
37481 };
37482
37483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37485 if (SWIG_arg_fail(1)) SWIG_fail;
37486 {
37487 arg2 = (int)(SWIG_As_int(obj1));
37488 if (SWIG_arg_fail(2)) SWIG_fail;
37489 }
37490 {
37491 PyThreadState* __tstate = wxPyBeginAllowThreads();
37492 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37493
37494 wxPyEndAllowThreads(__tstate);
37495 if (PyErr_Occurred()) SWIG_fail;
37496 }
37497 {
37498 #if wxUSE_UNICODE
37499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37500 #else
37501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37502 #endif
37503 }
37504 return resultobj;
37505 fail:
37506 return NULL;
37507 }
37508
37509
37510 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37511 PyObject *resultobj;
37512 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37513 wxArrayString result;
37514 PyObject * obj0 = 0 ;
37515 char *kwnames[] = {
37516 (char *) "self", NULL
37517 };
37518
37519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37521 if (SWIG_arg_fail(1)) SWIG_fail;
37522 {
37523 PyThreadState* __tstate = wxPyBeginAllowThreads();
37524 result = ((wxItemContainer const *)arg1)->GetStrings();
37525
37526 wxPyEndAllowThreads(__tstate);
37527 if (PyErr_Occurred()) SWIG_fail;
37528 }
37529 {
37530 resultobj = wxArrayString2PyList_helper(result);
37531 }
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37539 PyObject *resultobj;
37540 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37541 int arg2 ;
37542 wxString *arg3 = 0 ;
37543 bool temp3 = false ;
37544 PyObject * obj0 = 0 ;
37545 PyObject * obj1 = 0 ;
37546 PyObject * obj2 = 0 ;
37547 char *kwnames[] = {
37548 (char *) "self",(char *) "n",(char *) "s", NULL
37549 };
37550
37551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37553 if (SWIG_arg_fail(1)) SWIG_fail;
37554 {
37555 arg2 = (int)(SWIG_As_int(obj1));
37556 if (SWIG_arg_fail(2)) SWIG_fail;
37557 }
37558 {
37559 arg3 = wxString_in_helper(obj2);
37560 if (arg3 == NULL) SWIG_fail;
37561 temp3 = true;
37562 }
37563 {
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 (arg1)->SetString(arg2,(wxString const &)*arg3);
37566
37567 wxPyEndAllowThreads(__tstate);
37568 if (PyErr_Occurred()) SWIG_fail;
37569 }
37570 Py_INCREF(Py_None); resultobj = Py_None;
37571 {
37572 if (temp3)
37573 delete arg3;
37574 }
37575 return resultobj;
37576 fail:
37577 {
37578 if (temp3)
37579 delete arg3;
37580 }
37581 return NULL;
37582 }
37583
37584
37585 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37586 PyObject *resultobj;
37587 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37588 wxString *arg2 = 0 ;
37589 int result;
37590 bool temp2 = false ;
37591 PyObject * obj0 = 0 ;
37592 PyObject * obj1 = 0 ;
37593 char *kwnames[] = {
37594 (char *) "self",(char *) "s", NULL
37595 };
37596
37597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37599 if (SWIG_arg_fail(1)) SWIG_fail;
37600 {
37601 arg2 = wxString_in_helper(obj1);
37602 if (arg2 == NULL) SWIG_fail;
37603 temp2 = true;
37604 }
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37608
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 {
37613 resultobj = SWIG_From_int((int)(result));
37614 }
37615 {
37616 if (temp2)
37617 delete arg2;
37618 }
37619 return resultobj;
37620 fail:
37621 {
37622 if (temp2)
37623 delete arg2;
37624 }
37625 return NULL;
37626 }
37627
37628
37629 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37630 PyObject *resultobj;
37631 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37632 int arg2 ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "n", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) 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 = (int)(SWIG_As_int(obj1));
37644 if (SWIG_arg_fail(2)) SWIG_fail;
37645 }
37646 {
37647 PyThreadState* __tstate = wxPyBeginAllowThreads();
37648 (arg1)->SetSelection(arg2);
37649
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 Py_INCREF(Py_None); resultobj = Py_None;
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj;
37662 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37663 int result;
37664 PyObject * obj0 = 0 ;
37665 char *kwnames[] = {
37666 (char *) "self", NULL
37667 };
37668
37669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37671 if (SWIG_arg_fail(1)) SWIG_fail;
37672 {
37673 PyThreadState* __tstate = wxPyBeginAllowThreads();
37674 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37675
37676 wxPyEndAllowThreads(__tstate);
37677 if (PyErr_Occurred()) SWIG_fail;
37678 }
37679 {
37680 resultobj = SWIG_From_int((int)(result));
37681 }
37682 return resultobj;
37683 fail:
37684 return NULL;
37685 }
37686
37687
37688 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37689 PyObject *resultobj;
37690 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37691 wxString *arg2 = 0 ;
37692 bool result;
37693 bool temp2 = false ;
37694 PyObject * obj0 = 0 ;
37695 PyObject * obj1 = 0 ;
37696 char *kwnames[] = {
37697 (char *) "self",(char *) "s", NULL
37698 };
37699
37700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37702 if (SWIG_arg_fail(1)) SWIG_fail;
37703 {
37704 arg2 = wxString_in_helper(obj1);
37705 if (arg2 == NULL) SWIG_fail;
37706 temp2 = true;
37707 }
37708 {
37709 PyThreadState* __tstate = wxPyBeginAllowThreads();
37710 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37711
37712 wxPyEndAllowThreads(__tstate);
37713 if (PyErr_Occurred()) SWIG_fail;
37714 }
37715 {
37716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37717 }
37718 {
37719 if (temp2)
37720 delete arg2;
37721 }
37722 return resultobj;
37723 fail:
37724 {
37725 if (temp2)
37726 delete arg2;
37727 }
37728 return NULL;
37729 }
37730
37731
37732 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37733 PyObject *resultobj;
37734 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37735 wxString result;
37736 PyObject * obj0 = 0 ;
37737 char *kwnames[] = {
37738 (char *) "self", NULL
37739 };
37740
37741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37743 if (SWIG_arg_fail(1)) SWIG_fail;
37744 {
37745 PyThreadState* __tstate = wxPyBeginAllowThreads();
37746 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37747
37748 wxPyEndAllowThreads(__tstate);
37749 if (PyErr_Occurred()) SWIG_fail;
37750 }
37751 {
37752 #if wxUSE_UNICODE
37753 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37754 #else
37755 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37756 #endif
37757 }
37758 return resultobj;
37759 fail:
37760 return NULL;
37761 }
37762
37763
37764 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37765 PyObject *resultobj;
37766 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37767 int arg2 ;
37768 PyObject * obj0 = 0 ;
37769 PyObject * obj1 = 0 ;
37770 char *kwnames[] = {
37771 (char *) "self",(char *) "n", NULL
37772 };
37773
37774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37776 if (SWIG_arg_fail(1)) SWIG_fail;
37777 {
37778 arg2 = (int)(SWIG_As_int(obj1));
37779 if (SWIG_arg_fail(2)) SWIG_fail;
37780 }
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 (arg1)->Select(arg2);
37784
37785 wxPyEndAllowThreads(__tstate);
37786 if (PyErr_Occurred()) SWIG_fail;
37787 }
37788 Py_INCREF(Py_None); resultobj = Py_None;
37789 return resultobj;
37790 fail:
37791 return NULL;
37792 }
37793
37794
37795 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37796 PyObject *obj;
37797 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37798 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37799 Py_INCREF(obj);
37800 return Py_BuildValue((char *)"");
37801 }
37802 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37803 PyObject *obj;
37804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37805 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37806 Py_INCREF(obj);
37807 return Py_BuildValue((char *)"");
37808 }
37809 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37810 PyObject *resultobj;
37811 wxSizerItem *result;
37812 char *kwnames[] = {
37813 NULL
37814 };
37815
37816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37817 {
37818 PyThreadState* __tstate = wxPyBeginAllowThreads();
37819 result = (wxSizerItem *)new wxSizerItem();
37820
37821 wxPyEndAllowThreads(__tstate);
37822 if (PyErr_Occurred()) SWIG_fail;
37823 }
37824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37825 return resultobj;
37826 fail:
37827 return NULL;
37828 }
37829
37830
37831 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37832 PyObject *resultobj;
37833 wxWindow *arg1 = (wxWindow *) 0 ;
37834 int arg2 ;
37835 int arg3 ;
37836 int arg4 ;
37837 PyObject *arg5 = (PyObject *) NULL ;
37838 wxSizerItem *result;
37839 PyObject * obj0 = 0 ;
37840 PyObject * obj1 = 0 ;
37841 PyObject * obj2 = 0 ;
37842 PyObject * obj3 = 0 ;
37843 PyObject * obj4 = 0 ;
37844 char *kwnames[] = {
37845 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37846 };
37847
37848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37850 if (SWIG_arg_fail(1)) SWIG_fail;
37851 {
37852 arg2 = (int)(SWIG_As_int(obj1));
37853 if (SWIG_arg_fail(2)) SWIG_fail;
37854 }
37855 {
37856 arg3 = (int)(SWIG_As_int(obj2));
37857 if (SWIG_arg_fail(3)) SWIG_fail;
37858 }
37859 {
37860 arg4 = (int)(SWIG_As_int(obj3));
37861 if (SWIG_arg_fail(4)) SWIG_fail;
37862 }
37863 if (obj4) {
37864 arg5 = obj4;
37865 }
37866 {
37867 PyThreadState* __tstate = wxPyBeginAllowThreads();
37868 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37869
37870 wxPyEndAllowThreads(__tstate);
37871 if (PyErr_Occurred()) SWIG_fail;
37872 }
37873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37874 return resultobj;
37875 fail:
37876 return NULL;
37877 }
37878
37879
37880 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37881 PyObject *resultobj;
37882 int arg1 ;
37883 int arg2 ;
37884 int arg3 ;
37885 int arg4 ;
37886 int arg5 ;
37887 PyObject *arg6 = (PyObject *) NULL ;
37888 wxSizerItem *result;
37889 PyObject * obj0 = 0 ;
37890 PyObject * obj1 = 0 ;
37891 PyObject * obj2 = 0 ;
37892 PyObject * obj3 = 0 ;
37893 PyObject * obj4 = 0 ;
37894 PyObject * obj5 = 0 ;
37895 char *kwnames[] = {
37896 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37897 };
37898
37899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37900 {
37901 arg1 = (int)(SWIG_As_int(obj0));
37902 if (SWIG_arg_fail(1)) SWIG_fail;
37903 }
37904 {
37905 arg2 = (int)(SWIG_As_int(obj1));
37906 if (SWIG_arg_fail(2)) SWIG_fail;
37907 }
37908 {
37909 arg3 = (int)(SWIG_As_int(obj2));
37910 if (SWIG_arg_fail(3)) SWIG_fail;
37911 }
37912 {
37913 arg4 = (int)(SWIG_As_int(obj3));
37914 if (SWIG_arg_fail(4)) SWIG_fail;
37915 }
37916 {
37917 arg5 = (int)(SWIG_As_int(obj4));
37918 if (SWIG_arg_fail(5)) SWIG_fail;
37919 }
37920 if (obj5) {
37921 arg6 = obj5;
37922 }
37923 {
37924 PyThreadState* __tstate = wxPyBeginAllowThreads();
37925 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37926
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj;
37939 wxSizer *arg1 = (wxSizer *) 0 ;
37940 int arg2 ;
37941 int arg3 ;
37942 int arg4 ;
37943 PyObject *arg5 = (PyObject *) NULL ;
37944 wxSizerItem *result;
37945 PyObject * obj0 = 0 ;
37946 PyObject * obj1 = 0 ;
37947 PyObject * obj2 = 0 ;
37948 PyObject * obj3 = 0 ;
37949 PyObject * obj4 = 0 ;
37950 char *kwnames[] = {
37951 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37952 };
37953
37954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37956 if (SWIG_arg_fail(1)) SWIG_fail;
37957 {
37958 arg2 = (int)(SWIG_As_int(obj1));
37959 if (SWIG_arg_fail(2)) SWIG_fail;
37960 }
37961 {
37962 arg3 = (int)(SWIG_As_int(obj2));
37963 if (SWIG_arg_fail(3)) SWIG_fail;
37964 }
37965 {
37966 arg4 = (int)(SWIG_As_int(obj3));
37967 if (SWIG_arg_fail(4)) SWIG_fail;
37968 }
37969 if (obj4) {
37970 arg5 = obj4;
37971 }
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37975
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37987 PyObject *resultobj;
37988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37989 PyObject * obj0 = 0 ;
37990 char *kwnames[] = {
37991 (char *) "self", NULL
37992 };
37993
37994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37996 if (SWIG_arg_fail(1)) SWIG_fail;
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 (arg1)->DeleteWindows();
38000
38001 wxPyEndAllowThreads(__tstate);
38002 if (PyErr_Occurred()) SWIG_fail;
38003 }
38004 Py_INCREF(Py_None); resultobj = Py_None;
38005 return resultobj;
38006 fail:
38007 return NULL;
38008 }
38009
38010
38011 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38012 PyObject *resultobj;
38013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38014 PyObject * obj0 = 0 ;
38015 char *kwnames[] = {
38016 (char *) "self", NULL
38017 };
38018
38019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38021 if (SWIG_arg_fail(1)) SWIG_fail;
38022 {
38023 PyThreadState* __tstate = wxPyBeginAllowThreads();
38024 (arg1)->DetachSizer();
38025
38026 wxPyEndAllowThreads(__tstate);
38027 if (PyErr_Occurred()) SWIG_fail;
38028 }
38029 Py_INCREF(Py_None); resultobj = Py_None;
38030 return resultobj;
38031 fail:
38032 return NULL;
38033 }
38034
38035
38036 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj;
38038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38039 wxSize result;
38040 PyObject * obj0 = 0 ;
38041 char *kwnames[] = {
38042 (char *) "self", NULL
38043 };
38044
38045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38047 if (SWIG_arg_fail(1)) SWIG_fail;
38048 {
38049 PyThreadState* __tstate = wxPyBeginAllowThreads();
38050 result = (arg1)->GetSize();
38051
38052 wxPyEndAllowThreads(__tstate);
38053 if (PyErr_Occurred()) SWIG_fail;
38054 }
38055 {
38056 wxSize * resultptr;
38057 resultptr = new wxSize((wxSize &)(result));
38058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38059 }
38060 return resultobj;
38061 fail:
38062 return NULL;
38063 }
38064
38065
38066 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38067 PyObject *resultobj;
38068 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38069 wxSize result;
38070 PyObject * obj0 = 0 ;
38071 char *kwnames[] = {
38072 (char *) "self", NULL
38073 };
38074
38075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38077 if (SWIG_arg_fail(1)) SWIG_fail;
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = (arg1)->CalcMin();
38081
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 {
38086 wxSize * resultptr;
38087 resultptr = new wxSize((wxSize &)(result));
38088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38089 }
38090 return resultobj;
38091 fail:
38092 return NULL;
38093 }
38094
38095
38096 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38097 PyObject *resultobj;
38098 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38099 wxPoint arg2 ;
38100 wxSize arg3 ;
38101 PyObject * obj0 = 0 ;
38102 PyObject * obj1 = 0 ;
38103 PyObject * obj2 = 0 ;
38104 char *kwnames[] = {
38105 (char *) "self",(char *) "pos",(char *) "size", NULL
38106 };
38107
38108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38110 if (SWIG_arg_fail(1)) SWIG_fail;
38111 {
38112 wxPoint * argp;
38113 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38114 if (SWIG_arg_fail(2)) SWIG_fail;
38115 if (argp == NULL) {
38116 SWIG_null_ref("wxPoint");
38117 }
38118 if (SWIG_arg_fail(2)) SWIG_fail;
38119 arg2 = *argp;
38120 }
38121 {
38122 wxSize * argp;
38123 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38124 if (SWIG_arg_fail(3)) SWIG_fail;
38125 if (argp == NULL) {
38126 SWIG_null_ref("wxSize");
38127 }
38128 if (SWIG_arg_fail(3)) SWIG_fail;
38129 arg3 = *argp;
38130 }
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 (arg1)->SetDimension(arg2,arg3);
38134
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 Py_INCREF(Py_None); resultobj = Py_None;
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj;
38147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38148 wxSize result;
38149 PyObject * obj0 = 0 ;
38150 char *kwnames[] = {
38151 (char *) "self", NULL
38152 };
38153
38154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38156 if (SWIG_arg_fail(1)) SWIG_fail;
38157 {
38158 PyThreadState* __tstate = wxPyBeginAllowThreads();
38159 result = (arg1)->GetMinSize();
38160
38161 wxPyEndAllowThreads(__tstate);
38162 if (PyErr_Occurred()) SWIG_fail;
38163 }
38164 {
38165 wxSize * resultptr;
38166 resultptr = new wxSize((wxSize &)(result));
38167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38168 }
38169 return resultobj;
38170 fail:
38171 return NULL;
38172 }
38173
38174
38175 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38176 PyObject *resultobj;
38177 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38178 wxSize result;
38179 PyObject * obj0 = 0 ;
38180 char *kwnames[] = {
38181 (char *) "self", NULL
38182 };
38183
38184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38186 if (SWIG_arg_fail(1)) SWIG_fail;
38187 {
38188 PyThreadState* __tstate = wxPyBeginAllowThreads();
38189 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38190
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 {
38195 wxSize * resultptr;
38196 resultptr = new wxSize((wxSize &)(result));
38197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38198 }
38199 return resultobj;
38200 fail:
38201 return NULL;
38202 }
38203
38204
38205 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38206 PyObject *resultobj;
38207 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38208 int arg2 ;
38209 int arg3 ;
38210 PyObject * obj0 = 0 ;
38211 PyObject * obj1 = 0 ;
38212 PyObject * obj2 = 0 ;
38213 char *kwnames[] = {
38214 (char *) "self",(char *) "x",(char *) "y", NULL
38215 };
38216
38217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38219 if (SWIG_arg_fail(1)) SWIG_fail;
38220 {
38221 arg2 = (int)(SWIG_As_int(obj1));
38222 if (SWIG_arg_fail(2)) SWIG_fail;
38223 }
38224 {
38225 arg3 = (int)(SWIG_As_int(obj2));
38226 if (SWIG_arg_fail(3)) SWIG_fail;
38227 }
38228 {
38229 PyThreadState* __tstate = wxPyBeginAllowThreads();
38230 (arg1)->SetInitSize(arg2,arg3);
38231
38232 wxPyEndAllowThreads(__tstate);
38233 if (PyErr_Occurred()) SWIG_fail;
38234 }
38235 Py_INCREF(Py_None); resultobj = Py_None;
38236 return resultobj;
38237 fail:
38238 return NULL;
38239 }
38240
38241
38242 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38243 PyObject *resultobj;
38244 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38245 int arg2 ;
38246 int arg3 ;
38247 PyObject * obj0 = 0 ;
38248 PyObject * obj1 = 0 ;
38249 PyObject * obj2 = 0 ;
38250 char *kwnames[] = {
38251 (char *) "self",(char *) "width",(char *) "height", NULL
38252 };
38253
38254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38256 if (SWIG_arg_fail(1)) SWIG_fail;
38257 {
38258 arg2 = (int)(SWIG_As_int(obj1));
38259 if (SWIG_arg_fail(2)) SWIG_fail;
38260 }
38261 {
38262 arg3 = (int)(SWIG_As_int(obj2));
38263 if (SWIG_arg_fail(3)) SWIG_fail;
38264 }
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 (arg1)->SetRatio(arg2,arg3);
38268
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 Py_INCREF(Py_None); resultobj = Py_None;
38273 return resultobj;
38274 fail:
38275 return NULL;
38276 }
38277
38278
38279 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38280 PyObject *resultobj;
38281 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38282 wxSize arg2 ;
38283 PyObject * obj0 = 0 ;
38284 PyObject * obj1 = 0 ;
38285 char *kwnames[] = {
38286 (char *) "self",(char *) "size", NULL
38287 };
38288
38289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38291 if (SWIG_arg_fail(1)) SWIG_fail;
38292 {
38293 wxSize * argp;
38294 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38295 if (SWIG_arg_fail(2)) SWIG_fail;
38296 if (argp == NULL) {
38297 SWIG_null_ref("wxSize");
38298 }
38299 if (SWIG_arg_fail(2)) SWIG_fail;
38300 arg2 = *argp;
38301 }
38302 {
38303 PyThreadState* __tstate = wxPyBeginAllowThreads();
38304 (arg1)->SetRatio(arg2);
38305
38306 wxPyEndAllowThreads(__tstate);
38307 if (PyErr_Occurred()) SWIG_fail;
38308 }
38309 Py_INCREF(Py_None); resultobj = Py_None;
38310 return resultobj;
38311 fail:
38312 return NULL;
38313 }
38314
38315
38316 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38317 PyObject *resultobj;
38318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38319 float arg2 ;
38320 PyObject * obj0 = 0 ;
38321 PyObject * obj1 = 0 ;
38322 char *kwnames[] = {
38323 (char *) "self",(char *) "ratio", NULL
38324 };
38325
38326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38328 if (SWIG_arg_fail(1)) SWIG_fail;
38329 {
38330 arg2 = (float)(SWIG_As_float(obj1));
38331 if (SWIG_arg_fail(2)) SWIG_fail;
38332 }
38333 {
38334 PyThreadState* __tstate = wxPyBeginAllowThreads();
38335 (arg1)->SetRatio(arg2);
38336
38337 wxPyEndAllowThreads(__tstate);
38338 if (PyErr_Occurred()) SWIG_fail;
38339 }
38340 Py_INCREF(Py_None); resultobj = Py_None;
38341 return resultobj;
38342 fail:
38343 return NULL;
38344 }
38345
38346
38347 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38348 PyObject *resultobj;
38349 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38350 float result;
38351 PyObject * obj0 = 0 ;
38352 char *kwnames[] = {
38353 (char *) "self", NULL
38354 };
38355
38356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38358 if (SWIG_arg_fail(1)) SWIG_fail;
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = (float)(arg1)->GetRatio();
38362
38363 wxPyEndAllowThreads(__tstate);
38364 if (PyErr_Occurred()) SWIG_fail;
38365 }
38366 {
38367 resultobj = SWIG_From_float((float)(result));
38368 }
38369 return resultobj;
38370 fail:
38371 return NULL;
38372 }
38373
38374
38375 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38376 PyObject *resultobj;
38377 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38378 wxRect result;
38379 PyObject * obj0 = 0 ;
38380 char *kwnames[] = {
38381 (char *) "self", NULL
38382 };
38383
38384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38386 if (SWIG_arg_fail(1)) SWIG_fail;
38387 {
38388 PyThreadState* __tstate = wxPyBeginAllowThreads();
38389 result = (arg1)->GetRect();
38390
38391 wxPyEndAllowThreads(__tstate);
38392 if (PyErr_Occurred()) SWIG_fail;
38393 }
38394 {
38395 wxRect * resultptr;
38396 resultptr = new wxRect((wxRect &)(result));
38397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38398 }
38399 return resultobj;
38400 fail:
38401 return NULL;
38402 }
38403
38404
38405 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38406 PyObject *resultobj;
38407 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38408 bool result;
38409 PyObject * obj0 = 0 ;
38410 char *kwnames[] = {
38411 (char *) "self", NULL
38412 };
38413
38414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38416 if (SWIG_arg_fail(1)) SWIG_fail;
38417 {
38418 PyThreadState* __tstate = wxPyBeginAllowThreads();
38419 result = (bool)(arg1)->IsWindow();
38420
38421 wxPyEndAllowThreads(__tstate);
38422 if (PyErr_Occurred()) SWIG_fail;
38423 }
38424 {
38425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38426 }
38427 return resultobj;
38428 fail:
38429 return NULL;
38430 }
38431
38432
38433 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38434 PyObject *resultobj;
38435 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38436 bool result;
38437 PyObject * obj0 = 0 ;
38438 char *kwnames[] = {
38439 (char *) "self", NULL
38440 };
38441
38442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38444 if (SWIG_arg_fail(1)) SWIG_fail;
38445 {
38446 PyThreadState* __tstate = wxPyBeginAllowThreads();
38447 result = (bool)(arg1)->IsSizer();
38448
38449 wxPyEndAllowThreads(__tstate);
38450 if (PyErr_Occurred()) SWIG_fail;
38451 }
38452 {
38453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38454 }
38455 return resultobj;
38456 fail:
38457 return NULL;
38458 }
38459
38460
38461 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38462 PyObject *resultobj;
38463 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38464 bool result;
38465 PyObject * obj0 = 0 ;
38466 char *kwnames[] = {
38467 (char *) "self", NULL
38468 };
38469
38470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38472 if (SWIG_arg_fail(1)) SWIG_fail;
38473 {
38474 PyThreadState* __tstate = wxPyBeginAllowThreads();
38475 result = (bool)(arg1)->IsSpacer();
38476
38477 wxPyEndAllowThreads(__tstate);
38478 if (PyErr_Occurred()) SWIG_fail;
38479 }
38480 {
38481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38482 }
38483 return resultobj;
38484 fail:
38485 return NULL;
38486 }
38487
38488
38489 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38490 PyObject *resultobj;
38491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38492 int arg2 ;
38493 PyObject * obj0 = 0 ;
38494 PyObject * obj1 = 0 ;
38495 char *kwnames[] = {
38496 (char *) "self",(char *) "proportion", NULL
38497 };
38498
38499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38501 if (SWIG_arg_fail(1)) SWIG_fail;
38502 {
38503 arg2 = (int)(SWIG_As_int(obj1));
38504 if (SWIG_arg_fail(2)) SWIG_fail;
38505 }
38506 {
38507 PyThreadState* __tstate = wxPyBeginAllowThreads();
38508 (arg1)->SetProportion(arg2);
38509
38510 wxPyEndAllowThreads(__tstate);
38511 if (PyErr_Occurred()) SWIG_fail;
38512 }
38513 Py_INCREF(Py_None); resultobj = Py_None;
38514 return resultobj;
38515 fail:
38516 return NULL;
38517 }
38518
38519
38520 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38521 PyObject *resultobj;
38522 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38523 int result;
38524 PyObject * obj0 = 0 ;
38525 char *kwnames[] = {
38526 (char *) "self", NULL
38527 };
38528
38529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38531 if (SWIG_arg_fail(1)) SWIG_fail;
38532 {
38533 PyThreadState* __tstate = wxPyBeginAllowThreads();
38534 result = (int)(arg1)->GetProportion();
38535
38536 wxPyEndAllowThreads(__tstate);
38537 if (PyErr_Occurred()) SWIG_fail;
38538 }
38539 {
38540 resultobj = SWIG_From_int((int)(result));
38541 }
38542 return resultobj;
38543 fail:
38544 return NULL;
38545 }
38546
38547
38548 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38549 PyObject *resultobj;
38550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38551 int arg2 ;
38552 PyObject * obj0 = 0 ;
38553 PyObject * obj1 = 0 ;
38554 char *kwnames[] = {
38555 (char *) "self",(char *) "flag", NULL
38556 };
38557
38558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38560 if (SWIG_arg_fail(1)) SWIG_fail;
38561 {
38562 arg2 = (int)(SWIG_As_int(obj1));
38563 if (SWIG_arg_fail(2)) SWIG_fail;
38564 }
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->SetFlag(arg2);
38568
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 Py_INCREF(Py_None); resultobj = Py_None;
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj;
38581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38582 int result;
38583 PyObject * obj0 = 0 ;
38584 char *kwnames[] = {
38585 (char *) "self", NULL
38586 };
38587
38588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38590 if (SWIG_arg_fail(1)) SWIG_fail;
38591 {
38592 PyThreadState* __tstate = wxPyBeginAllowThreads();
38593 result = (int)(arg1)->GetFlag();
38594
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 {
38599 resultobj = SWIG_From_int((int)(result));
38600 }
38601 return resultobj;
38602 fail:
38603 return NULL;
38604 }
38605
38606
38607 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38608 PyObject *resultobj;
38609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38610 int arg2 ;
38611 PyObject * obj0 = 0 ;
38612 PyObject * obj1 = 0 ;
38613 char *kwnames[] = {
38614 (char *) "self",(char *) "border", NULL
38615 };
38616
38617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38619 if (SWIG_arg_fail(1)) SWIG_fail;
38620 {
38621 arg2 = (int)(SWIG_As_int(obj1));
38622 if (SWIG_arg_fail(2)) SWIG_fail;
38623 }
38624 {
38625 PyThreadState* __tstate = wxPyBeginAllowThreads();
38626 (arg1)->SetBorder(arg2);
38627
38628 wxPyEndAllowThreads(__tstate);
38629 if (PyErr_Occurred()) SWIG_fail;
38630 }
38631 Py_INCREF(Py_None); resultobj = Py_None;
38632 return resultobj;
38633 fail:
38634 return NULL;
38635 }
38636
38637
38638 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38639 PyObject *resultobj;
38640 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38641 int result;
38642 PyObject * obj0 = 0 ;
38643 char *kwnames[] = {
38644 (char *) "self", NULL
38645 };
38646
38647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38649 if (SWIG_arg_fail(1)) SWIG_fail;
38650 {
38651 PyThreadState* __tstate = wxPyBeginAllowThreads();
38652 result = (int)(arg1)->GetBorder();
38653
38654 wxPyEndAllowThreads(__tstate);
38655 if (PyErr_Occurred()) SWIG_fail;
38656 }
38657 {
38658 resultobj = SWIG_From_int((int)(result));
38659 }
38660 return resultobj;
38661 fail:
38662 return NULL;
38663 }
38664
38665
38666 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38667 PyObject *resultobj;
38668 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38669 wxWindow *result;
38670 PyObject * obj0 = 0 ;
38671 char *kwnames[] = {
38672 (char *) "self", NULL
38673 };
38674
38675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38677 if (SWIG_arg_fail(1)) SWIG_fail;
38678 {
38679 PyThreadState* __tstate = wxPyBeginAllowThreads();
38680 result = (wxWindow *)(arg1)->GetWindow();
38681
38682 wxPyEndAllowThreads(__tstate);
38683 if (PyErr_Occurred()) SWIG_fail;
38684 }
38685 {
38686 resultobj = wxPyMake_wxObject(result, 0);
38687 }
38688 return resultobj;
38689 fail:
38690 return NULL;
38691 }
38692
38693
38694 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38695 PyObject *resultobj;
38696 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38697 wxWindow *arg2 = (wxWindow *) 0 ;
38698 PyObject * obj0 = 0 ;
38699 PyObject * obj1 = 0 ;
38700 char *kwnames[] = {
38701 (char *) "self",(char *) "window", NULL
38702 };
38703
38704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38706 if (SWIG_arg_fail(1)) SWIG_fail;
38707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38708 if (SWIG_arg_fail(2)) SWIG_fail;
38709 {
38710 PyThreadState* __tstate = wxPyBeginAllowThreads();
38711 (arg1)->SetWindow(arg2);
38712
38713 wxPyEndAllowThreads(__tstate);
38714 if (PyErr_Occurred()) SWIG_fail;
38715 }
38716 Py_INCREF(Py_None); resultobj = Py_None;
38717 return resultobj;
38718 fail:
38719 return NULL;
38720 }
38721
38722
38723 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38724 PyObject *resultobj;
38725 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38726 wxSizer *result;
38727 PyObject * obj0 = 0 ;
38728 char *kwnames[] = {
38729 (char *) "self", NULL
38730 };
38731
38732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38734 if (SWIG_arg_fail(1)) SWIG_fail;
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 result = (wxSizer *)(arg1)->GetSizer();
38738
38739 wxPyEndAllowThreads(__tstate);
38740 if (PyErr_Occurred()) SWIG_fail;
38741 }
38742 {
38743 resultobj = wxPyMake_wxSizer(result, 0);
38744 }
38745 return resultobj;
38746 fail:
38747 return NULL;
38748 }
38749
38750
38751 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38752 PyObject *resultobj;
38753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38754 wxSizer *arg2 = (wxSizer *) 0 ;
38755 PyObject * obj0 = 0 ;
38756 PyObject * obj1 = 0 ;
38757 char *kwnames[] = {
38758 (char *) "self",(char *) "sizer", NULL
38759 };
38760
38761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38763 if (SWIG_arg_fail(1)) SWIG_fail;
38764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38765 if (SWIG_arg_fail(2)) SWIG_fail;
38766 {
38767 PyThreadState* __tstate = wxPyBeginAllowThreads();
38768 (arg1)->SetSizer(arg2);
38769
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 Py_INCREF(Py_None); resultobj = Py_None;
38774 return resultobj;
38775 fail:
38776 return NULL;
38777 }
38778
38779
38780 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38781 PyObject *resultobj;
38782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38783 wxSize *result;
38784 PyObject * obj0 = 0 ;
38785 char *kwnames[] = {
38786 (char *) "self", NULL
38787 };
38788
38789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38791 if (SWIG_arg_fail(1)) SWIG_fail;
38792 {
38793 PyThreadState* __tstate = wxPyBeginAllowThreads();
38794 {
38795 wxSize const &_result_ref = (arg1)->GetSpacer();
38796 result = (wxSize *) &_result_ref;
38797 }
38798
38799 wxPyEndAllowThreads(__tstate);
38800 if (PyErr_Occurred()) SWIG_fail;
38801 }
38802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38803 return resultobj;
38804 fail:
38805 return NULL;
38806 }
38807
38808
38809 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38810 PyObject *resultobj;
38811 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38812 wxSize *arg2 = 0 ;
38813 wxSize temp2 ;
38814 PyObject * obj0 = 0 ;
38815 PyObject * obj1 = 0 ;
38816 char *kwnames[] = {
38817 (char *) "self",(char *) "size", NULL
38818 };
38819
38820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38822 if (SWIG_arg_fail(1)) SWIG_fail;
38823 {
38824 arg2 = &temp2;
38825 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38826 }
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 (arg1)->SetSpacer((wxSize const &)*arg2);
38830
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 Py_INCREF(Py_None); resultobj = Py_None;
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38842 PyObject *resultobj;
38843 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38844 bool arg2 ;
38845 PyObject * obj0 = 0 ;
38846 PyObject * obj1 = 0 ;
38847 char *kwnames[] = {
38848 (char *) "self",(char *) "show", NULL
38849 };
38850
38851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38853 if (SWIG_arg_fail(1)) SWIG_fail;
38854 {
38855 arg2 = (bool)(SWIG_As_bool(obj1));
38856 if (SWIG_arg_fail(2)) SWIG_fail;
38857 }
38858 {
38859 PyThreadState* __tstate = wxPyBeginAllowThreads();
38860 (arg1)->Show(arg2);
38861
38862 wxPyEndAllowThreads(__tstate);
38863 if (PyErr_Occurred()) SWIG_fail;
38864 }
38865 Py_INCREF(Py_None); resultobj = Py_None;
38866 return resultobj;
38867 fail:
38868 return NULL;
38869 }
38870
38871
38872 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38873 PyObject *resultobj;
38874 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38875 bool result;
38876 PyObject * obj0 = 0 ;
38877 char *kwnames[] = {
38878 (char *) "self", NULL
38879 };
38880
38881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38883 if (SWIG_arg_fail(1)) SWIG_fail;
38884 {
38885 PyThreadState* __tstate = wxPyBeginAllowThreads();
38886 result = (bool)(arg1)->IsShown();
38887
38888 wxPyEndAllowThreads(__tstate);
38889 if (PyErr_Occurred()) SWIG_fail;
38890 }
38891 {
38892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38893 }
38894 return resultobj;
38895 fail:
38896 return NULL;
38897 }
38898
38899
38900 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38901 PyObject *resultobj;
38902 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38903 wxPoint result;
38904 PyObject * obj0 = 0 ;
38905 char *kwnames[] = {
38906 (char *) "self", NULL
38907 };
38908
38909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38911 if (SWIG_arg_fail(1)) SWIG_fail;
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 result = (arg1)->GetPosition();
38915
38916 wxPyEndAllowThreads(__tstate);
38917 if (PyErr_Occurred()) SWIG_fail;
38918 }
38919 {
38920 wxPoint * resultptr;
38921 resultptr = new wxPoint((wxPoint &)(result));
38922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38923 }
38924 return resultobj;
38925 fail:
38926 return NULL;
38927 }
38928
38929
38930 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38931 PyObject *resultobj;
38932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38933 PyObject *result;
38934 PyObject * obj0 = 0 ;
38935 char *kwnames[] = {
38936 (char *) "self", NULL
38937 };
38938
38939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38941 if (SWIG_arg_fail(1)) SWIG_fail;
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38945
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 resultobj = result;
38950 return resultobj;
38951 fail:
38952 return NULL;
38953 }
38954
38955
38956 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38957 PyObject *obj;
38958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38959 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38960 Py_INCREF(obj);
38961 return Py_BuildValue((char *)"");
38962 }
38963 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38964 PyObject *resultobj;
38965 wxSizer *arg1 = (wxSizer *) 0 ;
38966 PyObject *arg2 = (PyObject *) 0 ;
38967 PyObject * obj0 = 0 ;
38968 PyObject * obj1 = 0 ;
38969 char *kwnames[] = {
38970 (char *) "self",(char *) "_self", NULL
38971 };
38972
38973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38975 if (SWIG_arg_fail(1)) SWIG_fail;
38976 arg2 = obj1;
38977 {
38978 PyThreadState* __tstate = wxPyBeginAllowThreads();
38979 wxSizer__setOORInfo(arg1,arg2);
38980
38981 wxPyEndAllowThreads(__tstate);
38982 if (PyErr_Occurred()) SWIG_fail;
38983 }
38984 Py_INCREF(Py_None); resultobj = Py_None;
38985 return resultobj;
38986 fail:
38987 return NULL;
38988 }
38989
38990
38991 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38992 PyObject *resultobj;
38993 wxSizer *arg1 = (wxSizer *) 0 ;
38994 PyObject *arg2 = (PyObject *) 0 ;
38995 int arg3 = (int) 0 ;
38996 int arg4 = (int) 0 ;
38997 int arg5 = (int) 0 ;
38998 PyObject *arg6 = (PyObject *) NULL ;
38999 wxSizerItem *result;
39000 PyObject * obj0 = 0 ;
39001 PyObject * obj1 = 0 ;
39002 PyObject * obj2 = 0 ;
39003 PyObject * obj3 = 0 ;
39004 PyObject * obj4 = 0 ;
39005 PyObject * obj5 = 0 ;
39006 char *kwnames[] = {
39007 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39008 };
39009
39010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39012 if (SWIG_arg_fail(1)) SWIG_fail;
39013 arg2 = obj1;
39014 if (obj2) {
39015 {
39016 arg3 = (int)(SWIG_As_int(obj2));
39017 if (SWIG_arg_fail(3)) SWIG_fail;
39018 }
39019 }
39020 if (obj3) {
39021 {
39022 arg4 = (int)(SWIG_As_int(obj3));
39023 if (SWIG_arg_fail(4)) SWIG_fail;
39024 }
39025 }
39026 if (obj4) {
39027 {
39028 arg5 = (int)(SWIG_As_int(obj4));
39029 if (SWIG_arg_fail(5)) SWIG_fail;
39030 }
39031 }
39032 if (obj5) {
39033 arg6 = obj5;
39034 }
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39038
39039 wxPyEndAllowThreads(__tstate);
39040 if (PyErr_Occurred()) SWIG_fail;
39041 }
39042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39043 return resultobj;
39044 fail:
39045 return NULL;
39046 }
39047
39048
39049 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39050 PyObject *resultobj;
39051 wxSizer *arg1 = (wxSizer *) 0 ;
39052 int arg2 ;
39053 PyObject *arg3 = (PyObject *) 0 ;
39054 int arg4 = (int) 0 ;
39055 int arg5 = (int) 0 ;
39056 int arg6 = (int) 0 ;
39057 PyObject *arg7 = (PyObject *) NULL ;
39058 wxSizerItem *result;
39059 PyObject * obj0 = 0 ;
39060 PyObject * obj1 = 0 ;
39061 PyObject * obj2 = 0 ;
39062 PyObject * obj3 = 0 ;
39063 PyObject * obj4 = 0 ;
39064 PyObject * obj5 = 0 ;
39065 PyObject * obj6 = 0 ;
39066 char *kwnames[] = {
39067 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39068 };
39069
39070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39072 if (SWIG_arg_fail(1)) SWIG_fail;
39073 {
39074 arg2 = (int)(SWIG_As_int(obj1));
39075 if (SWIG_arg_fail(2)) SWIG_fail;
39076 }
39077 arg3 = obj2;
39078 if (obj3) {
39079 {
39080 arg4 = (int)(SWIG_As_int(obj3));
39081 if (SWIG_arg_fail(4)) SWIG_fail;
39082 }
39083 }
39084 if (obj4) {
39085 {
39086 arg5 = (int)(SWIG_As_int(obj4));
39087 if (SWIG_arg_fail(5)) SWIG_fail;
39088 }
39089 }
39090 if (obj5) {
39091 {
39092 arg6 = (int)(SWIG_As_int(obj5));
39093 if (SWIG_arg_fail(6)) SWIG_fail;
39094 }
39095 }
39096 if (obj6) {
39097 arg7 = obj6;
39098 }
39099 {
39100 PyThreadState* __tstate = wxPyBeginAllowThreads();
39101 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39102
39103 wxPyEndAllowThreads(__tstate);
39104 if (PyErr_Occurred()) SWIG_fail;
39105 }
39106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39107 return resultobj;
39108 fail:
39109 return NULL;
39110 }
39111
39112
39113 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39114 PyObject *resultobj;
39115 wxSizer *arg1 = (wxSizer *) 0 ;
39116 PyObject *arg2 = (PyObject *) 0 ;
39117 int arg3 = (int) 0 ;
39118 int arg4 = (int) 0 ;
39119 int arg5 = (int) 0 ;
39120 PyObject *arg6 = (PyObject *) NULL ;
39121 wxSizerItem *result;
39122 PyObject * obj0 = 0 ;
39123 PyObject * obj1 = 0 ;
39124 PyObject * obj2 = 0 ;
39125 PyObject * obj3 = 0 ;
39126 PyObject * obj4 = 0 ;
39127 PyObject * obj5 = 0 ;
39128 char *kwnames[] = {
39129 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39130 };
39131
39132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39134 if (SWIG_arg_fail(1)) SWIG_fail;
39135 arg2 = obj1;
39136 if (obj2) {
39137 {
39138 arg3 = (int)(SWIG_As_int(obj2));
39139 if (SWIG_arg_fail(3)) SWIG_fail;
39140 }
39141 }
39142 if (obj3) {
39143 {
39144 arg4 = (int)(SWIG_As_int(obj3));
39145 if (SWIG_arg_fail(4)) SWIG_fail;
39146 }
39147 }
39148 if (obj4) {
39149 {
39150 arg5 = (int)(SWIG_As_int(obj4));
39151 if (SWIG_arg_fail(5)) SWIG_fail;
39152 }
39153 }
39154 if (obj5) {
39155 arg6 = obj5;
39156 }
39157 {
39158 PyThreadState* __tstate = wxPyBeginAllowThreads();
39159 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39160
39161 wxPyEndAllowThreads(__tstate);
39162 if (PyErr_Occurred()) SWIG_fail;
39163 }
39164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39165 return resultobj;
39166 fail:
39167 return NULL;
39168 }
39169
39170
39171 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39172 PyObject *resultobj;
39173 wxSizer *arg1 = (wxSizer *) 0 ;
39174 PyObject *arg2 = (PyObject *) 0 ;
39175 bool result;
39176 PyObject * obj0 = 0 ;
39177 PyObject * obj1 = 0 ;
39178 char *kwnames[] = {
39179 (char *) "self",(char *) "item", NULL
39180 };
39181
39182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39184 if (SWIG_arg_fail(1)) SWIG_fail;
39185 arg2 = obj1;
39186 {
39187 PyThreadState* __tstate = wxPyBeginAllowThreads();
39188 result = (bool)wxSizer_Remove(arg1,arg2);
39189
39190 wxPyEndAllowThreads(__tstate);
39191 if (PyErr_Occurred()) SWIG_fail;
39192 }
39193 {
39194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39195 }
39196 return resultobj;
39197 fail:
39198 return NULL;
39199 }
39200
39201
39202 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39203 PyObject *resultobj;
39204 wxSizer *arg1 = (wxSizer *) 0 ;
39205 PyObject *arg2 = (PyObject *) 0 ;
39206 bool result;
39207 PyObject * obj0 = 0 ;
39208 PyObject * obj1 = 0 ;
39209 char *kwnames[] = {
39210 (char *) "self",(char *) "item", NULL
39211 };
39212
39213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39215 if (SWIG_arg_fail(1)) SWIG_fail;
39216 arg2 = obj1;
39217 {
39218 PyThreadState* __tstate = wxPyBeginAllowThreads();
39219 result = (bool)wxSizer_Detach(arg1,arg2);
39220
39221 wxPyEndAllowThreads(__tstate);
39222 if (PyErr_Occurred()) SWIG_fail;
39223 }
39224 {
39225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39226 }
39227 return resultobj;
39228 fail:
39229 return NULL;
39230 }
39231
39232
39233 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39234 PyObject *resultobj;
39235 wxSizer *arg1 = (wxSizer *) 0 ;
39236 PyObject *arg2 = (PyObject *) 0 ;
39237 wxSizerItem *result;
39238 PyObject * obj0 = 0 ;
39239 PyObject * obj1 = 0 ;
39240 char *kwnames[] = {
39241 (char *) "self",(char *) "item", NULL
39242 };
39243
39244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39246 if (SWIG_arg_fail(1)) SWIG_fail;
39247 arg2 = obj1;
39248 {
39249 PyThreadState* __tstate = wxPyBeginAllowThreads();
39250 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39251
39252 wxPyEndAllowThreads(__tstate);
39253 if (PyErr_Occurred()) SWIG_fail;
39254 }
39255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39263 PyObject *resultobj;
39264 wxSizer *arg1 = (wxSizer *) 0 ;
39265 PyObject *arg2 = (PyObject *) 0 ;
39266 wxSize *arg3 = 0 ;
39267 wxSize temp3 ;
39268 PyObject * obj0 = 0 ;
39269 PyObject * obj1 = 0 ;
39270 PyObject * obj2 = 0 ;
39271 char *kwnames[] = {
39272 (char *) "self",(char *) "item",(char *) "size", NULL
39273 };
39274
39275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39277 if (SWIG_arg_fail(1)) SWIG_fail;
39278 arg2 = obj1;
39279 {
39280 arg3 = &temp3;
39281 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39282 }
39283 {
39284 PyThreadState* __tstate = wxPyBeginAllowThreads();
39285 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39286
39287 wxPyEndAllowThreads(__tstate);
39288 if (PyErr_Occurred()) SWIG_fail;
39289 }
39290 Py_INCREF(Py_None); resultobj = Py_None;
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj;
39299 wxSizer *arg1 = (wxSizer *) 0 ;
39300 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39301 wxSizerItem *result;
39302 PyObject * obj0 = 0 ;
39303 PyObject * obj1 = 0 ;
39304 char *kwnames[] = {
39305 (char *) "self",(char *) "item", NULL
39306 };
39307
39308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39310 if (SWIG_arg_fail(1)) SWIG_fail;
39311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39312 if (SWIG_arg_fail(2)) SWIG_fail;
39313 {
39314 PyThreadState* __tstate = wxPyBeginAllowThreads();
39315 result = (wxSizerItem *)(arg1)->Add(arg2);
39316
39317 wxPyEndAllowThreads(__tstate);
39318 if (PyErr_Occurred()) SWIG_fail;
39319 }
39320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39321 return resultobj;
39322 fail:
39323 return NULL;
39324 }
39325
39326
39327 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39328 PyObject *resultobj;
39329 wxSizer *arg1 = (wxSizer *) 0 ;
39330 size_t arg2 ;
39331 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39332 wxSizerItem *result;
39333 PyObject * obj0 = 0 ;
39334 PyObject * obj1 = 0 ;
39335 PyObject * obj2 = 0 ;
39336 char *kwnames[] = {
39337 (char *) "self",(char *) "index",(char *) "item", NULL
39338 };
39339
39340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39342 if (SWIG_arg_fail(1)) SWIG_fail;
39343 {
39344 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39345 if (SWIG_arg_fail(2)) SWIG_fail;
39346 }
39347 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39348 if (SWIG_arg_fail(3)) SWIG_fail;
39349 {
39350 PyThreadState* __tstate = wxPyBeginAllowThreads();
39351 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39352
39353 wxPyEndAllowThreads(__tstate);
39354 if (PyErr_Occurred()) SWIG_fail;
39355 }
39356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39357 return resultobj;
39358 fail:
39359 return NULL;
39360 }
39361
39362
39363 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39364 PyObject *resultobj;
39365 wxSizer *arg1 = (wxSizer *) 0 ;
39366 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39367 wxSizerItem *result;
39368 PyObject * obj0 = 0 ;
39369 PyObject * obj1 = 0 ;
39370 char *kwnames[] = {
39371 (char *) "self",(char *) "item", NULL
39372 };
39373
39374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39376 if (SWIG_arg_fail(1)) SWIG_fail;
39377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39378 if (SWIG_arg_fail(2)) SWIG_fail;
39379 {
39380 PyThreadState* __tstate = wxPyBeginAllowThreads();
39381 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39382
39383 wxPyEndAllowThreads(__tstate);
39384 if (PyErr_Occurred()) SWIG_fail;
39385 }
39386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39387 return resultobj;
39388 fail:
39389 return NULL;
39390 }
39391
39392
39393 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39394 PyObject *resultobj;
39395 wxSizer *arg1 = (wxSizer *) 0 ;
39396 int arg2 ;
39397 int arg3 ;
39398 int arg4 ;
39399 int arg5 ;
39400 PyObject * obj0 = 0 ;
39401 PyObject * obj1 = 0 ;
39402 PyObject * obj2 = 0 ;
39403 PyObject * obj3 = 0 ;
39404 PyObject * obj4 = 0 ;
39405 char *kwnames[] = {
39406 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39407 };
39408
39409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39411 if (SWIG_arg_fail(1)) SWIG_fail;
39412 {
39413 arg2 = (int)(SWIG_As_int(obj1));
39414 if (SWIG_arg_fail(2)) SWIG_fail;
39415 }
39416 {
39417 arg3 = (int)(SWIG_As_int(obj2));
39418 if (SWIG_arg_fail(3)) SWIG_fail;
39419 }
39420 {
39421 arg4 = (int)(SWIG_As_int(obj3));
39422 if (SWIG_arg_fail(4)) SWIG_fail;
39423 }
39424 {
39425 arg5 = (int)(SWIG_As_int(obj4));
39426 if (SWIG_arg_fail(5)) SWIG_fail;
39427 }
39428 {
39429 PyThreadState* __tstate = wxPyBeginAllowThreads();
39430 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39431
39432 wxPyEndAllowThreads(__tstate);
39433 if (PyErr_Occurred()) SWIG_fail;
39434 }
39435 Py_INCREF(Py_None); resultobj = Py_None;
39436 return resultobj;
39437 fail:
39438 return NULL;
39439 }
39440
39441
39442 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39443 PyObject *resultobj;
39444 wxSizer *arg1 = (wxSizer *) 0 ;
39445 wxSize *arg2 = 0 ;
39446 wxSize temp2 ;
39447 PyObject * obj0 = 0 ;
39448 PyObject * obj1 = 0 ;
39449 char *kwnames[] = {
39450 (char *) "self",(char *) "size", NULL
39451 };
39452
39453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39455 if (SWIG_arg_fail(1)) SWIG_fail;
39456 {
39457 arg2 = &temp2;
39458 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39459 }
39460 {
39461 PyThreadState* __tstate = wxPyBeginAllowThreads();
39462 (arg1)->SetMinSize((wxSize const &)*arg2);
39463
39464 wxPyEndAllowThreads(__tstate);
39465 if (PyErr_Occurred()) SWIG_fail;
39466 }
39467 Py_INCREF(Py_None); resultobj = Py_None;
39468 return resultobj;
39469 fail:
39470 return NULL;
39471 }
39472
39473
39474 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39475 PyObject *resultobj;
39476 wxSizer *arg1 = (wxSizer *) 0 ;
39477 wxSize result;
39478 PyObject * obj0 = 0 ;
39479 char *kwnames[] = {
39480 (char *) "self", NULL
39481 };
39482
39483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39485 if (SWIG_arg_fail(1)) SWIG_fail;
39486 {
39487 PyThreadState* __tstate = wxPyBeginAllowThreads();
39488 result = (arg1)->GetSize();
39489
39490 wxPyEndAllowThreads(__tstate);
39491 if (PyErr_Occurred()) SWIG_fail;
39492 }
39493 {
39494 wxSize * resultptr;
39495 resultptr = new wxSize((wxSize &)(result));
39496 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39497 }
39498 return resultobj;
39499 fail:
39500 return NULL;
39501 }
39502
39503
39504 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39505 PyObject *resultobj;
39506 wxSizer *arg1 = (wxSizer *) 0 ;
39507 wxPoint result;
39508 PyObject * obj0 = 0 ;
39509 char *kwnames[] = {
39510 (char *) "self", NULL
39511 };
39512
39513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39515 if (SWIG_arg_fail(1)) SWIG_fail;
39516 {
39517 PyThreadState* __tstate = wxPyBeginAllowThreads();
39518 result = (arg1)->GetPosition();
39519
39520 wxPyEndAllowThreads(__tstate);
39521 if (PyErr_Occurred()) SWIG_fail;
39522 }
39523 {
39524 wxPoint * resultptr;
39525 resultptr = new wxPoint((wxPoint &)(result));
39526 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39527 }
39528 return resultobj;
39529 fail:
39530 return NULL;
39531 }
39532
39533
39534 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39535 PyObject *resultobj;
39536 wxSizer *arg1 = (wxSizer *) 0 ;
39537 wxSize result;
39538 PyObject * obj0 = 0 ;
39539 char *kwnames[] = {
39540 (char *) "self", NULL
39541 };
39542
39543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39545 if (SWIG_arg_fail(1)) SWIG_fail;
39546 {
39547 PyThreadState* __tstate = wxPyBeginAllowThreads();
39548 result = (arg1)->GetMinSize();
39549
39550 wxPyEndAllowThreads(__tstate);
39551 if (PyErr_Occurred()) SWIG_fail;
39552 }
39553 {
39554 wxSize * resultptr;
39555 resultptr = new wxSize((wxSize &)(result));
39556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39557 }
39558 return resultobj;
39559 fail:
39560 return NULL;
39561 }
39562
39563
39564 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39565 PyObject *resultobj;
39566 wxSizer *arg1 = (wxSizer *) 0 ;
39567 PyObject * obj0 = 0 ;
39568 char *kwnames[] = {
39569 (char *) "self", NULL
39570 };
39571
39572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39574 if (SWIG_arg_fail(1)) SWIG_fail;
39575 {
39576 PyThreadState* __tstate = wxPyBeginAllowThreads();
39577 (arg1)->RecalcSizes();
39578
39579 wxPyEndAllowThreads(__tstate);
39580 if (PyErr_Occurred()) SWIG_fail;
39581 }
39582 Py_INCREF(Py_None); resultobj = Py_None;
39583 return resultobj;
39584 fail:
39585 return NULL;
39586 }
39587
39588
39589 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39590 PyObject *resultobj;
39591 wxSizer *arg1 = (wxSizer *) 0 ;
39592 wxSize result;
39593 PyObject * obj0 = 0 ;
39594 char *kwnames[] = {
39595 (char *) "self", NULL
39596 };
39597
39598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39600 if (SWIG_arg_fail(1)) SWIG_fail;
39601 {
39602 PyThreadState* __tstate = wxPyBeginAllowThreads();
39603 result = (arg1)->CalcMin();
39604
39605 wxPyEndAllowThreads(__tstate);
39606 if (PyErr_Occurred()) SWIG_fail;
39607 }
39608 {
39609 wxSize * resultptr;
39610 resultptr = new wxSize((wxSize &)(result));
39611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39612 }
39613 return resultobj;
39614 fail:
39615 return NULL;
39616 }
39617
39618
39619 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39620 PyObject *resultobj;
39621 wxSizer *arg1 = (wxSizer *) 0 ;
39622 PyObject * obj0 = 0 ;
39623 char *kwnames[] = {
39624 (char *) "self", NULL
39625 };
39626
39627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39629 if (SWIG_arg_fail(1)) SWIG_fail;
39630 {
39631 PyThreadState* __tstate = wxPyBeginAllowThreads();
39632 (arg1)->Layout();
39633
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 Py_INCREF(Py_None); resultobj = Py_None;
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39645 PyObject *resultobj;
39646 wxSizer *arg1 = (wxSizer *) 0 ;
39647 wxWindow *arg2 = (wxWindow *) 0 ;
39648 wxSize result;
39649 PyObject * obj0 = 0 ;
39650 PyObject * obj1 = 0 ;
39651 char *kwnames[] = {
39652 (char *) "self",(char *) "window", NULL
39653 };
39654
39655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39657 if (SWIG_arg_fail(1)) SWIG_fail;
39658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39659 if (SWIG_arg_fail(2)) SWIG_fail;
39660 {
39661 PyThreadState* __tstate = wxPyBeginAllowThreads();
39662 result = (arg1)->Fit(arg2);
39663
39664 wxPyEndAllowThreads(__tstate);
39665 if (PyErr_Occurred()) SWIG_fail;
39666 }
39667 {
39668 wxSize * resultptr;
39669 resultptr = new wxSize((wxSize &)(result));
39670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39671 }
39672 return resultobj;
39673 fail:
39674 return NULL;
39675 }
39676
39677
39678 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39679 PyObject *resultobj;
39680 wxSizer *arg1 = (wxSizer *) 0 ;
39681 wxWindow *arg2 = (wxWindow *) 0 ;
39682 PyObject * obj0 = 0 ;
39683 PyObject * obj1 = 0 ;
39684 char *kwnames[] = {
39685 (char *) "self",(char *) "window", NULL
39686 };
39687
39688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39690 if (SWIG_arg_fail(1)) SWIG_fail;
39691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39692 if (SWIG_arg_fail(2)) SWIG_fail;
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 (arg1)->FitInside(arg2);
39696
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 Py_INCREF(Py_None); resultobj = Py_None;
39701 return resultobj;
39702 fail:
39703 return NULL;
39704 }
39705
39706
39707 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39708 PyObject *resultobj;
39709 wxSizer *arg1 = (wxSizer *) 0 ;
39710 wxWindow *arg2 = (wxWindow *) 0 ;
39711 PyObject * obj0 = 0 ;
39712 PyObject * obj1 = 0 ;
39713 char *kwnames[] = {
39714 (char *) "self",(char *) "window", NULL
39715 };
39716
39717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39719 if (SWIG_arg_fail(1)) SWIG_fail;
39720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39721 if (SWIG_arg_fail(2)) SWIG_fail;
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 (arg1)->SetSizeHints(arg2);
39725
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 Py_INCREF(Py_None); resultobj = Py_None;
39730 return resultobj;
39731 fail:
39732 return NULL;
39733 }
39734
39735
39736 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj;
39738 wxSizer *arg1 = (wxSizer *) 0 ;
39739 wxWindow *arg2 = (wxWindow *) 0 ;
39740 PyObject * obj0 = 0 ;
39741 PyObject * obj1 = 0 ;
39742 char *kwnames[] = {
39743 (char *) "self",(char *) "window", NULL
39744 };
39745
39746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39748 if (SWIG_arg_fail(1)) SWIG_fail;
39749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39750 if (SWIG_arg_fail(2)) SWIG_fail;
39751 {
39752 PyThreadState* __tstate = wxPyBeginAllowThreads();
39753 (arg1)->SetVirtualSizeHints(arg2);
39754
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 Py_INCREF(Py_None); resultobj = Py_None;
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39766 PyObject *resultobj;
39767 wxSizer *arg1 = (wxSizer *) 0 ;
39768 bool arg2 = (bool) false ;
39769 PyObject * obj0 = 0 ;
39770 PyObject * obj1 = 0 ;
39771 char *kwnames[] = {
39772 (char *) "self",(char *) "deleteWindows", NULL
39773 };
39774
39775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39777 if (SWIG_arg_fail(1)) SWIG_fail;
39778 if (obj1) {
39779 {
39780 arg2 = (bool)(SWIG_As_bool(obj1));
39781 if (SWIG_arg_fail(2)) SWIG_fail;
39782 }
39783 }
39784 {
39785 PyThreadState* __tstate = wxPyBeginAllowThreads();
39786 (arg1)->Clear(arg2);
39787
39788 wxPyEndAllowThreads(__tstate);
39789 if (PyErr_Occurred()) SWIG_fail;
39790 }
39791 Py_INCREF(Py_None); resultobj = Py_None;
39792 return resultobj;
39793 fail:
39794 return NULL;
39795 }
39796
39797
39798 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39799 PyObject *resultobj;
39800 wxSizer *arg1 = (wxSizer *) 0 ;
39801 PyObject * obj0 = 0 ;
39802 char *kwnames[] = {
39803 (char *) "self", NULL
39804 };
39805
39806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39808 if (SWIG_arg_fail(1)) SWIG_fail;
39809 {
39810 PyThreadState* __tstate = wxPyBeginAllowThreads();
39811 (arg1)->DeleteWindows();
39812
39813 wxPyEndAllowThreads(__tstate);
39814 if (PyErr_Occurred()) SWIG_fail;
39815 }
39816 Py_INCREF(Py_None); resultobj = Py_None;
39817 return resultobj;
39818 fail:
39819 return NULL;
39820 }
39821
39822
39823 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39824 PyObject *resultobj;
39825 wxSizer *arg1 = (wxSizer *) 0 ;
39826 PyObject *result;
39827 PyObject * obj0 = 0 ;
39828 char *kwnames[] = {
39829 (char *) "self", NULL
39830 };
39831
39832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39834 if (SWIG_arg_fail(1)) SWIG_fail;
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (PyObject *)wxSizer_GetChildren(arg1);
39838
39839 wxPyEndAllowThreads(__tstate);
39840 if (PyErr_Occurred()) SWIG_fail;
39841 }
39842 resultobj = result;
39843 return resultobj;
39844 fail:
39845 return NULL;
39846 }
39847
39848
39849 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39850 PyObject *resultobj;
39851 wxSizer *arg1 = (wxSizer *) 0 ;
39852 PyObject *arg2 = (PyObject *) 0 ;
39853 bool arg3 = (bool) true ;
39854 bool arg4 = (bool) false ;
39855 bool result;
39856 PyObject * obj0 = 0 ;
39857 PyObject * obj1 = 0 ;
39858 PyObject * obj2 = 0 ;
39859 PyObject * obj3 = 0 ;
39860 char *kwnames[] = {
39861 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39862 };
39863
39864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39866 if (SWIG_arg_fail(1)) SWIG_fail;
39867 arg2 = obj1;
39868 if (obj2) {
39869 {
39870 arg3 = (bool)(SWIG_As_bool(obj2));
39871 if (SWIG_arg_fail(3)) SWIG_fail;
39872 }
39873 }
39874 if (obj3) {
39875 {
39876 arg4 = (bool)(SWIG_As_bool(obj3));
39877 if (SWIG_arg_fail(4)) SWIG_fail;
39878 }
39879 }
39880 {
39881 PyThreadState* __tstate = wxPyBeginAllowThreads();
39882 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39883
39884 wxPyEndAllowThreads(__tstate);
39885 if (PyErr_Occurred()) SWIG_fail;
39886 }
39887 {
39888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39889 }
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39897 PyObject *resultobj;
39898 wxSizer *arg1 = (wxSizer *) 0 ;
39899 PyObject *arg2 = (PyObject *) 0 ;
39900 bool result;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 char *kwnames[] = {
39904 (char *) "self",(char *) "item", NULL
39905 };
39906
39907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39909 if (SWIG_arg_fail(1)) SWIG_fail;
39910 arg2 = obj1;
39911 {
39912 PyThreadState* __tstate = wxPyBeginAllowThreads();
39913 result = (bool)wxSizer_IsShown(arg1,arg2);
39914
39915 wxPyEndAllowThreads(__tstate);
39916 if (PyErr_Occurred()) SWIG_fail;
39917 }
39918 {
39919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39920 }
39921 return resultobj;
39922 fail:
39923 return NULL;
39924 }
39925
39926
39927 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39928 PyObject *resultobj;
39929 wxSizer *arg1 = (wxSizer *) 0 ;
39930 bool arg2 ;
39931 PyObject * obj0 = 0 ;
39932 PyObject * obj1 = 0 ;
39933 char *kwnames[] = {
39934 (char *) "self",(char *) "show", NULL
39935 };
39936
39937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39939 if (SWIG_arg_fail(1)) SWIG_fail;
39940 {
39941 arg2 = (bool)(SWIG_As_bool(obj1));
39942 if (SWIG_arg_fail(2)) SWIG_fail;
39943 }
39944 {
39945 PyThreadState* __tstate = wxPyBeginAllowThreads();
39946 (arg1)->ShowItems(arg2);
39947
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 Py_INCREF(Py_None); resultobj = Py_None;
39952 return resultobj;
39953 fail:
39954 return NULL;
39955 }
39956
39957
39958 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39959 PyObject *obj;
39960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39961 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39962 Py_INCREF(obj);
39963 return Py_BuildValue((char *)"");
39964 }
39965 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39966 PyObject *resultobj;
39967 wxPySizer *result;
39968 char *kwnames[] = {
39969 NULL
39970 };
39971
39972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39973 {
39974 PyThreadState* __tstate = wxPyBeginAllowThreads();
39975 result = (wxPySizer *)new wxPySizer();
39976
39977 wxPyEndAllowThreads(__tstate);
39978 if (PyErr_Occurred()) SWIG_fail;
39979 }
39980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39981 return resultobj;
39982 fail:
39983 return NULL;
39984 }
39985
39986
39987 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39988 PyObject *resultobj;
39989 wxPySizer *arg1 = (wxPySizer *) 0 ;
39990 PyObject *arg2 = (PyObject *) 0 ;
39991 PyObject *arg3 = (PyObject *) 0 ;
39992 PyObject * obj0 = 0 ;
39993 PyObject * obj1 = 0 ;
39994 PyObject * obj2 = 0 ;
39995 char *kwnames[] = {
39996 (char *) "self",(char *) "self",(char *) "_class", NULL
39997 };
39998
39999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40001 if (SWIG_arg_fail(1)) SWIG_fail;
40002 arg2 = obj1;
40003 arg3 = obj2;
40004 {
40005 PyThreadState* __tstate = wxPyBeginAllowThreads();
40006 (arg1)->_setCallbackInfo(arg2,arg3);
40007
40008 wxPyEndAllowThreads(__tstate);
40009 if (PyErr_Occurred()) SWIG_fail;
40010 }
40011 Py_INCREF(Py_None); resultobj = Py_None;
40012 return resultobj;
40013 fail:
40014 return NULL;
40015 }
40016
40017
40018 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40019 PyObject *obj;
40020 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40021 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40022 Py_INCREF(obj);
40023 return Py_BuildValue((char *)"");
40024 }
40025 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj;
40027 int arg1 = (int) wxHORIZONTAL ;
40028 wxBoxSizer *result;
40029 PyObject * obj0 = 0 ;
40030 char *kwnames[] = {
40031 (char *) "orient", NULL
40032 };
40033
40034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40035 if (obj0) {
40036 {
40037 arg1 = (int)(SWIG_As_int(obj0));
40038 if (SWIG_arg_fail(1)) SWIG_fail;
40039 }
40040 }
40041 {
40042 PyThreadState* __tstate = wxPyBeginAllowThreads();
40043 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40044
40045 wxPyEndAllowThreads(__tstate);
40046 if (PyErr_Occurred()) SWIG_fail;
40047 }
40048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40049 return resultobj;
40050 fail:
40051 return NULL;
40052 }
40053
40054
40055 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40056 PyObject *resultobj;
40057 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40058 int result;
40059 PyObject * obj0 = 0 ;
40060 char *kwnames[] = {
40061 (char *) "self", NULL
40062 };
40063
40064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40066 if (SWIG_arg_fail(1)) SWIG_fail;
40067 {
40068 PyThreadState* __tstate = wxPyBeginAllowThreads();
40069 result = (int)(arg1)->GetOrientation();
40070
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 {
40075 resultobj = SWIG_From_int((int)(result));
40076 }
40077 return resultobj;
40078 fail:
40079 return NULL;
40080 }
40081
40082
40083 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40084 PyObject *resultobj;
40085 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40086 int arg2 ;
40087 PyObject * obj0 = 0 ;
40088 PyObject * obj1 = 0 ;
40089 char *kwnames[] = {
40090 (char *) "self",(char *) "orient", NULL
40091 };
40092
40093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40095 if (SWIG_arg_fail(1)) SWIG_fail;
40096 {
40097 arg2 = (int)(SWIG_As_int(obj1));
40098 if (SWIG_arg_fail(2)) SWIG_fail;
40099 }
40100 {
40101 PyThreadState* __tstate = wxPyBeginAllowThreads();
40102 (arg1)->SetOrientation(arg2);
40103
40104 wxPyEndAllowThreads(__tstate);
40105 if (PyErr_Occurred()) SWIG_fail;
40106 }
40107 Py_INCREF(Py_None); resultobj = Py_None;
40108 return resultobj;
40109 fail:
40110 return NULL;
40111 }
40112
40113
40114 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40115 PyObject *obj;
40116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40117 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40118 Py_INCREF(obj);
40119 return Py_BuildValue((char *)"");
40120 }
40121 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj;
40123 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40124 int arg2 = (int) wxHORIZONTAL ;
40125 wxStaticBoxSizer *result;
40126 PyObject * obj0 = 0 ;
40127 PyObject * obj1 = 0 ;
40128 char *kwnames[] = {
40129 (char *) "box",(char *) "orient", NULL
40130 };
40131
40132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40134 if (SWIG_arg_fail(1)) SWIG_fail;
40135 if (obj1) {
40136 {
40137 arg2 = (int)(SWIG_As_int(obj1));
40138 if (SWIG_arg_fail(2)) SWIG_fail;
40139 }
40140 }
40141 {
40142 PyThreadState* __tstate = wxPyBeginAllowThreads();
40143 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40144
40145 wxPyEndAllowThreads(__tstate);
40146 if (PyErr_Occurred()) SWIG_fail;
40147 }
40148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40149 return resultobj;
40150 fail:
40151 return NULL;
40152 }
40153
40154
40155 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40156 PyObject *resultobj;
40157 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40158 wxStaticBox *result;
40159 PyObject * obj0 = 0 ;
40160 char *kwnames[] = {
40161 (char *) "self", NULL
40162 };
40163
40164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40166 if (SWIG_arg_fail(1)) SWIG_fail;
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 result = (wxStaticBox *)(arg1)->GetStaticBox();
40170
40171 wxPyEndAllowThreads(__tstate);
40172 if (PyErr_Occurred()) SWIG_fail;
40173 }
40174 {
40175 resultobj = wxPyMake_wxObject(result, 0);
40176 }
40177 return resultobj;
40178 fail:
40179 return NULL;
40180 }
40181
40182
40183 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40184 PyObject *obj;
40185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40186 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40187 Py_INCREF(obj);
40188 return Py_BuildValue((char *)"");
40189 }
40190 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40191 PyObject *resultobj;
40192 int arg1 = (int) 1 ;
40193 int arg2 = (int) 0 ;
40194 int arg3 = (int) 0 ;
40195 int arg4 = (int) 0 ;
40196 wxGridSizer *result;
40197 PyObject * obj0 = 0 ;
40198 PyObject * obj1 = 0 ;
40199 PyObject * obj2 = 0 ;
40200 PyObject * obj3 = 0 ;
40201 char *kwnames[] = {
40202 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40203 };
40204
40205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40206 if (obj0) {
40207 {
40208 arg1 = (int)(SWIG_As_int(obj0));
40209 if (SWIG_arg_fail(1)) SWIG_fail;
40210 }
40211 }
40212 if (obj1) {
40213 {
40214 arg2 = (int)(SWIG_As_int(obj1));
40215 if (SWIG_arg_fail(2)) SWIG_fail;
40216 }
40217 }
40218 if (obj2) {
40219 {
40220 arg3 = (int)(SWIG_As_int(obj2));
40221 if (SWIG_arg_fail(3)) SWIG_fail;
40222 }
40223 }
40224 if (obj3) {
40225 {
40226 arg4 = (int)(SWIG_As_int(obj3));
40227 if (SWIG_arg_fail(4)) SWIG_fail;
40228 }
40229 }
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40233
40234 wxPyEndAllowThreads(__tstate);
40235 if (PyErr_Occurred()) SWIG_fail;
40236 }
40237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40238 return resultobj;
40239 fail:
40240 return NULL;
40241 }
40242
40243
40244 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40245 PyObject *resultobj;
40246 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40247 int arg2 ;
40248 PyObject * obj0 = 0 ;
40249 PyObject * obj1 = 0 ;
40250 char *kwnames[] = {
40251 (char *) "self",(char *) "cols", NULL
40252 };
40253
40254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40256 if (SWIG_arg_fail(1)) SWIG_fail;
40257 {
40258 arg2 = (int)(SWIG_As_int(obj1));
40259 if (SWIG_arg_fail(2)) SWIG_fail;
40260 }
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->SetCols(arg2);
40264
40265 wxPyEndAllowThreads(__tstate);
40266 if (PyErr_Occurred()) SWIG_fail;
40267 }
40268 Py_INCREF(Py_None); resultobj = Py_None;
40269 return resultobj;
40270 fail:
40271 return NULL;
40272 }
40273
40274
40275 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj;
40277 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40278 int arg2 ;
40279 PyObject * obj0 = 0 ;
40280 PyObject * obj1 = 0 ;
40281 char *kwnames[] = {
40282 (char *) "self",(char *) "rows", NULL
40283 };
40284
40285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40287 if (SWIG_arg_fail(1)) SWIG_fail;
40288 {
40289 arg2 = (int)(SWIG_As_int(obj1));
40290 if (SWIG_arg_fail(2)) SWIG_fail;
40291 }
40292 {
40293 PyThreadState* __tstate = wxPyBeginAllowThreads();
40294 (arg1)->SetRows(arg2);
40295
40296 wxPyEndAllowThreads(__tstate);
40297 if (PyErr_Occurred()) SWIG_fail;
40298 }
40299 Py_INCREF(Py_None); resultobj = Py_None;
40300 return resultobj;
40301 fail:
40302 return NULL;
40303 }
40304
40305
40306 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40307 PyObject *resultobj;
40308 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40309 int arg2 ;
40310 PyObject * obj0 = 0 ;
40311 PyObject * obj1 = 0 ;
40312 char *kwnames[] = {
40313 (char *) "self",(char *) "gap", NULL
40314 };
40315
40316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40318 if (SWIG_arg_fail(1)) SWIG_fail;
40319 {
40320 arg2 = (int)(SWIG_As_int(obj1));
40321 if (SWIG_arg_fail(2)) SWIG_fail;
40322 }
40323 {
40324 PyThreadState* __tstate = wxPyBeginAllowThreads();
40325 (arg1)->SetVGap(arg2);
40326
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 Py_INCREF(Py_None); resultobj = Py_None;
40331 return resultobj;
40332 fail:
40333 return NULL;
40334 }
40335
40336
40337 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40338 PyObject *resultobj;
40339 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40340 int arg2 ;
40341 PyObject * obj0 = 0 ;
40342 PyObject * obj1 = 0 ;
40343 char *kwnames[] = {
40344 (char *) "self",(char *) "gap", NULL
40345 };
40346
40347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40349 if (SWIG_arg_fail(1)) SWIG_fail;
40350 {
40351 arg2 = (int)(SWIG_As_int(obj1));
40352 if (SWIG_arg_fail(2)) SWIG_fail;
40353 }
40354 {
40355 PyThreadState* __tstate = wxPyBeginAllowThreads();
40356 (arg1)->SetHGap(arg2);
40357
40358 wxPyEndAllowThreads(__tstate);
40359 if (PyErr_Occurred()) SWIG_fail;
40360 }
40361 Py_INCREF(Py_None); resultobj = Py_None;
40362 return resultobj;
40363 fail:
40364 return NULL;
40365 }
40366
40367
40368 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40369 PyObject *resultobj;
40370 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40371 int result;
40372 PyObject * obj0 = 0 ;
40373 char *kwnames[] = {
40374 (char *) "self", NULL
40375 };
40376
40377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40379 if (SWIG_arg_fail(1)) SWIG_fail;
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 result = (int)(arg1)->GetCols();
40383
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 {
40388 resultobj = SWIG_From_int((int)(result));
40389 }
40390 return resultobj;
40391 fail:
40392 return NULL;
40393 }
40394
40395
40396 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40397 PyObject *resultobj;
40398 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40399 int result;
40400 PyObject * obj0 = 0 ;
40401 char *kwnames[] = {
40402 (char *) "self", NULL
40403 };
40404
40405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40407 if (SWIG_arg_fail(1)) SWIG_fail;
40408 {
40409 PyThreadState* __tstate = wxPyBeginAllowThreads();
40410 result = (int)(arg1)->GetRows();
40411
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 {
40416 resultobj = SWIG_From_int((int)(result));
40417 }
40418 return resultobj;
40419 fail:
40420 return NULL;
40421 }
40422
40423
40424 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40425 PyObject *resultobj;
40426 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40427 int result;
40428 PyObject * obj0 = 0 ;
40429 char *kwnames[] = {
40430 (char *) "self", NULL
40431 };
40432
40433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40435 if (SWIG_arg_fail(1)) SWIG_fail;
40436 {
40437 PyThreadState* __tstate = wxPyBeginAllowThreads();
40438 result = (int)(arg1)->GetVGap();
40439
40440 wxPyEndAllowThreads(__tstate);
40441 if (PyErr_Occurred()) SWIG_fail;
40442 }
40443 {
40444 resultobj = SWIG_From_int((int)(result));
40445 }
40446 return resultobj;
40447 fail:
40448 return NULL;
40449 }
40450
40451
40452 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40453 PyObject *resultobj;
40454 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40455 int result;
40456 PyObject * obj0 = 0 ;
40457 char *kwnames[] = {
40458 (char *) "self", NULL
40459 };
40460
40461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40463 if (SWIG_arg_fail(1)) SWIG_fail;
40464 {
40465 PyThreadState* __tstate = wxPyBeginAllowThreads();
40466 result = (int)(arg1)->GetHGap();
40467
40468 wxPyEndAllowThreads(__tstate);
40469 if (PyErr_Occurred()) SWIG_fail;
40470 }
40471 {
40472 resultobj = SWIG_From_int((int)(result));
40473 }
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40481 PyObject *obj;
40482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40483 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40484 Py_INCREF(obj);
40485 return Py_BuildValue((char *)"");
40486 }
40487 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40488 PyObject *resultobj;
40489 int arg1 = (int) 1 ;
40490 int arg2 = (int) 0 ;
40491 int arg3 = (int) 0 ;
40492 int arg4 = (int) 0 ;
40493 wxFlexGridSizer *result;
40494 PyObject * obj0 = 0 ;
40495 PyObject * obj1 = 0 ;
40496 PyObject * obj2 = 0 ;
40497 PyObject * obj3 = 0 ;
40498 char *kwnames[] = {
40499 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40500 };
40501
40502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40503 if (obj0) {
40504 {
40505 arg1 = (int)(SWIG_As_int(obj0));
40506 if (SWIG_arg_fail(1)) SWIG_fail;
40507 }
40508 }
40509 if (obj1) {
40510 {
40511 arg2 = (int)(SWIG_As_int(obj1));
40512 if (SWIG_arg_fail(2)) SWIG_fail;
40513 }
40514 }
40515 if (obj2) {
40516 {
40517 arg3 = (int)(SWIG_As_int(obj2));
40518 if (SWIG_arg_fail(3)) SWIG_fail;
40519 }
40520 }
40521 if (obj3) {
40522 {
40523 arg4 = (int)(SWIG_As_int(obj3));
40524 if (SWIG_arg_fail(4)) SWIG_fail;
40525 }
40526 }
40527 {
40528 PyThreadState* __tstate = wxPyBeginAllowThreads();
40529 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40530
40531 wxPyEndAllowThreads(__tstate);
40532 if (PyErr_Occurred()) SWIG_fail;
40533 }
40534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40535 return resultobj;
40536 fail:
40537 return NULL;
40538 }
40539
40540
40541 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40542 PyObject *resultobj;
40543 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40544 size_t arg2 ;
40545 int arg3 = (int) 0 ;
40546 PyObject * obj0 = 0 ;
40547 PyObject * obj1 = 0 ;
40548 PyObject * obj2 = 0 ;
40549 char *kwnames[] = {
40550 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40551 };
40552
40553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40555 if (SWIG_arg_fail(1)) SWIG_fail;
40556 {
40557 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40558 if (SWIG_arg_fail(2)) SWIG_fail;
40559 }
40560 if (obj2) {
40561 {
40562 arg3 = (int)(SWIG_As_int(obj2));
40563 if (SWIG_arg_fail(3)) SWIG_fail;
40564 }
40565 }
40566 {
40567 PyThreadState* __tstate = wxPyBeginAllowThreads();
40568 (arg1)->AddGrowableRow(arg2,arg3);
40569
40570 wxPyEndAllowThreads(__tstate);
40571 if (PyErr_Occurred()) SWIG_fail;
40572 }
40573 Py_INCREF(Py_None); resultobj = Py_None;
40574 return resultobj;
40575 fail:
40576 return NULL;
40577 }
40578
40579
40580 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40581 PyObject *resultobj;
40582 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40583 size_t arg2 ;
40584 PyObject * obj0 = 0 ;
40585 PyObject * obj1 = 0 ;
40586 char *kwnames[] = {
40587 (char *) "self",(char *) "idx", NULL
40588 };
40589
40590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40592 if (SWIG_arg_fail(1)) SWIG_fail;
40593 {
40594 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40595 if (SWIG_arg_fail(2)) SWIG_fail;
40596 }
40597 {
40598 PyThreadState* __tstate = wxPyBeginAllowThreads();
40599 (arg1)->RemoveGrowableRow(arg2);
40600
40601 wxPyEndAllowThreads(__tstate);
40602 if (PyErr_Occurred()) SWIG_fail;
40603 }
40604 Py_INCREF(Py_None); resultobj = Py_None;
40605 return resultobj;
40606 fail:
40607 return NULL;
40608 }
40609
40610
40611 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40612 PyObject *resultobj;
40613 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40614 size_t arg2 ;
40615 int arg3 = (int) 0 ;
40616 PyObject * obj0 = 0 ;
40617 PyObject * obj1 = 0 ;
40618 PyObject * obj2 = 0 ;
40619 char *kwnames[] = {
40620 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40621 };
40622
40623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40625 if (SWIG_arg_fail(1)) SWIG_fail;
40626 {
40627 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40628 if (SWIG_arg_fail(2)) SWIG_fail;
40629 }
40630 if (obj2) {
40631 {
40632 arg3 = (int)(SWIG_As_int(obj2));
40633 if (SWIG_arg_fail(3)) SWIG_fail;
40634 }
40635 }
40636 {
40637 PyThreadState* __tstate = wxPyBeginAllowThreads();
40638 (arg1)->AddGrowableCol(arg2,arg3);
40639
40640 wxPyEndAllowThreads(__tstate);
40641 if (PyErr_Occurred()) SWIG_fail;
40642 }
40643 Py_INCREF(Py_None); resultobj = Py_None;
40644 return resultobj;
40645 fail:
40646 return NULL;
40647 }
40648
40649
40650 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40651 PyObject *resultobj;
40652 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40653 size_t arg2 ;
40654 PyObject * obj0 = 0 ;
40655 PyObject * obj1 = 0 ;
40656 char *kwnames[] = {
40657 (char *) "self",(char *) "idx", NULL
40658 };
40659
40660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40662 if (SWIG_arg_fail(1)) SWIG_fail;
40663 {
40664 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40665 if (SWIG_arg_fail(2)) SWIG_fail;
40666 }
40667 {
40668 PyThreadState* __tstate = wxPyBeginAllowThreads();
40669 (arg1)->RemoveGrowableCol(arg2);
40670
40671 wxPyEndAllowThreads(__tstate);
40672 if (PyErr_Occurred()) SWIG_fail;
40673 }
40674 Py_INCREF(Py_None); resultobj = Py_None;
40675 return resultobj;
40676 fail:
40677 return NULL;
40678 }
40679
40680
40681 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40682 PyObject *resultobj;
40683 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40684 int arg2 ;
40685 PyObject * obj0 = 0 ;
40686 PyObject * obj1 = 0 ;
40687 char *kwnames[] = {
40688 (char *) "self",(char *) "direction", NULL
40689 };
40690
40691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40693 if (SWIG_arg_fail(1)) SWIG_fail;
40694 {
40695 arg2 = (int)(SWIG_As_int(obj1));
40696 if (SWIG_arg_fail(2)) SWIG_fail;
40697 }
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 (arg1)->SetFlexibleDirection(arg2);
40701
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 Py_INCREF(Py_None); resultobj = Py_None;
40706 return resultobj;
40707 fail:
40708 return NULL;
40709 }
40710
40711
40712 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40713 PyObject *resultobj;
40714 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40715 int result;
40716 PyObject * obj0 = 0 ;
40717 char *kwnames[] = {
40718 (char *) "self", NULL
40719 };
40720
40721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40723 if (SWIG_arg_fail(1)) SWIG_fail;
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 result = (int)(arg1)->GetFlexibleDirection();
40727
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 {
40732 resultobj = SWIG_From_int((int)(result));
40733 }
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj;
40742 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40743 wxFlexSizerGrowMode arg2 ;
40744 PyObject * obj0 = 0 ;
40745 PyObject * obj1 = 0 ;
40746 char *kwnames[] = {
40747 (char *) "self",(char *) "mode", NULL
40748 };
40749
40750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40752 if (SWIG_arg_fail(1)) SWIG_fail;
40753 {
40754 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40755 if (SWIG_arg_fail(2)) SWIG_fail;
40756 }
40757 {
40758 PyThreadState* __tstate = wxPyBeginAllowThreads();
40759 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40760
40761 wxPyEndAllowThreads(__tstate);
40762 if (PyErr_Occurred()) SWIG_fail;
40763 }
40764 Py_INCREF(Py_None); resultobj = Py_None;
40765 return resultobj;
40766 fail:
40767 return NULL;
40768 }
40769
40770
40771 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40772 PyObject *resultobj;
40773 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40774 wxFlexSizerGrowMode result;
40775 PyObject * obj0 = 0 ;
40776 char *kwnames[] = {
40777 (char *) "self", NULL
40778 };
40779
40780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40782 if (SWIG_arg_fail(1)) SWIG_fail;
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40786
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 resultobj = SWIG_From_int((result));
40791 return resultobj;
40792 fail:
40793 return NULL;
40794 }
40795
40796
40797 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40798 PyObject *resultobj;
40799 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40800 wxArrayInt *result;
40801 PyObject * obj0 = 0 ;
40802 char *kwnames[] = {
40803 (char *) "self", NULL
40804 };
40805
40806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40808 if (SWIG_arg_fail(1)) SWIG_fail;
40809 {
40810 PyThreadState* __tstate = wxPyBeginAllowThreads();
40811 {
40812 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40813 result = (wxArrayInt *) &_result_ref;
40814 }
40815
40816 wxPyEndAllowThreads(__tstate);
40817 if (PyErr_Occurred()) SWIG_fail;
40818 }
40819 {
40820 resultobj = PyList_New(0);
40821 size_t idx;
40822 for (idx = 0; idx < result->GetCount(); idx += 1) {
40823 PyObject* val = PyInt_FromLong( result->Item(idx) );
40824 PyList_Append(resultobj, val);
40825 Py_DECREF(val);
40826 }
40827 }
40828 return resultobj;
40829 fail:
40830 return NULL;
40831 }
40832
40833
40834 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40835 PyObject *resultobj;
40836 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40837 wxArrayInt *result;
40838 PyObject * obj0 = 0 ;
40839 char *kwnames[] = {
40840 (char *) "self", NULL
40841 };
40842
40843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40845 if (SWIG_arg_fail(1)) SWIG_fail;
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 {
40849 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40850 result = (wxArrayInt *) &_result_ref;
40851 }
40852
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = PyList_New(0);
40858 size_t idx;
40859 for (idx = 0; idx < result->GetCount(); idx += 1) {
40860 PyObject* val = PyInt_FromLong( result->Item(idx) );
40861 PyList_Append(resultobj, val);
40862 Py_DECREF(val);
40863 }
40864 }
40865 return resultobj;
40866 fail:
40867 return NULL;
40868 }
40869
40870
40871 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40872 PyObject *obj;
40873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40874 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40875 Py_INCREF(obj);
40876 return Py_BuildValue((char *)"");
40877 }
40878 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40879 PyObject *resultobj;
40880 wxStdDialogButtonSizer *result;
40881 char *kwnames[] = {
40882 NULL
40883 };
40884
40885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40886 {
40887 PyThreadState* __tstate = wxPyBeginAllowThreads();
40888 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40889
40890 wxPyEndAllowThreads(__tstate);
40891 if (PyErr_Occurred()) SWIG_fail;
40892 }
40893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40894 return resultobj;
40895 fail:
40896 return NULL;
40897 }
40898
40899
40900 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40901 PyObject *resultobj;
40902 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40903 wxButton *arg2 = (wxButton *) 0 ;
40904 PyObject * obj0 = 0 ;
40905 PyObject * obj1 = 0 ;
40906 char *kwnames[] = {
40907 (char *) "self",(char *) "button", NULL
40908 };
40909
40910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40912 if (SWIG_arg_fail(1)) SWIG_fail;
40913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40914 if (SWIG_arg_fail(2)) SWIG_fail;
40915 {
40916 PyThreadState* __tstate = wxPyBeginAllowThreads();
40917 (arg1)->AddButton(arg2);
40918
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 Py_INCREF(Py_None); resultobj = Py_None;
40923 return resultobj;
40924 fail:
40925 return NULL;
40926 }
40927
40928
40929 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40930 PyObject *resultobj;
40931 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40932 PyObject * obj0 = 0 ;
40933 char *kwnames[] = {
40934 (char *) "self", NULL
40935 };
40936
40937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40939 if (SWIG_arg_fail(1)) SWIG_fail;
40940 {
40941 PyThreadState* __tstate = wxPyBeginAllowThreads();
40942 (arg1)->Realize();
40943
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 Py_INCREF(Py_None); resultobj = Py_None;
40948 return resultobj;
40949 fail:
40950 return NULL;
40951 }
40952
40953
40954 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40955 PyObject *resultobj;
40956 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40957 wxButton *arg2 = (wxButton *) 0 ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 char *kwnames[] = {
40961 (char *) "self",(char *) "button", NULL
40962 };
40963
40964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40966 if (SWIG_arg_fail(1)) SWIG_fail;
40967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40968 if (SWIG_arg_fail(2)) SWIG_fail;
40969 {
40970 PyThreadState* __tstate = wxPyBeginAllowThreads();
40971 (arg1)->SetAffirmativeButton(arg2);
40972
40973 wxPyEndAllowThreads(__tstate);
40974 if (PyErr_Occurred()) SWIG_fail;
40975 }
40976 Py_INCREF(Py_None); resultobj = Py_None;
40977 return resultobj;
40978 fail:
40979 return NULL;
40980 }
40981
40982
40983 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40984 PyObject *resultobj;
40985 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40986 wxButton *arg2 = (wxButton *) 0 ;
40987 PyObject * obj0 = 0 ;
40988 PyObject * obj1 = 0 ;
40989 char *kwnames[] = {
40990 (char *) "self",(char *) "button", NULL
40991 };
40992
40993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40995 if (SWIG_arg_fail(1)) SWIG_fail;
40996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40997 if (SWIG_arg_fail(2)) SWIG_fail;
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 (arg1)->SetNegativeButton(arg2);
41001
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 Py_INCREF(Py_None); resultobj = Py_None;
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41013 PyObject *resultobj;
41014 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41015 wxButton *arg2 = (wxButton *) 0 ;
41016 PyObject * obj0 = 0 ;
41017 PyObject * obj1 = 0 ;
41018 char *kwnames[] = {
41019 (char *) "self",(char *) "button", NULL
41020 };
41021
41022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41024 if (SWIG_arg_fail(1)) SWIG_fail;
41025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41026 if (SWIG_arg_fail(2)) SWIG_fail;
41027 {
41028 PyThreadState* __tstate = wxPyBeginAllowThreads();
41029 (arg1)->SetCancelButton(arg2);
41030
41031 wxPyEndAllowThreads(__tstate);
41032 if (PyErr_Occurred()) SWIG_fail;
41033 }
41034 Py_INCREF(Py_None); resultobj = Py_None;
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj;
41043 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41044 wxButton *result;
41045 PyObject * obj0 = 0 ;
41046 char *kwnames[] = {
41047 (char *) "self", NULL
41048 };
41049
41050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41056
41057 wxPyEndAllowThreads(__tstate);
41058 if (PyErr_Occurred()) SWIG_fail;
41059 }
41060 {
41061 resultobj = wxPyMake_wxObject(result, 0);
41062 }
41063 return resultobj;
41064 fail:
41065 return NULL;
41066 }
41067
41068
41069 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41070 PyObject *resultobj;
41071 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41072 wxButton *result;
41073 PyObject * obj0 = 0 ;
41074 char *kwnames[] = {
41075 (char *) "self", NULL
41076 };
41077
41078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41080 if (SWIG_arg_fail(1)) SWIG_fail;
41081 {
41082 PyThreadState* __tstate = wxPyBeginAllowThreads();
41083 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41084
41085 wxPyEndAllowThreads(__tstate);
41086 if (PyErr_Occurred()) SWIG_fail;
41087 }
41088 {
41089 resultobj = wxPyMake_wxObject(result, 0);
41090 }
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41098 PyObject *resultobj;
41099 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41100 wxButton *result;
41101 PyObject * obj0 = 0 ;
41102 char *kwnames[] = {
41103 (char *) "self", NULL
41104 };
41105
41106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41108 if (SWIG_arg_fail(1)) SWIG_fail;
41109 {
41110 PyThreadState* __tstate = wxPyBeginAllowThreads();
41111 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41112
41113 wxPyEndAllowThreads(__tstate);
41114 if (PyErr_Occurred()) SWIG_fail;
41115 }
41116 {
41117 resultobj = wxPyMake_wxObject(result, 0);
41118 }
41119 return resultobj;
41120 fail:
41121 return NULL;
41122 }
41123
41124
41125 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41126 PyObject *resultobj;
41127 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41128 wxButton *result;
41129 PyObject * obj0 = 0 ;
41130 char *kwnames[] = {
41131 (char *) "self", NULL
41132 };
41133
41134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41136 if (SWIG_arg_fail(1)) SWIG_fail;
41137 {
41138 PyThreadState* __tstate = wxPyBeginAllowThreads();
41139 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41140
41141 wxPyEndAllowThreads(__tstate);
41142 if (PyErr_Occurred()) SWIG_fail;
41143 }
41144 {
41145 resultobj = wxPyMake_wxObject(result, 0);
41146 }
41147 return resultobj;
41148 fail:
41149 return NULL;
41150 }
41151
41152
41153 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41154 PyObject *resultobj;
41155 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41156 wxButton *result;
41157 PyObject * obj0 = 0 ;
41158 char *kwnames[] = {
41159 (char *) "self", NULL
41160 };
41161
41162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41164 if (SWIG_arg_fail(1)) SWIG_fail;
41165 {
41166 PyThreadState* __tstate = wxPyBeginAllowThreads();
41167 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41168
41169 wxPyEndAllowThreads(__tstate);
41170 if (PyErr_Occurred()) SWIG_fail;
41171 }
41172 {
41173 resultobj = wxPyMake_wxObject(result, 0);
41174 }
41175 return resultobj;
41176 fail:
41177 return NULL;
41178 }
41179
41180
41181 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41182 PyObject *obj;
41183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41184 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41185 Py_INCREF(obj);
41186 return Py_BuildValue((char *)"");
41187 }
41188 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41189 PyObject *resultobj;
41190 int arg1 = (int) 0 ;
41191 int arg2 = (int) 0 ;
41192 wxGBPosition *result;
41193 PyObject * obj0 = 0 ;
41194 PyObject * obj1 = 0 ;
41195 char *kwnames[] = {
41196 (char *) "row",(char *) "col", NULL
41197 };
41198
41199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41200 if (obj0) {
41201 {
41202 arg1 = (int)(SWIG_As_int(obj0));
41203 if (SWIG_arg_fail(1)) SWIG_fail;
41204 }
41205 }
41206 if (obj1) {
41207 {
41208 arg2 = (int)(SWIG_As_int(obj1));
41209 if (SWIG_arg_fail(2)) SWIG_fail;
41210 }
41211 }
41212 {
41213 PyThreadState* __tstate = wxPyBeginAllowThreads();
41214 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41215
41216 wxPyEndAllowThreads(__tstate);
41217 if (PyErr_Occurred()) SWIG_fail;
41218 }
41219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41220 return resultobj;
41221 fail:
41222 return NULL;
41223 }
41224
41225
41226 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41227 PyObject *resultobj;
41228 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41229 int result;
41230 PyObject * obj0 = 0 ;
41231 char *kwnames[] = {
41232 (char *) "self", NULL
41233 };
41234
41235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41237 if (SWIG_arg_fail(1)) SWIG_fail;
41238 {
41239 PyThreadState* __tstate = wxPyBeginAllowThreads();
41240 result = (int)((wxGBPosition const *)arg1)->GetRow();
41241
41242 wxPyEndAllowThreads(__tstate);
41243 if (PyErr_Occurred()) SWIG_fail;
41244 }
41245 {
41246 resultobj = SWIG_From_int((int)(result));
41247 }
41248 return resultobj;
41249 fail:
41250 return NULL;
41251 }
41252
41253
41254 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41255 PyObject *resultobj;
41256 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41257 int result;
41258 PyObject * obj0 = 0 ;
41259 char *kwnames[] = {
41260 (char *) "self", NULL
41261 };
41262
41263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41265 if (SWIG_arg_fail(1)) SWIG_fail;
41266 {
41267 PyThreadState* __tstate = wxPyBeginAllowThreads();
41268 result = (int)((wxGBPosition const *)arg1)->GetCol();
41269
41270 wxPyEndAllowThreads(__tstate);
41271 if (PyErr_Occurred()) SWIG_fail;
41272 }
41273 {
41274 resultobj = SWIG_From_int((int)(result));
41275 }
41276 return resultobj;
41277 fail:
41278 return NULL;
41279 }
41280
41281
41282 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41283 PyObject *resultobj;
41284 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41285 int arg2 ;
41286 PyObject * obj0 = 0 ;
41287 PyObject * obj1 = 0 ;
41288 char *kwnames[] = {
41289 (char *) "self",(char *) "row", NULL
41290 };
41291
41292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41294 if (SWIG_arg_fail(1)) SWIG_fail;
41295 {
41296 arg2 = (int)(SWIG_As_int(obj1));
41297 if (SWIG_arg_fail(2)) SWIG_fail;
41298 }
41299 {
41300 PyThreadState* __tstate = wxPyBeginAllowThreads();
41301 (arg1)->SetRow(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_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41314 PyObject *resultobj;
41315 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41316 int arg2 ;
41317 PyObject * obj0 = 0 ;
41318 PyObject * obj1 = 0 ;
41319 char *kwnames[] = {
41320 (char *) "self",(char *) "col", NULL
41321 };
41322
41323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41325 if (SWIG_arg_fail(1)) SWIG_fail;
41326 {
41327 arg2 = (int)(SWIG_As_int(obj1));
41328 if (SWIG_arg_fail(2)) SWIG_fail;
41329 }
41330 {
41331 PyThreadState* __tstate = wxPyBeginAllowThreads();
41332 (arg1)->SetCol(arg2);
41333
41334 wxPyEndAllowThreads(__tstate);
41335 if (PyErr_Occurred()) SWIG_fail;
41336 }
41337 Py_INCREF(Py_None); resultobj = Py_None;
41338 return resultobj;
41339 fail:
41340 return NULL;
41341 }
41342
41343
41344 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41345 PyObject *resultobj;
41346 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41347 wxGBPosition *arg2 = 0 ;
41348 bool result;
41349 wxGBPosition temp2 ;
41350 PyObject * obj0 = 0 ;
41351 PyObject * obj1 = 0 ;
41352 char *kwnames[] = {
41353 (char *) "self",(char *) "other", NULL
41354 };
41355
41356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41358 if (SWIG_arg_fail(1)) SWIG_fail;
41359 {
41360 arg2 = &temp2;
41361 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41362 }
41363 {
41364 PyThreadState* __tstate = wxPyBeginAllowThreads();
41365 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41366
41367 wxPyEndAllowThreads(__tstate);
41368 if (PyErr_Occurred()) SWIG_fail;
41369 }
41370 {
41371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41372 }
41373 return resultobj;
41374 fail:
41375 return NULL;
41376 }
41377
41378
41379 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41380 PyObject *resultobj;
41381 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41382 wxGBPosition *arg2 = 0 ;
41383 bool result;
41384 wxGBPosition temp2 ;
41385 PyObject * obj0 = 0 ;
41386 PyObject * obj1 = 0 ;
41387 char *kwnames[] = {
41388 (char *) "self",(char *) "other", NULL
41389 };
41390
41391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41393 if (SWIG_arg_fail(1)) SWIG_fail;
41394 {
41395 arg2 = &temp2;
41396 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41397 }
41398 {
41399 PyThreadState* __tstate = wxPyBeginAllowThreads();
41400 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41401
41402 wxPyEndAllowThreads(__tstate);
41403 if (PyErr_Occurred()) SWIG_fail;
41404 }
41405 {
41406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41407 }
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj;
41416 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41417 int arg2 = (int) 0 ;
41418 int arg3 = (int) 0 ;
41419 PyObject * obj0 = 0 ;
41420 PyObject * obj1 = 0 ;
41421 PyObject * obj2 = 0 ;
41422 char *kwnames[] = {
41423 (char *) "self",(char *) "row",(char *) "col", NULL
41424 };
41425
41426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41428 if (SWIG_arg_fail(1)) SWIG_fail;
41429 if (obj1) {
41430 {
41431 arg2 = (int)(SWIG_As_int(obj1));
41432 if (SWIG_arg_fail(2)) SWIG_fail;
41433 }
41434 }
41435 if (obj2) {
41436 {
41437 arg3 = (int)(SWIG_As_int(obj2));
41438 if (SWIG_arg_fail(3)) SWIG_fail;
41439 }
41440 }
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 wxGBPosition_Set(arg1,arg2,arg3);
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 Py_INCREF(Py_None); resultobj = Py_None;
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj;
41457 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41458 PyObject *result;
41459 PyObject * obj0 = 0 ;
41460 char *kwnames[] = {
41461 (char *) "self", NULL
41462 };
41463
41464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41466 if (SWIG_arg_fail(1)) SWIG_fail;
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (PyObject *)wxGBPosition_Get(arg1);
41470
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 resultobj = result;
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41482 PyObject *obj;
41483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41484 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41485 Py_INCREF(obj);
41486 return Py_BuildValue((char *)"");
41487 }
41488 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj;
41490 int arg1 = (int) 1 ;
41491 int arg2 = (int) 1 ;
41492 wxGBSpan *result;
41493 PyObject * obj0 = 0 ;
41494 PyObject * obj1 = 0 ;
41495 char *kwnames[] = {
41496 (char *) "rowspan",(char *) "colspan", NULL
41497 };
41498
41499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41500 if (obj0) {
41501 {
41502 arg1 = (int)(SWIG_As_int(obj0));
41503 if (SWIG_arg_fail(1)) SWIG_fail;
41504 }
41505 }
41506 if (obj1) {
41507 {
41508 arg2 = (int)(SWIG_As_int(obj1));
41509 if (SWIG_arg_fail(2)) SWIG_fail;
41510 }
41511 }
41512 {
41513 PyThreadState* __tstate = wxPyBeginAllowThreads();
41514 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41515
41516 wxPyEndAllowThreads(__tstate);
41517 if (PyErr_Occurred()) SWIG_fail;
41518 }
41519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41520 return resultobj;
41521 fail:
41522 return NULL;
41523 }
41524
41525
41526 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41527 PyObject *resultobj;
41528 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41529 int result;
41530 PyObject * obj0 = 0 ;
41531 char *kwnames[] = {
41532 (char *) "self", NULL
41533 };
41534
41535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41537 if (SWIG_arg_fail(1)) SWIG_fail;
41538 {
41539 PyThreadState* __tstate = wxPyBeginAllowThreads();
41540 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41541
41542 wxPyEndAllowThreads(__tstate);
41543 if (PyErr_Occurred()) SWIG_fail;
41544 }
41545 {
41546 resultobj = SWIG_From_int((int)(result));
41547 }
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41555 PyObject *resultobj;
41556 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41557 int result;
41558 PyObject * obj0 = 0 ;
41559 char *kwnames[] = {
41560 (char *) "self", NULL
41561 };
41562
41563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41565 if (SWIG_arg_fail(1)) SWIG_fail;
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41569
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 {
41574 resultobj = SWIG_From_int((int)(result));
41575 }
41576 return resultobj;
41577 fail:
41578 return NULL;
41579 }
41580
41581
41582 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41583 PyObject *resultobj;
41584 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41585 int arg2 ;
41586 PyObject * obj0 = 0 ;
41587 PyObject * obj1 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self",(char *) "rowspan", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 {
41596 arg2 = (int)(SWIG_As_int(obj1));
41597 if (SWIG_arg_fail(2)) SWIG_fail;
41598 }
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 (arg1)->SetRowspan(arg2);
41602
41603 wxPyEndAllowThreads(__tstate);
41604 if (PyErr_Occurred()) SWIG_fail;
41605 }
41606 Py_INCREF(Py_None); resultobj = Py_None;
41607 return resultobj;
41608 fail:
41609 return NULL;
41610 }
41611
41612
41613 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41614 PyObject *resultobj;
41615 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41616 int arg2 ;
41617 PyObject * obj0 = 0 ;
41618 PyObject * obj1 = 0 ;
41619 char *kwnames[] = {
41620 (char *) "self",(char *) "colspan", NULL
41621 };
41622
41623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41625 if (SWIG_arg_fail(1)) SWIG_fail;
41626 {
41627 arg2 = (int)(SWIG_As_int(obj1));
41628 if (SWIG_arg_fail(2)) SWIG_fail;
41629 }
41630 {
41631 PyThreadState* __tstate = wxPyBeginAllowThreads();
41632 (arg1)->SetColspan(arg2);
41633
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 Py_INCREF(Py_None); resultobj = Py_None;
41638 return resultobj;
41639 fail:
41640 return NULL;
41641 }
41642
41643
41644 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41645 PyObject *resultobj;
41646 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41647 wxGBSpan *arg2 = 0 ;
41648 bool result;
41649 wxGBSpan temp2 ;
41650 PyObject * obj0 = 0 ;
41651 PyObject * obj1 = 0 ;
41652 char *kwnames[] = {
41653 (char *) "self",(char *) "other", NULL
41654 };
41655
41656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41658 if (SWIG_arg_fail(1)) SWIG_fail;
41659 {
41660 arg2 = &temp2;
41661 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41662 }
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41666
41667 wxPyEndAllowThreads(__tstate);
41668 if (PyErr_Occurred()) SWIG_fail;
41669 }
41670 {
41671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41672 }
41673 return resultobj;
41674 fail:
41675 return NULL;
41676 }
41677
41678
41679 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41680 PyObject *resultobj;
41681 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41682 wxGBSpan *arg2 = 0 ;
41683 bool result;
41684 wxGBSpan temp2 ;
41685 PyObject * obj0 = 0 ;
41686 PyObject * obj1 = 0 ;
41687 char *kwnames[] = {
41688 (char *) "self",(char *) "other", NULL
41689 };
41690
41691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41693 if (SWIG_arg_fail(1)) SWIG_fail;
41694 {
41695 arg2 = &temp2;
41696 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41697 }
41698 {
41699 PyThreadState* __tstate = wxPyBeginAllowThreads();
41700 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41701
41702 wxPyEndAllowThreads(__tstate);
41703 if (PyErr_Occurred()) SWIG_fail;
41704 }
41705 {
41706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41707 }
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj;
41716 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41717 int arg2 = (int) 1 ;
41718 int arg3 = (int) 1 ;
41719 PyObject * obj0 = 0 ;
41720 PyObject * obj1 = 0 ;
41721 PyObject * obj2 = 0 ;
41722 char *kwnames[] = {
41723 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41724 };
41725
41726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41728 if (SWIG_arg_fail(1)) SWIG_fail;
41729 if (obj1) {
41730 {
41731 arg2 = (int)(SWIG_As_int(obj1));
41732 if (SWIG_arg_fail(2)) SWIG_fail;
41733 }
41734 }
41735 if (obj2) {
41736 {
41737 arg3 = (int)(SWIG_As_int(obj2));
41738 if (SWIG_arg_fail(3)) SWIG_fail;
41739 }
41740 }
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 wxGBSpan_Set(arg1,arg2,arg3);
41744
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 Py_INCREF(Py_None); resultobj = Py_None;
41749 return resultobj;
41750 fail:
41751 return NULL;
41752 }
41753
41754
41755 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41756 PyObject *resultobj;
41757 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41758 PyObject *result;
41759 PyObject * obj0 = 0 ;
41760 char *kwnames[] = {
41761 (char *) "self", NULL
41762 };
41763
41764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41766 if (SWIG_arg_fail(1)) SWIG_fail;
41767 {
41768 PyThreadState* __tstate = wxPyBeginAllowThreads();
41769 result = (PyObject *)wxGBSpan_Get(arg1);
41770
41771 wxPyEndAllowThreads(__tstate);
41772 if (PyErr_Occurred()) SWIG_fail;
41773 }
41774 resultobj = result;
41775 return resultobj;
41776 fail:
41777 return NULL;
41778 }
41779
41780
41781 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41782 PyObject *obj;
41783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41784 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41785 Py_INCREF(obj);
41786 return Py_BuildValue((char *)"");
41787 }
41788 static int _wrap_DefaultSpan_set(PyObject *) {
41789 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41790 return 1;
41791 }
41792
41793
41794 static PyObject *_wrap_DefaultSpan_get(void) {
41795 PyObject *pyobj;
41796
41797 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41798 return pyobj;
41799 }
41800
41801
41802 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41803 PyObject *resultobj;
41804 wxGBSizerItem *result;
41805 char *kwnames[] = {
41806 NULL
41807 };
41808
41809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41810 {
41811 PyThreadState* __tstate = wxPyBeginAllowThreads();
41812 result = (wxGBSizerItem *)new wxGBSizerItem();
41813
41814 wxPyEndAllowThreads(__tstate);
41815 if (PyErr_Occurred()) SWIG_fail;
41816 }
41817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41818 return resultobj;
41819 fail:
41820 return NULL;
41821 }
41822
41823
41824 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41825 PyObject *resultobj;
41826 wxWindow *arg1 = (wxWindow *) 0 ;
41827 wxGBPosition *arg2 = 0 ;
41828 wxGBSpan *arg3 = 0 ;
41829 int arg4 ;
41830 int arg5 ;
41831 PyObject *arg6 = (PyObject *) NULL ;
41832 wxGBSizerItem *result;
41833 wxGBPosition temp2 ;
41834 wxGBSpan temp3 ;
41835 PyObject * obj0 = 0 ;
41836 PyObject * obj1 = 0 ;
41837 PyObject * obj2 = 0 ;
41838 PyObject * obj3 = 0 ;
41839 PyObject * obj4 = 0 ;
41840 PyObject * obj5 = 0 ;
41841 char *kwnames[] = {
41842 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41843 };
41844
41845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41847 if (SWIG_arg_fail(1)) SWIG_fail;
41848 {
41849 arg2 = &temp2;
41850 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41851 }
41852 {
41853 arg3 = &temp3;
41854 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41855 }
41856 {
41857 arg4 = (int)(SWIG_As_int(obj3));
41858 if (SWIG_arg_fail(4)) SWIG_fail;
41859 }
41860 {
41861 arg5 = (int)(SWIG_As_int(obj4));
41862 if (SWIG_arg_fail(5)) SWIG_fail;
41863 }
41864 if (obj5) {
41865 arg6 = obj5;
41866 }
41867 {
41868 PyThreadState* __tstate = wxPyBeginAllowThreads();
41869 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41870
41871 wxPyEndAllowThreads(__tstate);
41872 if (PyErr_Occurred()) SWIG_fail;
41873 }
41874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41875 return resultobj;
41876 fail:
41877 return NULL;
41878 }
41879
41880
41881 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41882 PyObject *resultobj;
41883 wxSizer *arg1 = (wxSizer *) 0 ;
41884 wxGBPosition *arg2 = 0 ;
41885 wxGBSpan *arg3 = 0 ;
41886 int arg4 ;
41887 int arg5 ;
41888 PyObject *arg6 = (PyObject *) NULL ;
41889 wxGBSizerItem *result;
41890 wxGBPosition temp2 ;
41891 wxGBSpan temp3 ;
41892 PyObject * obj0 = 0 ;
41893 PyObject * obj1 = 0 ;
41894 PyObject * obj2 = 0 ;
41895 PyObject * obj3 = 0 ;
41896 PyObject * obj4 = 0 ;
41897 PyObject * obj5 = 0 ;
41898 char *kwnames[] = {
41899 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41900 };
41901
41902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41904 if (SWIG_arg_fail(1)) SWIG_fail;
41905 {
41906 arg2 = &temp2;
41907 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41908 }
41909 {
41910 arg3 = &temp3;
41911 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41912 }
41913 {
41914 arg4 = (int)(SWIG_As_int(obj3));
41915 if (SWIG_arg_fail(4)) SWIG_fail;
41916 }
41917 {
41918 arg5 = (int)(SWIG_As_int(obj4));
41919 if (SWIG_arg_fail(5)) SWIG_fail;
41920 }
41921 if (obj5) {
41922 arg6 = obj5;
41923 }
41924 {
41925 PyThreadState* __tstate = wxPyBeginAllowThreads();
41926 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41927
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj;
41940 int arg1 ;
41941 int arg2 ;
41942 wxGBPosition *arg3 = 0 ;
41943 wxGBSpan *arg4 = 0 ;
41944 int arg5 ;
41945 int arg6 ;
41946 PyObject *arg7 = (PyObject *) NULL ;
41947 wxGBSizerItem *result;
41948 wxGBPosition temp3 ;
41949 wxGBSpan temp4 ;
41950 PyObject * obj0 = 0 ;
41951 PyObject * obj1 = 0 ;
41952 PyObject * obj2 = 0 ;
41953 PyObject * obj3 = 0 ;
41954 PyObject * obj4 = 0 ;
41955 PyObject * obj5 = 0 ;
41956 PyObject * obj6 = 0 ;
41957 char *kwnames[] = {
41958 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41959 };
41960
41961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41962 {
41963 arg1 = (int)(SWIG_As_int(obj0));
41964 if (SWIG_arg_fail(1)) SWIG_fail;
41965 }
41966 {
41967 arg2 = (int)(SWIG_As_int(obj1));
41968 if (SWIG_arg_fail(2)) SWIG_fail;
41969 }
41970 {
41971 arg3 = &temp3;
41972 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41973 }
41974 {
41975 arg4 = &temp4;
41976 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41977 }
41978 {
41979 arg5 = (int)(SWIG_As_int(obj4));
41980 if (SWIG_arg_fail(5)) SWIG_fail;
41981 }
41982 {
41983 arg6 = (int)(SWIG_As_int(obj5));
41984 if (SWIG_arg_fail(6)) SWIG_fail;
41985 }
41986 if (obj6) {
41987 arg7 = obj6;
41988 }
41989 {
41990 PyThreadState* __tstate = wxPyBeginAllowThreads();
41991 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41992
41993 wxPyEndAllowThreads(__tstate);
41994 if (PyErr_Occurred()) SWIG_fail;
41995 }
41996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41997 return resultobj;
41998 fail:
41999 return NULL;
42000 }
42001
42002
42003 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42004 PyObject *resultobj;
42005 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42006 wxGBPosition result;
42007 PyObject * obj0 = 0 ;
42008 char *kwnames[] = {
42009 (char *) "self", NULL
42010 };
42011
42012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42014 if (SWIG_arg_fail(1)) SWIG_fail;
42015 {
42016 PyThreadState* __tstate = wxPyBeginAllowThreads();
42017 result = ((wxGBSizerItem const *)arg1)->GetPos();
42018
42019 wxPyEndAllowThreads(__tstate);
42020 if (PyErr_Occurred()) SWIG_fail;
42021 }
42022 {
42023 wxGBPosition * resultptr;
42024 resultptr = new wxGBPosition((wxGBPosition &)(result));
42025 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42026 }
42027 return resultobj;
42028 fail:
42029 return NULL;
42030 }
42031
42032
42033 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42034 PyObject *resultobj;
42035 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42036 wxGBSpan result;
42037 PyObject * obj0 = 0 ;
42038 char *kwnames[] = {
42039 (char *) "self", NULL
42040 };
42041
42042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42044 if (SWIG_arg_fail(1)) SWIG_fail;
42045 {
42046 PyThreadState* __tstate = wxPyBeginAllowThreads();
42047 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42048
42049 wxPyEndAllowThreads(__tstate);
42050 if (PyErr_Occurred()) SWIG_fail;
42051 }
42052 {
42053 wxGBSpan * resultptr;
42054 resultptr = new wxGBSpan((wxGBSpan &)(result));
42055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42056 }
42057 return resultobj;
42058 fail:
42059 return NULL;
42060 }
42061
42062
42063 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42064 PyObject *resultobj;
42065 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42066 wxGBPosition *arg2 = 0 ;
42067 bool result;
42068 wxGBPosition temp2 ;
42069 PyObject * obj0 = 0 ;
42070 PyObject * obj1 = 0 ;
42071 char *kwnames[] = {
42072 (char *) "self",(char *) "pos", NULL
42073 };
42074
42075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42077 if (SWIG_arg_fail(1)) SWIG_fail;
42078 {
42079 arg2 = &temp2;
42080 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42081 }
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (bool)(arg1)->SetPos((wxGBPosition 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_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj;
42100 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42101 wxGBSpan *arg2 = 0 ;
42102 bool result;
42103 wxGBSpan temp2 ;
42104 PyObject * obj0 = 0 ;
42105 PyObject * obj1 = 0 ;
42106 char *kwnames[] = {
42107 (char *) "self",(char *) "span", NULL
42108 };
42109
42110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42112 if (SWIG_arg_fail(1)) SWIG_fail;
42113 {
42114 arg2 = &temp2;
42115 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42116 }
42117 {
42118 PyThreadState* __tstate = wxPyBeginAllowThreads();
42119 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42120
42121 wxPyEndAllowThreads(__tstate);
42122 if (PyErr_Occurred()) SWIG_fail;
42123 }
42124 {
42125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42126 }
42127 return resultobj;
42128 fail:
42129 return NULL;
42130 }
42131
42132
42133 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42134 PyObject *resultobj;
42135 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42136 wxGBSizerItem *arg2 = 0 ;
42137 bool result;
42138 PyObject * obj0 = 0 ;
42139 PyObject * obj1 = 0 ;
42140 char *kwnames[] = {
42141 (char *) "self",(char *) "other", NULL
42142 };
42143
42144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42146 if (SWIG_arg_fail(1)) SWIG_fail;
42147 {
42148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42149 if (SWIG_arg_fail(2)) SWIG_fail;
42150 if (arg2 == NULL) {
42151 SWIG_null_ref("wxGBSizerItem");
42152 }
42153 if (SWIG_arg_fail(2)) SWIG_fail;
42154 }
42155 {
42156 PyThreadState* __tstate = wxPyBeginAllowThreads();
42157 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42158
42159 wxPyEndAllowThreads(__tstate);
42160 if (PyErr_Occurred()) SWIG_fail;
42161 }
42162 {
42163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42164 }
42165 return resultobj;
42166 fail:
42167 return NULL;
42168 }
42169
42170
42171 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42172 PyObject *resultobj;
42173 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42174 wxGBPosition *arg2 = 0 ;
42175 wxGBSpan *arg3 = 0 ;
42176 bool result;
42177 wxGBPosition temp2 ;
42178 wxGBSpan temp3 ;
42179 PyObject * obj0 = 0 ;
42180 PyObject * obj1 = 0 ;
42181 PyObject * obj2 = 0 ;
42182 char *kwnames[] = {
42183 (char *) "self",(char *) "pos",(char *) "span", NULL
42184 };
42185
42186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42188 if (SWIG_arg_fail(1)) SWIG_fail;
42189 {
42190 arg2 = &temp2;
42191 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42192 }
42193 {
42194 arg3 = &temp3;
42195 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42196 }
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42200
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 {
42205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42206 }
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj;
42215 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42216 wxGBPosition result;
42217 PyObject * obj0 = 0 ;
42218 char *kwnames[] = {
42219 (char *) "self", NULL
42220 };
42221
42222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42224 if (SWIG_arg_fail(1)) SWIG_fail;
42225 {
42226 PyThreadState* __tstate = wxPyBeginAllowThreads();
42227 result = wxGBSizerItem_GetEndPos(arg1);
42228
42229 wxPyEndAllowThreads(__tstate);
42230 if (PyErr_Occurred()) SWIG_fail;
42231 }
42232 {
42233 wxGBPosition * resultptr;
42234 resultptr = new wxGBPosition((wxGBPosition &)(result));
42235 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42236 }
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42244 PyObject *resultobj;
42245 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42246 wxGridBagSizer *result;
42247 PyObject * obj0 = 0 ;
42248 char *kwnames[] = {
42249 (char *) "self", NULL
42250 };
42251
42252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42254 if (SWIG_arg_fail(1)) SWIG_fail;
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42258
42259 wxPyEndAllowThreads(__tstate);
42260 if (PyErr_Occurred()) SWIG_fail;
42261 }
42262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42270 PyObject *resultobj;
42271 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42272 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42273 PyObject * obj0 = 0 ;
42274 PyObject * obj1 = 0 ;
42275 char *kwnames[] = {
42276 (char *) "self",(char *) "sizer", NULL
42277 };
42278
42279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42281 if (SWIG_arg_fail(1)) SWIG_fail;
42282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42283 if (SWIG_arg_fail(2)) SWIG_fail;
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 (arg1)->SetGBSizer(arg2);
42287
42288 wxPyEndAllowThreads(__tstate);
42289 if (PyErr_Occurred()) SWIG_fail;
42290 }
42291 Py_INCREF(Py_None); resultobj = Py_None;
42292 return resultobj;
42293 fail:
42294 return NULL;
42295 }
42296
42297
42298 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42299 PyObject *obj;
42300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42301 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42302 Py_INCREF(obj);
42303 return Py_BuildValue((char *)"");
42304 }
42305 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42306 PyObject *resultobj;
42307 int arg1 = (int) 0 ;
42308 int arg2 = (int) 0 ;
42309 wxGridBagSizer *result;
42310 PyObject * obj0 = 0 ;
42311 PyObject * obj1 = 0 ;
42312 char *kwnames[] = {
42313 (char *) "vgap",(char *) "hgap", NULL
42314 };
42315
42316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42317 if (obj0) {
42318 {
42319 arg1 = (int)(SWIG_As_int(obj0));
42320 if (SWIG_arg_fail(1)) SWIG_fail;
42321 }
42322 }
42323 if (obj1) {
42324 {
42325 arg2 = (int)(SWIG_As_int(obj1));
42326 if (SWIG_arg_fail(2)) SWIG_fail;
42327 }
42328 }
42329 {
42330 PyThreadState* __tstate = wxPyBeginAllowThreads();
42331 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42332
42333 wxPyEndAllowThreads(__tstate);
42334 if (PyErr_Occurred()) SWIG_fail;
42335 }
42336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42337 return resultobj;
42338 fail:
42339 return NULL;
42340 }
42341
42342
42343 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42344 PyObject *resultobj;
42345 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42346 PyObject *arg2 = (PyObject *) 0 ;
42347 wxGBPosition *arg3 = 0 ;
42348 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42349 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42350 int arg5 = (int) 0 ;
42351 int arg6 = (int) 0 ;
42352 PyObject *arg7 = (PyObject *) NULL ;
42353 wxGBSizerItem *result;
42354 wxGBPosition temp3 ;
42355 wxGBSpan temp4 ;
42356 PyObject * obj0 = 0 ;
42357 PyObject * obj1 = 0 ;
42358 PyObject * obj2 = 0 ;
42359 PyObject * obj3 = 0 ;
42360 PyObject * obj4 = 0 ;
42361 PyObject * obj5 = 0 ;
42362 PyObject * obj6 = 0 ;
42363 char *kwnames[] = {
42364 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42365 };
42366
42367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42369 if (SWIG_arg_fail(1)) SWIG_fail;
42370 arg2 = obj1;
42371 {
42372 arg3 = &temp3;
42373 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42374 }
42375 if (obj3) {
42376 {
42377 arg4 = &temp4;
42378 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42379 }
42380 }
42381 if (obj4) {
42382 {
42383 arg5 = (int)(SWIG_As_int(obj4));
42384 if (SWIG_arg_fail(5)) SWIG_fail;
42385 }
42386 }
42387 if (obj5) {
42388 {
42389 arg6 = (int)(SWIG_As_int(obj5));
42390 if (SWIG_arg_fail(6)) SWIG_fail;
42391 }
42392 }
42393 if (obj6) {
42394 arg7 = obj6;
42395 }
42396 {
42397 PyThreadState* __tstate = wxPyBeginAllowThreads();
42398 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42399
42400 wxPyEndAllowThreads(__tstate);
42401 if (PyErr_Occurred()) SWIG_fail;
42402 }
42403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42404 return resultobj;
42405 fail:
42406 return NULL;
42407 }
42408
42409
42410 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42411 PyObject *resultobj;
42412 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42413 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42414 wxGBSizerItem *result;
42415 PyObject * obj0 = 0 ;
42416 PyObject * obj1 = 0 ;
42417 char *kwnames[] = {
42418 (char *) "self",(char *) "item", NULL
42419 };
42420
42421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42423 if (SWIG_arg_fail(1)) SWIG_fail;
42424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42425 if (SWIG_arg_fail(2)) SWIG_fail;
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42429
42430 wxPyEndAllowThreads(__tstate);
42431 if (PyErr_Occurred()) SWIG_fail;
42432 }
42433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42434 return resultobj;
42435 fail:
42436 return NULL;
42437 }
42438
42439
42440 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42441 PyObject *resultobj;
42442 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42443 int arg2 ;
42444 int arg3 ;
42445 wxSize result;
42446 PyObject * obj0 = 0 ;
42447 PyObject * obj1 = 0 ;
42448 PyObject * obj2 = 0 ;
42449 char *kwnames[] = {
42450 (char *) "self",(char *) "row",(char *) "col", NULL
42451 };
42452
42453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42455 if (SWIG_arg_fail(1)) SWIG_fail;
42456 {
42457 arg2 = (int)(SWIG_As_int(obj1));
42458 if (SWIG_arg_fail(2)) SWIG_fail;
42459 }
42460 {
42461 arg3 = (int)(SWIG_As_int(obj2));
42462 if (SWIG_arg_fail(3)) SWIG_fail;
42463 }
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42467
42468 wxPyEndAllowThreads(__tstate);
42469 if (PyErr_Occurred()) SWIG_fail;
42470 }
42471 {
42472 wxSize * resultptr;
42473 resultptr = new wxSize((wxSize &)(result));
42474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42475 }
42476 return resultobj;
42477 fail:
42478 return NULL;
42479 }
42480
42481
42482 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42483 PyObject *resultobj;
42484 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42485 wxSize result;
42486 PyObject * obj0 = 0 ;
42487 char *kwnames[] = {
42488 (char *) "self", NULL
42489 };
42490
42491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42493 if (SWIG_arg_fail(1)) SWIG_fail;
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42497
42498 wxPyEndAllowThreads(__tstate);
42499 if (PyErr_Occurred()) SWIG_fail;
42500 }
42501 {
42502 wxSize * resultptr;
42503 resultptr = new wxSize((wxSize &)(result));
42504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42505 }
42506 return resultobj;
42507 fail:
42508 return NULL;
42509 }
42510
42511
42512 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42513 PyObject *resultobj;
42514 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42515 wxSize *arg2 = 0 ;
42516 wxSize temp2 ;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519 char *kwnames[] = {
42520 (char *) "self",(char *) "sz", NULL
42521 };
42522
42523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42525 if (SWIG_arg_fail(1)) SWIG_fail;
42526 {
42527 arg2 = &temp2;
42528 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42529 }
42530 {
42531 PyThreadState* __tstate = wxPyBeginAllowThreads();
42532 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42533
42534 wxPyEndAllowThreads(__tstate);
42535 if (PyErr_Occurred()) SWIG_fail;
42536 }
42537 Py_INCREF(Py_None); resultobj = Py_None;
42538 return resultobj;
42539 fail:
42540 return NULL;
42541 }
42542
42543
42544 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42545 PyObject *resultobj;
42546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42547 wxWindow *arg2 = (wxWindow *) 0 ;
42548 wxGBPosition result;
42549 PyObject * obj0 = 0 ;
42550 PyObject * obj1 = 0 ;
42551
42552 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42554 if (SWIG_arg_fail(1)) SWIG_fail;
42555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42556 if (SWIG_arg_fail(2)) SWIG_fail;
42557 {
42558 PyThreadState* __tstate = wxPyBeginAllowThreads();
42559 result = (arg1)->GetItemPosition(arg2);
42560
42561 wxPyEndAllowThreads(__tstate);
42562 if (PyErr_Occurred()) SWIG_fail;
42563 }
42564 {
42565 wxGBPosition * resultptr;
42566 resultptr = new wxGBPosition((wxGBPosition &)(result));
42567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42568 }
42569 return resultobj;
42570 fail:
42571 return NULL;
42572 }
42573
42574
42575 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42576 PyObject *resultobj;
42577 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42578 wxSizer *arg2 = (wxSizer *) 0 ;
42579 wxGBPosition result;
42580 PyObject * obj0 = 0 ;
42581 PyObject * obj1 = 0 ;
42582
42583 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42585 if (SWIG_arg_fail(1)) SWIG_fail;
42586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42587 if (SWIG_arg_fail(2)) SWIG_fail;
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 result = (arg1)->GetItemPosition(arg2);
42591
42592 wxPyEndAllowThreads(__tstate);
42593 if (PyErr_Occurred()) SWIG_fail;
42594 }
42595 {
42596 wxGBPosition * resultptr;
42597 resultptr = new wxGBPosition((wxGBPosition &)(result));
42598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42599 }
42600 return resultobj;
42601 fail:
42602 return NULL;
42603 }
42604
42605
42606 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42607 PyObject *resultobj;
42608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42609 size_t arg2 ;
42610 wxGBPosition result;
42611 PyObject * obj0 = 0 ;
42612 PyObject * obj1 = 0 ;
42613
42614 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42616 if (SWIG_arg_fail(1)) SWIG_fail;
42617 {
42618 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42619 if (SWIG_arg_fail(2)) SWIG_fail;
42620 }
42621 {
42622 PyThreadState* __tstate = wxPyBeginAllowThreads();
42623 result = (arg1)->GetItemPosition(arg2);
42624
42625 wxPyEndAllowThreads(__tstate);
42626 if (PyErr_Occurred()) SWIG_fail;
42627 }
42628 {
42629 wxGBPosition * resultptr;
42630 resultptr = new wxGBPosition((wxGBPosition &)(result));
42631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42632 }
42633 return resultobj;
42634 fail:
42635 return NULL;
42636 }
42637
42638
42639 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42640 int argc;
42641 PyObject *argv[3];
42642 int ii;
42643
42644 argc = PyObject_Length(args);
42645 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42646 argv[ii] = PyTuple_GetItem(args,ii);
42647 }
42648 if (argc == 2) {
42649 int _v;
42650 {
42651 void *ptr;
42652 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42653 _v = 0;
42654 PyErr_Clear();
42655 } else {
42656 _v = 1;
42657 }
42658 }
42659 if (_v) {
42660 {
42661 void *ptr;
42662 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42663 _v = 0;
42664 PyErr_Clear();
42665 } else {
42666 _v = 1;
42667 }
42668 }
42669 if (_v) {
42670 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42671 }
42672 }
42673 }
42674 if (argc == 2) {
42675 int _v;
42676 {
42677 void *ptr;
42678 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42679 _v = 0;
42680 PyErr_Clear();
42681 } else {
42682 _v = 1;
42683 }
42684 }
42685 if (_v) {
42686 {
42687 void *ptr;
42688 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42689 _v = 0;
42690 PyErr_Clear();
42691 } else {
42692 _v = 1;
42693 }
42694 }
42695 if (_v) {
42696 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42697 }
42698 }
42699 }
42700 if (argc == 2) {
42701 int _v;
42702 {
42703 void *ptr;
42704 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42705 _v = 0;
42706 PyErr_Clear();
42707 } else {
42708 _v = 1;
42709 }
42710 }
42711 if (_v) {
42712 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42713 if (_v) {
42714 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42715 }
42716 }
42717 }
42718
42719 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42720 return NULL;
42721 }
42722
42723
42724 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42725 PyObject *resultobj;
42726 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42727 wxWindow *arg2 = (wxWindow *) 0 ;
42728 wxGBPosition *arg3 = 0 ;
42729 bool result;
42730 wxGBPosition temp3 ;
42731 PyObject * obj0 = 0 ;
42732 PyObject * obj1 = 0 ;
42733 PyObject * obj2 = 0 ;
42734
42735 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42737 if (SWIG_arg_fail(1)) SWIG_fail;
42738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42739 if (SWIG_arg_fail(2)) SWIG_fail;
42740 {
42741 arg3 = &temp3;
42742 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42743 }
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42747
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 {
42752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42753 }
42754 return resultobj;
42755 fail:
42756 return NULL;
42757 }
42758
42759
42760 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42761 PyObject *resultobj;
42762 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42763 wxSizer *arg2 = (wxSizer *) 0 ;
42764 wxGBPosition *arg3 = 0 ;
42765 bool result;
42766 wxGBPosition temp3 ;
42767 PyObject * obj0 = 0 ;
42768 PyObject * obj1 = 0 ;
42769 PyObject * obj2 = 0 ;
42770
42771 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42773 if (SWIG_arg_fail(1)) SWIG_fail;
42774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42775 if (SWIG_arg_fail(2)) SWIG_fail;
42776 {
42777 arg3 = &temp3;
42778 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42779 }
42780 {
42781 PyThreadState* __tstate = wxPyBeginAllowThreads();
42782 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42783
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 {
42788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42789 }
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42797 PyObject *resultobj;
42798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42799 size_t arg2 ;
42800 wxGBPosition *arg3 = 0 ;
42801 bool result;
42802 wxGBPosition temp3 ;
42803 PyObject * obj0 = 0 ;
42804 PyObject * obj1 = 0 ;
42805 PyObject * obj2 = 0 ;
42806
42807 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42809 if (SWIG_arg_fail(1)) SWIG_fail;
42810 {
42811 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42812 if (SWIG_arg_fail(2)) SWIG_fail;
42813 }
42814 {
42815 arg3 = &temp3;
42816 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42817 }
42818 {
42819 PyThreadState* __tstate = wxPyBeginAllowThreads();
42820 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42821
42822 wxPyEndAllowThreads(__tstate);
42823 if (PyErr_Occurred()) SWIG_fail;
42824 }
42825 {
42826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42827 }
42828 return resultobj;
42829 fail:
42830 return NULL;
42831 }
42832
42833
42834 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42835 int argc;
42836 PyObject *argv[4];
42837 int ii;
42838
42839 argc = PyObject_Length(args);
42840 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42841 argv[ii] = PyTuple_GetItem(args,ii);
42842 }
42843 if (argc == 3) {
42844 int _v;
42845 {
42846 void *ptr;
42847 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42848 _v = 0;
42849 PyErr_Clear();
42850 } else {
42851 _v = 1;
42852 }
42853 }
42854 if (_v) {
42855 {
42856 void *ptr;
42857 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42858 _v = 0;
42859 PyErr_Clear();
42860 } else {
42861 _v = 1;
42862 }
42863 }
42864 if (_v) {
42865 {
42866 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42867 }
42868 if (_v) {
42869 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42870 }
42871 }
42872 }
42873 }
42874 if (argc == 3) {
42875 int _v;
42876 {
42877 void *ptr;
42878 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42879 _v = 0;
42880 PyErr_Clear();
42881 } else {
42882 _v = 1;
42883 }
42884 }
42885 if (_v) {
42886 {
42887 void *ptr;
42888 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42889 _v = 0;
42890 PyErr_Clear();
42891 } else {
42892 _v = 1;
42893 }
42894 }
42895 if (_v) {
42896 {
42897 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42898 }
42899 if (_v) {
42900 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42901 }
42902 }
42903 }
42904 }
42905 if (argc == 3) {
42906 int _v;
42907 {
42908 void *ptr;
42909 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42910 _v = 0;
42911 PyErr_Clear();
42912 } else {
42913 _v = 1;
42914 }
42915 }
42916 if (_v) {
42917 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42918 if (_v) {
42919 {
42920 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42921 }
42922 if (_v) {
42923 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42924 }
42925 }
42926 }
42927 }
42928
42929 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42930 return NULL;
42931 }
42932
42933
42934 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42935 PyObject *resultobj;
42936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42937 wxWindow *arg2 = (wxWindow *) 0 ;
42938 wxGBSpan result;
42939 PyObject * obj0 = 0 ;
42940 PyObject * obj1 = 0 ;
42941
42942 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42944 if (SWIG_arg_fail(1)) SWIG_fail;
42945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42946 if (SWIG_arg_fail(2)) SWIG_fail;
42947 {
42948 PyThreadState* __tstate = wxPyBeginAllowThreads();
42949 result = (arg1)->GetItemSpan(arg2);
42950
42951 wxPyEndAllowThreads(__tstate);
42952 if (PyErr_Occurred()) SWIG_fail;
42953 }
42954 {
42955 wxGBSpan * resultptr;
42956 resultptr = new wxGBSpan((wxGBSpan &)(result));
42957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42958 }
42959 return resultobj;
42960 fail:
42961 return NULL;
42962 }
42963
42964
42965 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42966 PyObject *resultobj;
42967 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42968 wxSizer *arg2 = (wxSizer *) 0 ;
42969 wxGBSpan result;
42970 PyObject * obj0 = 0 ;
42971 PyObject * obj1 = 0 ;
42972
42973 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42975 if (SWIG_arg_fail(1)) SWIG_fail;
42976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42977 if (SWIG_arg_fail(2)) SWIG_fail;
42978 {
42979 PyThreadState* __tstate = wxPyBeginAllowThreads();
42980 result = (arg1)->GetItemSpan(arg2);
42981
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 {
42986 wxGBSpan * resultptr;
42987 resultptr = new wxGBSpan((wxGBSpan &)(result));
42988 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42989 }
42990 return resultobj;
42991 fail:
42992 return NULL;
42993 }
42994
42995
42996 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42997 PyObject *resultobj;
42998 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42999 size_t arg2 ;
43000 wxGBSpan result;
43001 PyObject * obj0 = 0 ;
43002 PyObject * obj1 = 0 ;
43003
43004 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43006 if (SWIG_arg_fail(1)) SWIG_fail;
43007 {
43008 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43009 if (SWIG_arg_fail(2)) SWIG_fail;
43010 }
43011 {
43012 PyThreadState* __tstate = wxPyBeginAllowThreads();
43013 result = (arg1)->GetItemSpan(arg2);
43014
43015 wxPyEndAllowThreads(__tstate);
43016 if (PyErr_Occurred()) SWIG_fail;
43017 }
43018 {
43019 wxGBSpan * resultptr;
43020 resultptr = new wxGBSpan((wxGBSpan &)(result));
43021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43022 }
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43030 int argc;
43031 PyObject *argv[3];
43032 int ii;
43033
43034 argc = PyObject_Length(args);
43035 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43036 argv[ii] = PyTuple_GetItem(args,ii);
43037 }
43038 if (argc == 2) {
43039 int _v;
43040 {
43041 void *ptr;
43042 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43043 _v = 0;
43044 PyErr_Clear();
43045 } else {
43046 _v = 1;
43047 }
43048 }
43049 if (_v) {
43050 {
43051 void *ptr;
43052 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43053 _v = 0;
43054 PyErr_Clear();
43055 } else {
43056 _v = 1;
43057 }
43058 }
43059 if (_v) {
43060 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43061 }
43062 }
43063 }
43064 if (argc == 2) {
43065 int _v;
43066 {
43067 void *ptr;
43068 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43069 _v = 0;
43070 PyErr_Clear();
43071 } else {
43072 _v = 1;
43073 }
43074 }
43075 if (_v) {
43076 {
43077 void *ptr;
43078 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43079 _v = 0;
43080 PyErr_Clear();
43081 } else {
43082 _v = 1;
43083 }
43084 }
43085 if (_v) {
43086 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43087 }
43088 }
43089 }
43090 if (argc == 2) {
43091 int _v;
43092 {
43093 void *ptr;
43094 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43095 _v = 0;
43096 PyErr_Clear();
43097 } else {
43098 _v = 1;
43099 }
43100 }
43101 if (_v) {
43102 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43103 if (_v) {
43104 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43105 }
43106 }
43107 }
43108
43109 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43110 return NULL;
43111 }
43112
43113
43114 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43115 PyObject *resultobj;
43116 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43117 wxWindow *arg2 = (wxWindow *) 0 ;
43118 wxGBSpan *arg3 = 0 ;
43119 bool result;
43120 wxGBSpan temp3 ;
43121 PyObject * obj0 = 0 ;
43122 PyObject * obj1 = 0 ;
43123 PyObject * obj2 = 0 ;
43124
43125 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43127 if (SWIG_arg_fail(1)) SWIG_fail;
43128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43129 if (SWIG_arg_fail(2)) SWIG_fail;
43130 {
43131 arg3 = &temp3;
43132 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43133 }
43134 {
43135 PyThreadState* __tstate = wxPyBeginAllowThreads();
43136 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43137
43138 wxPyEndAllowThreads(__tstate);
43139 if (PyErr_Occurred()) SWIG_fail;
43140 }
43141 {
43142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43143 }
43144 return resultobj;
43145 fail:
43146 return NULL;
43147 }
43148
43149
43150 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43151 PyObject *resultobj;
43152 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43153 wxSizer *arg2 = (wxSizer *) 0 ;
43154 wxGBSpan *arg3 = 0 ;
43155 bool result;
43156 wxGBSpan temp3 ;
43157 PyObject * obj0 = 0 ;
43158 PyObject * obj1 = 0 ;
43159 PyObject * obj2 = 0 ;
43160
43161 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43163 if (SWIG_arg_fail(1)) SWIG_fail;
43164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43165 if (SWIG_arg_fail(2)) SWIG_fail;
43166 {
43167 arg3 = &temp3;
43168 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43169 }
43170 {
43171 PyThreadState* __tstate = wxPyBeginAllowThreads();
43172 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43173
43174 wxPyEndAllowThreads(__tstate);
43175 if (PyErr_Occurred()) SWIG_fail;
43176 }
43177 {
43178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43179 }
43180 return resultobj;
43181 fail:
43182 return NULL;
43183 }
43184
43185
43186 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43187 PyObject *resultobj;
43188 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43189 size_t arg2 ;
43190 wxGBSpan *arg3 = 0 ;
43191 bool result;
43192 wxGBSpan temp3 ;
43193 PyObject * obj0 = 0 ;
43194 PyObject * obj1 = 0 ;
43195 PyObject * obj2 = 0 ;
43196
43197 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43199 if (SWIG_arg_fail(1)) SWIG_fail;
43200 {
43201 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43202 if (SWIG_arg_fail(2)) SWIG_fail;
43203 }
43204 {
43205 arg3 = &temp3;
43206 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43207 }
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43211
43212 wxPyEndAllowThreads(__tstate);
43213 if (PyErr_Occurred()) SWIG_fail;
43214 }
43215 {
43216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43217 }
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43225 int argc;
43226 PyObject *argv[4];
43227 int ii;
43228
43229 argc = PyObject_Length(args);
43230 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43231 argv[ii] = PyTuple_GetItem(args,ii);
43232 }
43233 if (argc == 3) {
43234 int _v;
43235 {
43236 void *ptr;
43237 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43238 _v = 0;
43239 PyErr_Clear();
43240 } else {
43241 _v = 1;
43242 }
43243 }
43244 if (_v) {
43245 {
43246 void *ptr;
43247 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43248 _v = 0;
43249 PyErr_Clear();
43250 } else {
43251 _v = 1;
43252 }
43253 }
43254 if (_v) {
43255 {
43256 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43257 }
43258 if (_v) {
43259 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43260 }
43261 }
43262 }
43263 }
43264 if (argc == 3) {
43265 int _v;
43266 {
43267 void *ptr;
43268 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43269 _v = 0;
43270 PyErr_Clear();
43271 } else {
43272 _v = 1;
43273 }
43274 }
43275 if (_v) {
43276 {
43277 void *ptr;
43278 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43279 _v = 0;
43280 PyErr_Clear();
43281 } else {
43282 _v = 1;
43283 }
43284 }
43285 if (_v) {
43286 {
43287 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43288 }
43289 if (_v) {
43290 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43291 }
43292 }
43293 }
43294 }
43295 if (argc == 3) {
43296 int _v;
43297 {
43298 void *ptr;
43299 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43300 _v = 0;
43301 PyErr_Clear();
43302 } else {
43303 _v = 1;
43304 }
43305 }
43306 if (_v) {
43307 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43308 if (_v) {
43309 {
43310 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43311 }
43312 if (_v) {
43313 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43314 }
43315 }
43316 }
43317 }
43318
43319 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43320 return NULL;
43321 }
43322
43323
43324 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43325 PyObject *resultobj;
43326 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43327 wxWindow *arg2 = (wxWindow *) 0 ;
43328 wxGBSizerItem *result;
43329 PyObject * obj0 = 0 ;
43330 PyObject * obj1 = 0 ;
43331
43332 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43334 if (SWIG_arg_fail(1)) SWIG_fail;
43335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43336 if (SWIG_arg_fail(2)) SWIG_fail;
43337 {
43338 PyThreadState* __tstate = wxPyBeginAllowThreads();
43339 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43340
43341 wxPyEndAllowThreads(__tstate);
43342 if (PyErr_Occurred()) SWIG_fail;
43343 }
43344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43345 return resultobj;
43346 fail:
43347 return NULL;
43348 }
43349
43350
43351 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43352 PyObject *resultobj;
43353 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43354 wxSizer *arg2 = (wxSizer *) 0 ;
43355 wxGBSizerItem *result;
43356 PyObject * obj0 = 0 ;
43357 PyObject * obj1 = 0 ;
43358
43359 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43361 if (SWIG_arg_fail(1)) SWIG_fail;
43362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43363 if (SWIG_arg_fail(2)) SWIG_fail;
43364 {
43365 PyThreadState* __tstate = wxPyBeginAllowThreads();
43366 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43367
43368 wxPyEndAllowThreads(__tstate);
43369 if (PyErr_Occurred()) SWIG_fail;
43370 }
43371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43372 return resultobj;
43373 fail:
43374 return NULL;
43375 }
43376
43377
43378 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43379 int argc;
43380 PyObject *argv[3];
43381 int ii;
43382
43383 argc = PyObject_Length(args);
43384 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43385 argv[ii] = PyTuple_GetItem(args,ii);
43386 }
43387 if (argc == 2) {
43388 int _v;
43389 {
43390 void *ptr;
43391 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43392 _v = 0;
43393 PyErr_Clear();
43394 } else {
43395 _v = 1;
43396 }
43397 }
43398 if (_v) {
43399 {
43400 void *ptr;
43401 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43402 _v = 0;
43403 PyErr_Clear();
43404 } else {
43405 _v = 1;
43406 }
43407 }
43408 if (_v) {
43409 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43410 }
43411 }
43412 }
43413 if (argc == 2) {
43414 int _v;
43415 {
43416 void *ptr;
43417 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43418 _v = 0;
43419 PyErr_Clear();
43420 } else {
43421 _v = 1;
43422 }
43423 }
43424 if (_v) {
43425 {
43426 void *ptr;
43427 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43428 _v = 0;
43429 PyErr_Clear();
43430 } else {
43431 _v = 1;
43432 }
43433 }
43434 if (_v) {
43435 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43436 }
43437 }
43438 }
43439
43440 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43441 return NULL;
43442 }
43443
43444
43445 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43446 PyObject *resultobj;
43447 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43448 wxGBPosition *arg2 = 0 ;
43449 wxGBSizerItem *result;
43450 wxGBPosition temp2 ;
43451 PyObject * obj0 = 0 ;
43452 PyObject * obj1 = 0 ;
43453 char *kwnames[] = {
43454 (char *) "self",(char *) "pos", NULL
43455 };
43456
43457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43459 if (SWIG_arg_fail(1)) SWIG_fail;
43460 {
43461 arg2 = &temp2;
43462 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43463 }
43464 {
43465 PyThreadState* __tstate = wxPyBeginAllowThreads();
43466 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43467
43468 wxPyEndAllowThreads(__tstate);
43469 if (PyErr_Occurred()) SWIG_fail;
43470 }
43471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43472 return resultobj;
43473 fail:
43474 return NULL;
43475 }
43476
43477
43478 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43479 PyObject *resultobj;
43480 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43481 wxPoint *arg2 = 0 ;
43482 wxGBSizerItem *result;
43483 wxPoint temp2 ;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486 char *kwnames[] = {
43487 (char *) "self",(char *) "pt", NULL
43488 };
43489
43490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43492 if (SWIG_arg_fail(1)) SWIG_fail;
43493 {
43494 arg2 = &temp2;
43495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43496 }
43497 {
43498 PyThreadState* __tstate = wxPyBeginAllowThreads();
43499 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43500
43501 wxPyEndAllowThreads(__tstate);
43502 if (PyErr_Occurred()) SWIG_fail;
43503 }
43504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43505 return resultobj;
43506 fail:
43507 return NULL;
43508 }
43509
43510
43511 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43512 PyObject *resultobj;
43513 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43514 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43515 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43516 bool result;
43517 PyObject * obj0 = 0 ;
43518 PyObject * obj1 = 0 ;
43519 PyObject * obj2 = 0 ;
43520 char *kwnames[] = {
43521 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43522 };
43523
43524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43526 if (SWIG_arg_fail(1)) SWIG_fail;
43527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43528 if (SWIG_arg_fail(2)) SWIG_fail;
43529 if (obj2) {
43530 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43531 if (SWIG_arg_fail(3)) SWIG_fail;
43532 }
43533 {
43534 PyThreadState* __tstate = wxPyBeginAllowThreads();
43535 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43536
43537 wxPyEndAllowThreads(__tstate);
43538 if (PyErr_Occurred()) SWIG_fail;
43539 }
43540 {
43541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43542 }
43543 return resultobj;
43544 fail:
43545 return NULL;
43546 }
43547
43548
43549 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43550 PyObject *resultobj;
43551 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43552 wxGBPosition *arg2 = 0 ;
43553 wxGBSpan *arg3 = 0 ;
43554 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43555 bool result;
43556 wxGBPosition temp2 ;
43557 wxGBSpan temp3 ;
43558 PyObject * obj0 = 0 ;
43559 PyObject * obj1 = 0 ;
43560 PyObject * obj2 = 0 ;
43561 PyObject * obj3 = 0 ;
43562 char *kwnames[] = {
43563 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43564 };
43565
43566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43568 if (SWIG_arg_fail(1)) SWIG_fail;
43569 {
43570 arg2 = &temp2;
43571 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43572 }
43573 {
43574 arg3 = &temp3;
43575 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43576 }
43577 if (obj3) {
43578 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43579 if (SWIG_arg_fail(4)) SWIG_fail;
43580 }
43581 {
43582 PyThreadState* __tstate = wxPyBeginAllowThreads();
43583 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43584
43585 wxPyEndAllowThreads(__tstate);
43586 if (PyErr_Occurred()) SWIG_fail;
43587 }
43588 {
43589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43590 }
43591 return resultobj;
43592 fail:
43593 return NULL;
43594 }
43595
43596
43597 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43598 PyObject *obj;
43599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43600 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43601 Py_INCREF(obj);
43602 return Py_BuildValue((char *)"");
43603 }
43604 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43605 PyObject *resultobj;
43606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43607 wxRelationship arg2 ;
43608 wxWindow *arg3 = (wxWindow *) 0 ;
43609 wxEdge arg4 ;
43610 int arg5 = (int) 0 ;
43611 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43612 PyObject * obj0 = 0 ;
43613 PyObject * obj1 = 0 ;
43614 PyObject * obj2 = 0 ;
43615 PyObject * obj3 = 0 ;
43616 PyObject * obj4 = 0 ;
43617 PyObject * obj5 = 0 ;
43618 char *kwnames[] = {
43619 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43620 };
43621
43622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43624 if (SWIG_arg_fail(1)) SWIG_fail;
43625 {
43626 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43627 if (SWIG_arg_fail(2)) SWIG_fail;
43628 }
43629 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43630 if (SWIG_arg_fail(3)) SWIG_fail;
43631 {
43632 arg4 = (wxEdge)(SWIG_As_int(obj3));
43633 if (SWIG_arg_fail(4)) SWIG_fail;
43634 }
43635 if (obj4) {
43636 {
43637 arg5 = (int)(SWIG_As_int(obj4));
43638 if (SWIG_arg_fail(5)) SWIG_fail;
43639 }
43640 }
43641 if (obj5) {
43642 {
43643 arg6 = (int)(SWIG_As_int(obj5));
43644 if (SWIG_arg_fail(6)) SWIG_fail;
43645 }
43646 }
43647 {
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43650
43651 wxPyEndAllowThreads(__tstate);
43652 if (PyErr_Occurred()) SWIG_fail;
43653 }
43654 Py_INCREF(Py_None); resultobj = Py_None;
43655 return resultobj;
43656 fail:
43657 return NULL;
43658 }
43659
43660
43661 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43662 PyObject *resultobj;
43663 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43664 wxWindow *arg2 = (wxWindow *) 0 ;
43665 int arg3 = (int) 0 ;
43666 PyObject * obj0 = 0 ;
43667 PyObject * obj1 = 0 ;
43668 PyObject * obj2 = 0 ;
43669 char *kwnames[] = {
43670 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43671 };
43672
43673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43675 if (SWIG_arg_fail(1)) SWIG_fail;
43676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43677 if (SWIG_arg_fail(2)) SWIG_fail;
43678 if (obj2) {
43679 {
43680 arg3 = (int)(SWIG_As_int(obj2));
43681 if (SWIG_arg_fail(3)) SWIG_fail;
43682 }
43683 }
43684 {
43685 PyThreadState* __tstate = wxPyBeginAllowThreads();
43686 (arg1)->LeftOf(arg2,arg3);
43687
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 Py_INCREF(Py_None); resultobj = Py_None;
43692 return resultobj;
43693 fail:
43694 return NULL;
43695 }
43696
43697
43698 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43699 PyObject *resultobj;
43700 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43701 wxWindow *arg2 = (wxWindow *) 0 ;
43702 int arg3 = (int) 0 ;
43703 PyObject * obj0 = 0 ;
43704 PyObject * obj1 = 0 ;
43705 PyObject * obj2 = 0 ;
43706 char *kwnames[] = {
43707 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43708 };
43709
43710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43712 if (SWIG_arg_fail(1)) SWIG_fail;
43713 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43714 if (SWIG_arg_fail(2)) SWIG_fail;
43715 if (obj2) {
43716 {
43717 arg3 = (int)(SWIG_As_int(obj2));
43718 if (SWIG_arg_fail(3)) SWIG_fail;
43719 }
43720 }
43721 {
43722 PyThreadState* __tstate = wxPyBeginAllowThreads();
43723 (arg1)->RightOf(arg2,arg3);
43724
43725 wxPyEndAllowThreads(__tstate);
43726 if (PyErr_Occurred()) SWIG_fail;
43727 }
43728 Py_INCREF(Py_None); resultobj = Py_None;
43729 return resultobj;
43730 fail:
43731 return NULL;
43732 }
43733
43734
43735 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43736 PyObject *resultobj;
43737 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43738 wxWindow *arg2 = (wxWindow *) 0 ;
43739 int arg3 = (int) 0 ;
43740 PyObject * obj0 = 0 ;
43741 PyObject * obj1 = 0 ;
43742 PyObject * obj2 = 0 ;
43743 char *kwnames[] = {
43744 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43745 };
43746
43747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43749 if (SWIG_arg_fail(1)) SWIG_fail;
43750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43751 if (SWIG_arg_fail(2)) SWIG_fail;
43752 if (obj2) {
43753 {
43754 arg3 = (int)(SWIG_As_int(obj2));
43755 if (SWIG_arg_fail(3)) SWIG_fail;
43756 }
43757 }
43758 {
43759 PyThreadState* __tstate = wxPyBeginAllowThreads();
43760 (arg1)->Above(arg2,arg3);
43761
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 Py_INCREF(Py_None); resultobj = Py_None;
43766 return resultobj;
43767 fail:
43768 return NULL;
43769 }
43770
43771
43772 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43773 PyObject *resultobj;
43774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43775 wxWindow *arg2 = (wxWindow *) 0 ;
43776 int arg3 = (int) 0 ;
43777 PyObject * obj0 = 0 ;
43778 PyObject * obj1 = 0 ;
43779 PyObject * obj2 = 0 ;
43780 char *kwnames[] = {
43781 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43782 };
43783
43784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43786 if (SWIG_arg_fail(1)) SWIG_fail;
43787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43788 if (SWIG_arg_fail(2)) SWIG_fail;
43789 if (obj2) {
43790 {
43791 arg3 = (int)(SWIG_As_int(obj2));
43792 if (SWIG_arg_fail(3)) SWIG_fail;
43793 }
43794 }
43795 {
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 (arg1)->Below(arg2,arg3);
43798
43799 wxPyEndAllowThreads(__tstate);
43800 if (PyErr_Occurred()) SWIG_fail;
43801 }
43802 Py_INCREF(Py_None); resultobj = Py_None;
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43810 PyObject *resultobj;
43811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43812 wxWindow *arg2 = (wxWindow *) 0 ;
43813 wxEdge arg3 ;
43814 int arg4 = (int) 0 ;
43815 PyObject * obj0 = 0 ;
43816 PyObject * obj1 = 0 ;
43817 PyObject * obj2 = 0 ;
43818 PyObject * obj3 = 0 ;
43819 char *kwnames[] = {
43820 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43821 };
43822
43823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43825 if (SWIG_arg_fail(1)) SWIG_fail;
43826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43827 if (SWIG_arg_fail(2)) SWIG_fail;
43828 {
43829 arg3 = (wxEdge)(SWIG_As_int(obj2));
43830 if (SWIG_arg_fail(3)) SWIG_fail;
43831 }
43832 if (obj3) {
43833 {
43834 arg4 = (int)(SWIG_As_int(obj3));
43835 if (SWIG_arg_fail(4)) SWIG_fail;
43836 }
43837 }
43838 {
43839 PyThreadState* __tstate = wxPyBeginAllowThreads();
43840 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43841
43842 wxPyEndAllowThreads(__tstate);
43843 if (PyErr_Occurred()) SWIG_fail;
43844 }
43845 Py_INCREF(Py_None); resultobj = Py_None;
43846 return resultobj;
43847 fail:
43848 return NULL;
43849 }
43850
43851
43852 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43853 PyObject *resultobj;
43854 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43855 wxWindow *arg2 = (wxWindow *) 0 ;
43856 wxEdge arg3 ;
43857 int arg4 ;
43858 PyObject * obj0 = 0 ;
43859 PyObject * obj1 = 0 ;
43860 PyObject * obj2 = 0 ;
43861 PyObject * obj3 = 0 ;
43862 char *kwnames[] = {
43863 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43864 };
43865
43866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43868 if (SWIG_arg_fail(1)) SWIG_fail;
43869 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43870 if (SWIG_arg_fail(2)) SWIG_fail;
43871 {
43872 arg3 = (wxEdge)(SWIG_As_int(obj2));
43873 if (SWIG_arg_fail(3)) SWIG_fail;
43874 }
43875 {
43876 arg4 = (int)(SWIG_As_int(obj3));
43877 if (SWIG_arg_fail(4)) SWIG_fail;
43878 }
43879 {
43880 PyThreadState* __tstate = wxPyBeginAllowThreads();
43881 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43882
43883 wxPyEndAllowThreads(__tstate);
43884 if (PyErr_Occurred()) SWIG_fail;
43885 }
43886 Py_INCREF(Py_None); resultobj = Py_None;
43887 return resultobj;
43888 fail:
43889 return NULL;
43890 }
43891
43892
43893 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43894 PyObject *resultobj;
43895 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43896 int arg2 ;
43897 PyObject * obj0 = 0 ;
43898 PyObject * obj1 = 0 ;
43899 char *kwnames[] = {
43900 (char *) "self",(char *) "val", NULL
43901 };
43902
43903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43905 if (SWIG_arg_fail(1)) SWIG_fail;
43906 {
43907 arg2 = (int)(SWIG_As_int(obj1));
43908 if (SWIG_arg_fail(2)) SWIG_fail;
43909 }
43910 {
43911 PyThreadState* __tstate = wxPyBeginAllowThreads();
43912 (arg1)->Absolute(arg2);
43913
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 Py_INCREF(Py_None); resultobj = Py_None;
43918 return resultobj;
43919 fail:
43920 return NULL;
43921 }
43922
43923
43924 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43925 PyObject *resultobj;
43926 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43927 PyObject * obj0 = 0 ;
43928 char *kwnames[] = {
43929 (char *) "self", NULL
43930 };
43931
43932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43934 if (SWIG_arg_fail(1)) SWIG_fail;
43935 {
43936 PyThreadState* __tstate = wxPyBeginAllowThreads();
43937 (arg1)->Unconstrained();
43938
43939 wxPyEndAllowThreads(__tstate);
43940 if (PyErr_Occurred()) SWIG_fail;
43941 }
43942 Py_INCREF(Py_None); resultobj = Py_None;
43943 return resultobj;
43944 fail:
43945 return NULL;
43946 }
43947
43948
43949 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43950 PyObject *resultobj;
43951 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43952 PyObject * obj0 = 0 ;
43953 char *kwnames[] = {
43954 (char *) "self", NULL
43955 };
43956
43957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43959 if (SWIG_arg_fail(1)) SWIG_fail;
43960 {
43961 PyThreadState* __tstate = wxPyBeginAllowThreads();
43962 (arg1)->AsIs();
43963
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 Py_INCREF(Py_None); resultobj = Py_None;
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj;
43976 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43977 wxWindow *result;
43978 PyObject * obj0 = 0 ;
43979 char *kwnames[] = {
43980 (char *) "self", NULL
43981 };
43982
43983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43985 if (SWIG_arg_fail(1)) SWIG_fail;
43986 {
43987 PyThreadState* __tstate = wxPyBeginAllowThreads();
43988 result = (wxWindow *)(arg1)->GetOtherWindow();
43989
43990 wxPyEndAllowThreads(__tstate);
43991 if (PyErr_Occurred()) SWIG_fail;
43992 }
43993 {
43994 resultobj = wxPyMake_wxObject(result, 0);
43995 }
43996 return resultobj;
43997 fail:
43998 return NULL;
43999 }
44000
44001
44002 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44003 PyObject *resultobj;
44004 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44005 wxEdge result;
44006 PyObject * obj0 = 0 ;
44007 char *kwnames[] = {
44008 (char *) "self", NULL
44009 };
44010
44011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44013 if (SWIG_arg_fail(1)) SWIG_fail;
44014 {
44015 PyThreadState* __tstate = wxPyBeginAllowThreads();
44016 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44017
44018 wxPyEndAllowThreads(__tstate);
44019 if (PyErr_Occurred()) SWIG_fail;
44020 }
44021 resultobj = SWIG_From_int((result));
44022 return resultobj;
44023 fail:
44024 return NULL;
44025 }
44026
44027
44028 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44029 PyObject *resultobj;
44030 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44031 wxEdge arg2 ;
44032 PyObject * obj0 = 0 ;
44033 PyObject * obj1 = 0 ;
44034 char *kwnames[] = {
44035 (char *) "self",(char *) "which", NULL
44036 };
44037
44038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44040 if (SWIG_arg_fail(1)) SWIG_fail;
44041 {
44042 arg2 = (wxEdge)(SWIG_As_int(obj1));
44043 if (SWIG_arg_fail(2)) SWIG_fail;
44044 }
44045 {
44046 PyThreadState* __tstate = wxPyBeginAllowThreads();
44047 (arg1)->SetEdge((wxEdge )arg2);
44048
44049 wxPyEndAllowThreads(__tstate);
44050 if (PyErr_Occurred()) SWIG_fail;
44051 }
44052 Py_INCREF(Py_None); resultobj = Py_None;
44053 return resultobj;
44054 fail:
44055 return NULL;
44056 }
44057
44058
44059 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44060 PyObject *resultobj;
44061 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44062 int arg2 ;
44063 PyObject * obj0 = 0 ;
44064 PyObject * obj1 = 0 ;
44065 char *kwnames[] = {
44066 (char *) "self",(char *) "v", NULL
44067 };
44068
44069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44071 if (SWIG_arg_fail(1)) SWIG_fail;
44072 {
44073 arg2 = (int)(SWIG_As_int(obj1));
44074 if (SWIG_arg_fail(2)) SWIG_fail;
44075 }
44076 {
44077 PyThreadState* __tstate = wxPyBeginAllowThreads();
44078 (arg1)->SetValue(arg2);
44079
44080 wxPyEndAllowThreads(__tstate);
44081 if (PyErr_Occurred()) SWIG_fail;
44082 }
44083 Py_INCREF(Py_None); resultobj = Py_None;
44084 return resultobj;
44085 fail:
44086 return NULL;
44087 }
44088
44089
44090 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44091 PyObject *resultobj;
44092 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44093 int result;
44094 PyObject * obj0 = 0 ;
44095 char *kwnames[] = {
44096 (char *) "self", NULL
44097 };
44098
44099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44101 if (SWIG_arg_fail(1)) SWIG_fail;
44102 {
44103 PyThreadState* __tstate = wxPyBeginAllowThreads();
44104 result = (int)(arg1)->GetMargin();
44105
44106 wxPyEndAllowThreads(__tstate);
44107 if (PyErr_Occurred()) SWIG_fail;
44108 }
44109 {
44110 resultobj = SWIG_From_int((int)(result));
44111 }
44112 return resultobj;
44113 fail:
44114 return NULL;
44115 }
44116
44117
44118 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44119 PyObject *resultobj;
44120 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44121 int arg2 ;
44122 PyObject * obj0 = 0 ;
44123 PyObject * obj1 = 0 ;
44124 char *kwnames[] = {
44125 (char *) "self",(char *) "m", NULL
44126 };
44127
44128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44130 if (SWIG_arg_fail(1)) SWIG_fail;
44131 {
44132 arg2 = (int)(SWIG_As_int(obj1));
44133 if (SWIG_arg_fail(2)) SWIG_fail;
44134 }
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 (arg1)->SetMargin(arg2);
44138
44139 wxPyEndAllowThreads(__tstate);
44140 if (PyErr_Occurred()) SWIG_fail;
44141 }
44142 Py_INCREF(Py_None); resultobj = Py_None;
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44150 PyObject *resultobj;
44151 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44152 int result;
44153 PyObject * obj0 = 0 ;
44154 char *kwnames[] = {
44155 (char *) "self", NULL
44156 };
44157
44158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44160 if (SWIG_arg_fail(1)) SWIG_fail;
44161 {
44162 PyThreadState* __tstate = wxPyBeginAllowThreads();
44163 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44164
44165 wxPyEndAllowThreads(__tstate);
44166 if (PyErr_Occurred()) SWIG_fail;
44167 }
44168 {
44169 resultobj = SWIG_From_int((int)(result));
44170 }
44171 return resultobj;
44172 fail:
44173 return NULL;
44174 }
44175
44176
44177 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44178 PyObject *resultobj;
44179 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44180 int result;
44181 PyObject * obj0 = 0 ;
44182 char *kwnames[] = {
44183 (char *) "self", NULL
44184 };
44185
44186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44188 if (SWIG_arg_fail(1)) SWIG_fail;
44189 {
44190 PyThreadState* __tstate = wxPyBeginAllowThreads();
44191 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44192
44193 wxPyEndAllowThreads(__tstate);
44194 if (PyErr_Occurred()) SWIG_fail;
44195 }
44196 {
44197 resultobj = SWIG_From_int((int)(result));
44198 }
44199 return resultobj;
44200 fail:
44201 return NULL;
44202 }
44203
44204
44205 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44206 PyObject *resultobj;
44207 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44208 int result;
44209 PyObject * obj0 = 0 ;
44210 char *kwnames[] = {
44211 (char *) "self", NULL
44212 };
44213
44214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44216 if (SWIG_arg_fail(1)) SWIG_fail;
44217 {
44218 PyThreadState* __tstate = wxPyBeginAllowThreads();
44219 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44220
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 {
44225 resultobj = SWIG_From_int((int)(result));
44226 }
44227 return resultobj;
44228 fail:
44229 return NULL;
44230 }
44231
44232
44233 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44234 PyObject *resultobj;
44235 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44236 bool result;
44237 PyObject * obj0 = 0 ;
44238 char *kwnames[] = {
44239 (char *) "self", NULL
44240 };
44241
44242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44244 if (SWIG_arg_fail(1)) SWIG_fail;
44245 {
44246 PyThreadState* __tstate = wxPyBeginAllowThreads();
44247 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44248
44249 wxPyEndAllowThreads(__tstate);
44250 if (PyErr_Occurred()) SWIG_fail;
44251 }
44252 {
44253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44254 }
44255 return resultobj;
44256 fail:
44257 return NULL;
44258 }
44259
44260
44261 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44262 PyObject *resultobj;
44263 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44264 bool arg2 ;
44265 PyObject * obj0 = 0 ;
44266 PyObject * obj1 = 0 ;
44267 char *kwnames[] = {
44268 (char *) "self",(char *) "d", NULL
44269 };
44270
44271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44273 if (SWIG_arg_fail(1)) SWIG_fail;
44274 {
44275 arg2 = (bool)(SWIG_As_bool(obj1));
44276 if (SWIG_arg_fail(2)) SWIG_fail;
44277 }
44278 {
44279 PyThreadState* __tstate = wxPyBeginAllowThreads();
44280 (arg1)->SetDone(arg2);
44281
44282 wxPyEndAllowThreads(__tstate);
44283 if (PyErr_Occurred()) SWIG_fail;
44284 }
44285 Py_INCREF(Py_None); resultobj = Py_None;
44286 return resultobj;
44287 fail:
44288 return NULL;
44289 }
44290
44291
44292 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44293 PyObject *resultobj;
44294 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44295 wxRelationship result;
44296 PyObject * obj0 = 0 ;
44297 char *kwnames[] = {
44298 (char *) "self", NULL
44299 };
44300
44301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44303 if (SWIG_arg_fail(1)) SWIG_fail;
44304 {
44305 PyThreadState* __tstate = wxPyBeginAllowThreads();
44306 result = (wxRelationship)(arg1)->GetRelationship();
44307
44308 wxPyEndAllowThreads(__tstate);
44309 if (PyErr_Occurred()) SWIG_fail;
44310 }
44311 resultobj = SWIG_From_int((result));
44312 return resultobj;
44313 fail:
44314 return NULL;
44315 }
44316
44317
44318 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44319 PyObject *resultobj;
44320 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44321 wxRelationship arg2 ;
44322 PyObject * obj0 = 0 ;
44323 PyObject * obj1 = 0 ;
44324 char *kwnames[] = {
44325 (char *) "self",(char *) "r", NULL
44326 };
44327
44328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44330 if (SWIG_arg_fail(1)) SWIG_fail;
44331 {
44332 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44333 if (SWIG_arg_fail(2)) SWIG_fail;
44334 }
44335 {
44336 PyThreadState* __tstate = wxPyBeginAllowThreads();
44337 (arg1)->SetRelationship((wxRelationship )arg2);
44338
44339 wxPyEndAllowThreads(__tstate);
44340 if (PyErr_Occurred()) SWIG_fail;
44341 }
44342 Py_INCREF(Py_None); resultobj = Py_None;
44343 return resultobj;
44344 fail:
44345 return NULL;
44346 }
44347
44348
44349 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44350 PyObject *resultobj;
44351 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44352 wxWindow *arg2 = (wxWindow *) 0 ;
44353 bool result;
44354 PyObject * obj0 = 0 ;
44355 PyObject * obj1 = 0 ;
44356 char *kwnames[] = {
44357 (char *) "self",(char *) "otherW", NULL
44358 };
44359
44360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44362 if (SWIG_arg_fail(1)) SWIG_fail;
44363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44364 if (SWIG_arg_fail(2)) SWIG_fail;
44365 {
44366 PyThreadState* __tstate = wxPyBeginAllowThreads();
44367 result = (bool)(arg1)->ResetIfWin(arg2);
44368
44369 wxPyEndAllowThreads(__tstate);
44370 if (PyErr_Occurred()) SWIG_fail;
44371 }
44372 {
44373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44374 }
44375 return resultobj;
44376 fail:
44377 return NULL;
44378 }
44379
44380
44381 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44382 PyObject *resultobj;
44383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44384 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44385 wxWindow *arg3 = (wxWindow *) 0 ;
44386 bool result;
44387 PyObject * obj0 = 0 ;
44388 PyObject * obj1 = 0 ;
44389 PyObject * obj2 = 0 ;
44390 char *kwnames[] = {
44391 (char *) "self",(char *) "constraints",(char *) "win", NULL
44392 };
44393
44394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44396 if (SWIG_arg_fail(1)) SWIG_fail;
44397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44398 if (SWIG_arg_fail(2)) SWIG_fail;
44399 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44400 if (SWIG_arg_fail(3)) SWIG_fail;
44401 {
44402 PyThreadState* __tstate = wxPyBeginAllowThreads();
44403 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44404
44405 wxPyEndAllowThreads(__tstate);
44406 if (PyErr_Occurred()) SWIG_fail;
44407 }
44408 {
44409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44410 }
44411 return resultobj;
44412 fail:
44413 return NULL;
44414 }
44415
44416
44417 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44418 PyObject *resultobj;
44419 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44420 wxEdge arg2 ;
44421 wxWindow *arg3 = (wxWindow *) 0 ;
44422 wxWindow *arg4 = (wxWindow *) 0 ;
44423 int result;
44424 PyObject * obj0 = 0 ;
44425 PyObject * obj1 = 0 ;
44426 PyObject * obj2 = 0 ;
44427 PyObject * obj3 = 0 ;
44428 char *kwnames[] = {
44429 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44430 };
44431
44432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44434 if (SWIG_arg_fail(1)) SWIG_fail;
44435 {
44436 arg2 = (wxEdge)(SWIG_As_int(obj1));
44437 if (SWIG_arg_fail(2)) SWIG_fail;
44438 }
44439 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44440 if (SWIG_arg_fail(3)) SWIG_fail;
44441 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44442 if (SWIG_arg_fail(4)) SWIG_fail;
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44446
44447 wxPyEndAllowThreads(__tstate);
44448 if (PyErr_Occurred()) SWIG_fail;
44449 }
44450 {
44451 resultobj = SWIG_From_int((int)(result));
44452 }
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44460 PyObject *obj;
44461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44462 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44463 Py_INCREF(obj);
44464 return Py_BuildValue((char *)"");
44465 }
44466 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44467 PyObject *resultobj;
44468 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44469 wxIndividualLayoutConstraint *result;
44470 PyObject * obj0 = 0 ;
44471 char *kwnames[] = {
44472 (char *) "self", NULL
44473 };
44474
44475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44477 if (SWIG_arg_fail(1)) SWIG_fail;
44478 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44479
44480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44481 return resultobj;
44482 fail:
44483 return NULL;
44484 }
44485
44486
44487 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44488 PyObject *resultobj;
44489 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44490 wxIndividualLayoutConstraint *result;
44491 PyObject * obj0 = 0 ;
44492 char *kwnames[] = {
44493 (char *) "self", NULL
44494 };
44495
44496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44498 if (SWIG_arg_fail(1)) SWIG_fail;
44499 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44500
44501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44502 return resultobj;
44503 fail:
44504 return NULL;
44505 }
44506
44507
44508 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44509 PyObject *resultobj;
44510 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44511 wxIndividualLayoutConstraint *result;
44512 PyObject * obj0 = 0 ;
44513 char *kwnames[] = {
44514 (char *) "self", NULL
44515 };
44516
44517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44519 if (SWIG_arg_fail(1)) SWIG_fail;
44520 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44521
44522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44523 return resultobj;
44524 fail:
44525 return NULL;
44526 }
44527
44528
44529 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44530 PyObject *resultobj;
44531 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44532 wxIndividualLayoutConstraint *result;
44533 PyObject * obj0 = 0 ;
44534 char *kwnames[] = {
44535 (char *) "self", NULL
44536 };
44537
44538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44540 if (SWIG_arg_fail(1)) SWIG_fail;
44541 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44542
44543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj;
44552 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44553 wxIndividualLayoutConstraint *result;
44554 PyObject * obj0 = 0 ;
44555 char *kwnames[] = {
44556 (char *) "self", NULL
44557 };
44558
44559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44561 if (SWIG_arg_fail(1)) SWIG_fail;
44562 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44563
44564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj;
44573 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44574 wxIndividualLayoutConstraint *result;
44575 PyObject * obj0 = 0 ;
44576 char *kwnames[] = {
44577 (char *) "self", NULL
44578 };
44579
44580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44582 if (SWIG_arg_fail(1)) SWIG_fail;
44583 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44584
44585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44586 return resultobj;
44587 fail:
44588 return NULL;
44589 }
44590
44591
44592 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44593 PyObject *resultobj;
44594 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44595 wxIndividualLayoutConstraint *result;
44596 PyObject * obj0 = 0 ;
44597 char *kwnames[] = {
44598 (char *) "self", NULL
44599 };
44600
44601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44603 if (SWIG_arg_fail(1)) SWIG_fail;
44604 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44605
44606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44607 return resultobj;
44608 fail:
44609 return NULL;
44610 }
44611
44612
44613 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44614 PyObject *resultobj;
44615 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44616 wxIndividualLayoutConstraint *result;
44617 PyObject * obj0 = 0 ;
44618 char *kwnames[] = {
44619 (char *) "self", NULL
44620 };
44621
44622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44624 if (SWIG_arg_fail(1)) SWIG_fail;
44625 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44626
44627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44628 return resultobj;
44629 fail:
44630 return NULL;
44631 }
44632
44633
44634 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44635 PyObject *resultobj;
44636 wxLayoutConstraints *result;
44637 char *kwnames[] = {
44638 NULL
44639 };
44640
44641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44642 {
44643 PyThreadState* __tstate = wxPyBeginAllowThreads();
44644 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44645
44646 wxPyEndAllowThreads(__tstate);
44647 if (PyErr_Occurred()) SWIG_fail;
44648 }
44649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44650 return resultobj;
44651 fail:
44652 return NULL;
44653 }
44654
44655
44656 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44657 PyObject *resultobj;
44658 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44659 wxWindow *arg2 = (wxWindow *) 0 ;
44660 int *arg3 = (int *) 0 ;
44661 bool result;
44662 int temp3 ;
44663 int res3 = 0 ;
44664 PyObject * obj0 = 0 ;
44665 PyObject * obj1 = 0 ;
44666 char *kwnames[] = {
44667 (char *) "self",(char *) "win", NULL
44668 };
44669
44670 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44673 if (SWIG_arg_fail(1)) SWIG_fail;
44674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44675 if (SWIG_arg_fail(2)) SWIG_fail;
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44679
44680 wxPyEndAllowThreads(__tstate);
44681 if (PyErr_Occurred()) SWIG_fail;
44682 }
44683 {
44684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44685 }
44686 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44687 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44688 return resultobj;
44689 fail:
44690 return NULL;
44691 }
44692
44693
44694 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44695 PyObject *resultobj;
44696 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44697 bool result;
44698 PyObject * obj0 = 0 ;
44699 char *kwnames[] = {
44700 (char *) "self", NULL
44701 };
44702
44703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44705 if (SWIG_arg_fail(1)) SWIG_fail;
44706 {
44707 PyThreadState* __tstate = wxPyBeginAllowThreads();
44708 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44709
44710 wxPyEndAllowThreads(__tstate);
44711 if (PyErr_Occurred()) SWIG_fail;
44712 }
44713 {
44714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44715 }
44716 return resultobj;
44717 fail:
44718 return NULL;
44719 }
44720
44721
44722 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44723 PyObject *obj;
44724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44725 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44726 Py_INCREF(obj);
44727 return Py_BuildValue((char *)"");
44728 }
44729 static PyMethodDef SwigMethods[] = {
44730 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44731 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44732 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44735 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44756 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44769 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44784 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44837 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44865 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44884 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44886 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44894 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44895 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44907 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44919 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44923 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44929 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44939 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44949 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44953 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45028 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45030 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45032 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45034 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45036 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45038 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45040 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45042 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45044 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45046 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45048 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45050 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45052 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45066 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45084 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45087 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45090 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45102 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45107 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45113 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45119 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45182 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45189 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45225 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45235 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45241 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45243 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45245 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45248 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45252 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45255 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45258 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45260 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45265 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45273 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45277 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45280 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45282 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45286 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45303 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45305 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45308 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45310 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45314 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45318 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45329 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45332 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45335 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45339 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45346 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45351 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45356 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45360 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45405 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45425 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45432 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45436 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45446 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45616 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45656 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45670 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45673 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45728 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45755 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45799 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45807 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45826 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45827 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45864 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45894 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45897 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45901 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45904 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45914 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45926 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45938 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45948 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45972 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45979 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45980 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45981 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45982 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45983 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45988 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46015 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46027 { NULL, NULL, 0, NULL }
46028 };
46029
46030
46031 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46032
46033 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46034 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46035 }
46036 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46037 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46038 }
46039 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46040 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46041 }
46042 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46043 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46044 }
46045 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46046 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46047 }
46048 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46049 return (void *)((wxSizer *) ((wxGridSizer *) x));
46050 }
46051 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46052 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46053 }
46054 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46055 return (void *)((wxSizer *) ((wxPySizer *) x));
46056 }
46057 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46058 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46059 }
46060 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46061 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46062 }
46063 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46064 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46065 }
46066 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46067 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46068 }
46069 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46070 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46071 }
46072 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46073 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46074 }
46075 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46076 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46077 }
46078 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46079 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46080 }
46081 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46082 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46083 }
46084 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46085 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46086 }
46087 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46088 return (void *)((wxEvent *) ((wxPyEvent *) x));
46089 }
46090 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46091 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46092 }
46093 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46094 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46095 }
46096 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46097 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46098 }
46099 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46100 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46101 }
46102 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46103 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46104 }
46105 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46106 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46107 }
46108 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46109 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46110 }
46111 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46112 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46113 }
46114 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46115 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46116 }
46117 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46118 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46119 }
46120 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46121 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46122 }
46123 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46124 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46125 }
46126 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46128 }
46129 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46130 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46131 }
46132 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46133 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46134 }
46135 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46136 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46137 }
46138 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46139 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46140 }
46141 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46142 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46143 }
46144 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46145 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46146 }
46147 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46148 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46149 }
46150 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46151 return (void *)((wxEvent *) ((wxShowEvent *) x));
46152 }
46153 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46154 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46155 }
46156 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46157 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46158 }
46159 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46160 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46161 }
46162 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46163 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46164 }
46165 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46166 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46167 }
46168 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46169 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46170 }
46171 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46172 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46173 }
46174 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46175 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46176 }
46177 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46178 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46179 }
46180 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46181 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46182 }
46183 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46184 return (void *)((wxControl *) ((wxControlWithItems *) x));
46185 }
46186 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46187 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46188 }
46189 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46190 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46191 }
46192 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46193 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46194 }
46195 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46196 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46197 }
46198 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46199 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46200 }
46201 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46202 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46203 }
46204 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46205 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46206 }
46207 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46208 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46209 }
46210 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46211 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46212 }
46213 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46214 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46215 }
46216 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46217 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46218 }
46219 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46220 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46221 }
46222 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46223 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46224 }
46225 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46226 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46227 }
46228 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46229 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46230 }
46231 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46232 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46233 }
46234 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46235 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46236 }
46237 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46238 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46239 }
46240 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46241 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46242 }
46243 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46244 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46245 }
46246 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46247 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46248 }
46249 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46250 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46251 }
46252 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46253 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46254 }
46255 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46256 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46257 }
46258 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46259 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46260 }
46261 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46262 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46263 }
46264 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46265 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46266 }
46267 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46268 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46269 }
46270 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46271 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46272 }
46273 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46274 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46275 }
46276 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46277 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46278 }
46279 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46280 return (void *)((wxObject *) ((wxSizerItem *) x));
46281 }
46282 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46284 }
46285 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46286 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46287 }
46288 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46289 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46290 }
46291 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46292 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46293 }
46294 static void *_p_wxSizerTo_p_wxObject(void *x) {
46295 return (void *)((wxObject *) ((wxSizer *) x));
46296 }
46297 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46298 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46299 }
46300 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46301 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46302 }
46303 static void *_p_wxEventTo_p_wxObject(void *x) {
46304 return (void *)((wxObject *) ((wxEvent *) x));
46305 }
46306 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46307 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46308 }
46309 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46310 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46311 }
46312 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46313 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46314 }
46315 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46316 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46317 }
46318 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46319 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46320 }
46321 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46322 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46323 }
46324 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46325 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46326 }
46327 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46328 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46329 }
46330 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46331 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46332 }
46333 static void *_p_wxControlTo_p_wxObject(void *x) {
46334 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46335 }
46336 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46337 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46338 }
46339 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46340 return (void *)((wxObject *) ((wxFSFile *) x));
46341 }
46342 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46343 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46344 }
46345 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46346 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46347 }
46348 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46349 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46350 }
46351 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46352 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46353 }
46354 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46355 return (void *)((wxObject *) ((wxMenuItem *) x));
46356 }
46357 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46358 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46359 }
46360 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46361 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46362 }
46363 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46364 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46365 }
46366 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46367 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46368 }
46369 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46370 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46371 }
46372 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46373 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46374 }
46375 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46376 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46377 }
46378 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46379 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46380 }
46381 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46382 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46383 }
46384 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46385 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46386 }
46387 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46388 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46389 }
46390 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46391 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46392 }
46393 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46394 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46395 }
46396 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46397 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46398 }
46399 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46400 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46401 }
46402 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46403 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46404 }
46405 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46406 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46407 }
46408 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46409 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46410 }
46411 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46412 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46413 }
46414 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46415 return (void *)((wxObject *) ((wxImageHandler *) x));
46416 }
46417 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46418 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46419 }
46420 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46421 return (void *)((wxObject *) ((wxEvtHandler *) x));
46422 }
46423 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46424 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46425 }
46426 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46427 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46428 }
46429 static void *_p_wxImageTo_p_wxObject(void *x) {
46430 return (void *)((wxObject *) ((wxImage *) x));
46431 }
46432 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46433 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46434 }
46435 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46436 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46437 }
46438 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46439 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46440 }
46441 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46442 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46443 }
46444 static void *_p_wxWindowTo_p_wxObject(void *x) {
46445 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46446 }
46447 static void *_p_wxMenuTo_p_wxObject(void *x) {
46448 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46449 }
46450 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46451 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46452 }
46453 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46454 return (void *)((wxObject *) ((wxFileSystem *) x));
46455 }
46456 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46457 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46458 }
46459 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46460 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46461 }
46462 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46463 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46464 }
46465 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46466 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46467 }
46468 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46469 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46470 }
46471 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46472 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46473 }
46474 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46475 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46476 }
46477 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46478 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46479 }
46480 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46481 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46482 }
46483 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46484 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46485 }
46486 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46487 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46488 }
46489 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46490 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46491 }
46492 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46493 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46494 }
46495 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46496 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46497 }
46498 static void *_p_wxControlTo_p_wxWindow(void *x) {
46499 return (void *)((wxWindow *) ((wxControl *) x));
46500 }
46501 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46502 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46503 }
46504 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46505 return (void *)((wxWindow *) ((wxMenuBar *) x));
46506 }
46507 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46508 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46509 }
46510 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46511 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46512 }
46513 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46514 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46515 }
46516 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46517 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46518 }
46519 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46520 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46521 }
46522 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46523 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46524 }
46525 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46526 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46527 }
46528 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46529 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46530 }
46531 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46532 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46533 }
46534 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46535 return (void *)((wxValidator *) ((wxPyValidator *) x));
46536 }
46537 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}};
46538 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}};
46539 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}};
46540 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}};
46541 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}};
46542 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}};
46543 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}};
46544 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}};
46545 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}};
46546 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}};
46547 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}};
46548 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}};
46549 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}};
46550 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}};
46551 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}};
46552 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}};
46553 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}};
46554 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}};
46555 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}};
46556 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}};
46557 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}};
46558 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}};
46559 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}};
46560 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}};
46561 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}};
46562 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}};
46563 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}};
46564 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}};
46565 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}};
46566 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}};
46567 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}};
46568 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}};
46569 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}};
46570 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}};
46571 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}};
46572 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}};
46573 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}};
46574 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}};
46575 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}};
46576 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}};
46577 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}};
46578 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}};
46579 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}};
46580 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}};
46581 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}};
46582 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}};
46583 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}};
46584 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}};
46585 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}};
46586 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}};
46587 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}};
46588 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}};
46589 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}};
46590 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}};
46591 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}};
46592 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}};
46593 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}};
46594 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}};
46595 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}};
46596 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}};
46597 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}};
46598 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}};
46599 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}};
46600 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}};
46601 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}};
46602 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}};
46603 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}};
46604 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}};
46605 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}};
46606 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}};
46607 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}};
46608 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}};
46609 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}};
46610 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}};
46611 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}};
46612 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}};
46613 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}};
46614 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}};
46615 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}};
46616 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}};
46617 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}};
46618 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}};
46619 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}};
46620 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}};
46621 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}};
46622 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}};
46623 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}};
46624 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}};
46625 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}};
46626 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}};
46627 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}};
46628 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}};
46629 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}};
46630 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}};
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 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}};
46645 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}};
46646 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}};
46647 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}};
46648 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46649 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}};
46650 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}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 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}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 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}};
46663 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}};
46664
46665 static swig_type_info *swig_types_initial[] = {
46666 _swigt__p_wxLayoutConstraints,
46667 _swigt__p_wxRealPoint,
46668 _swigt__p_wxSizerItem,
46669 _swigt__p_wxGBSizerItem,
46670 _swigt__p_wxScrollEvent,
46671 _swigt__p_wxEventLoop,
46672 _swigt__p_wxIndividualLayoutConstraint,
46673 _swigt__p_wxSizer,
46674 _swigt__p_wxBoxSizer,
46675 _swigt__p_wxStaticBoxSizer,
46676 _swigt__p_wxGridBagSizer,
46677 _swigt__p_wxAcceleratorEntry,
46678 _swigt__p_wxUpdateUIEvent,
46679 _swigt__p_wxEvent,
46680 _swigt__p_wxMenu,
46681 _swigt__p_wxGridSizer,
46682 _swigt__p_wxFlexGridSizer,
46683 _swigt__p_wxInitDialogEvent,
46684 _swigt__p_wxItemContainer,
46685 _swigt__p_wxNcPaintEvent,
46686 _swigt__p_wxPaintEvent,
46687 _swigt__p_wxSysColourChangedEvent,
46688 _swigt__p_wxMouseCaptureChangedEvent,
46689 _swigt__p_wxDisplayChangedEvent,
46690 _swigt__p_wxPaletteChangedEvent,
46691 _swigt__p_wxControl,
46692 _swigt__p_wxFont,
46693 _swigt__p_wxMenuBarBase,
46694 _swigt__p_wxSetCursorEvent,
46695 _swigt__p_wxFSFile,
46696 _swigt__p_wxCaret,
46697 _swigt__ptrdiff_t,
46698 _swigt__std__ptrdiff_t,
46699 _swigt__p_wxRegion,
46700 _swigt__p_wxPoint2D,
46701 _swigt__p_int,
46702 _swigt__p_wxSize,
46703 _swigt__p_wxDC,
46704 _swigt__p_wxPySizer,
46705 _swigt__p_wxVisualAttributes,
46706 _swigt__p_wxNotifyEvent,
46707 _swigt__p_wxPyEvent,
46708 _swigt__p_wxPropagationDisabler,
46709 _swigt__p_form_ops_t,
46710 _swigt__p_wxAppTraits,
46711 _swigt__p_wxArrayString,
46712 _swigt__p_wxShowEvent,
46713 _swigt__p_wxToolTip,
46714 _swigt__p_wxMoveEvent,
46715 _swigt__p_wxSizeEvent,
46716 _swigt__p_wxActivateEvent,
46717 _swigt__p_wxIconizeEvent,
46718 _swigt__p_wxMaximizeEvent,
46719 _swigt__p_wxQueryNewPaletteEvent,
46720 _swigt__p_wxWindowCreateEvent,
46721 _swigt__p_wxIdleEvent,
46722 _swigt__p_wxDateEvent,
46723 _swigt__p_wxMenuItem,
46724 _swigt__p_wxStaticBox,
46725 _swigt__p_long,
46726 _swigt__p_wxDuplexMode,
46727 _swigt__p_wxTIFFHandler,
46728 _swigt__p_wxXPMHandler,
46729 _swigt__p_wxPNMHandler,
46730 _swigt__p_wxJPEGHandler,
46731 _swigt__p_wxPCXHandler,
46732 _swigt__p_wxGIFHandler,
46733 _swigt__p_wxPNGHandler,
46734 _swigt__p_wxANIHandler,
46735 _swigt__p_wxMemoryFSHandler,
46736 _swigt__p_wxZipFSHandler,
46737 _swigt__p_wxInternetFSHandler,
46738 _swigt__p_wxPyFileSystemHandler,
46739 _swigt__p_wxEvtHandler,
46740 _swigt__p_wxCURHandler,
46741 _swigt__p_wxICOHandler,
46742 _swigt__p_wxBMPHandler,
46743 _swigt__p_wxImageHandler,
46744 _swigt__p_wxFileSystemHandler,
46745 _swigt__p_wxRect,
46746 _swigt__p_wxButton,
46747 _swigt__p_wxGBSpan,
46748 _swigt__p_wxPropagateOnce,
46749 _swigt__p_wxAcceleratorTable,
46750 _swigt__p_wxStdDialogButtonSizer,
46751 _swigt__p_char,
46752 _swigt__p_wxGBPosition,
46753 _swigt__p_wxImage,
46754 _swigt__p_wxFrame,
46755 _swigt__p_wxScrollWinEvent,
46756 _swigt__p_wxPaperSize,
46757 _swigt__p_wxImageHistogram,
46758 _swigt__p_wxPoint,
46759 _swigt__p_wxCursor,
46760 _swigt__p_wxObject,
46761 _swigt__p_wxInputStream,
46762 _swigt__p_wxOutputStream,
46763 _swigt__p_wxPyInputStream,
46764 _swigt__p_wxDateTime,
46765 _swigt__p_wxKeyEvent,
46766 _swigt__p_wxNavigationKeyEvent,
46767 _swigt__p_wxWindowDestroyEvent,
46768 _swigt__p_unsigned_long,
46769 _swigt__p_wxWindow,
46770 _swigt__p_wxMenuBar,
46771 _swigt__p_wxFileSystem,
46772 _swigt__p_wxBitmap,
46773 _swigt__unsigned_int,
46774 _swigt__p_unsigned_int,
46775 _swigt__p_wxMenuEvent,
46776 _swigt__p_wxContextMenuEvent,
46777 _swigt__p_unsigned_char,
46778 _swigt__p_wxEraseEvent,
46779 _swigt__p_wxMouseEvent,
46780 _swigt__p_wxCloseEvent,
46781 _swigt__p_wxPyApp,
46782 _swigt__p_wxCommandEvent,
46783 _swigt__p_wxPyCommandEvent,
46784 _swigt__p_wxPyDropTarget,
46785 _swigt__p_wxQuantize,
46786 _swigt__p_wxChildFocusEvent,
46787 _swigt__p_wxFocusEvent,
46788 _swigt__p_wxDropFilesEvent,
46789 _swigt__p_wxControlWithItems,
46790 _swigt__p_wxColour,
46791 _swigt__p_wxValidator,
46792 _swigt__p_wxPyValidator,
46793 0
46794 };
46795
46796
46797 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46798
46799 static swig_const_info swig_const_table[] = {
46800 {0, 0, 0, 0.0, 0, 0}};
46801
46802 #ifdef __cplusplus
46803 }
46804 #endif
46805
46806
46807 #ifdef __cplusplus
46808 extern "C" {
46809 #endif
46810
46811 /* Python-specific SWIG API */
46812 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46813 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46814 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46815
46816 /* -----------------------------------------------------------------------------
46817 * global variable support code.
46818 * ----------------------------------------------------------------------------- */
46819
46820 typedef struct swig_globalvar {
46821 char *name; /* Name of global variable */
46822 PyObject *(*get_attr)(); /* Return the current value */
46823 int (*set_attr)(PyObject *); /* Set the value */
46824 struct swig_globalvar *next;
46825 } swig_globalvar;
46826
46827 typedef struct swig_varlinkobject {
46828 PyObject_HEAD
46829 swig_globalvar *vars;
46830 } swig_varlinkobject;
46831
46832 static PyObject *
46833 swig_varlink_repr(swig_varlinkobject *v) {
46834 v = v;
46835 return PyString_FromString("<Swig global variables>");
46836 }
46837
46838 static int
46839 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46840 swig_globalvar *var;
46841 flags = flags;
46842 fprintf(fp,"Swig global variables { ");
46843 for (var = v->vars; var; var=var->next) {
46844 fprintf(fp,"%s", var->name);
46845 if (var->next) fprintf(fp,", ");
46846 }
46847 fprintf(fp," }\n");
46848 return 0;
46849 }
46850
46851 static PyObject *
46852 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46853 swig_globalvar *var = v->vars;
46854 while (var) {
46855 if (strcmp(var->name,n) == 0) {
46856 return (*var->get_attr)();
46857 }
46858 var = var->next;
46859 }
46860 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46861 return NULL;
46862 }
46863
46864 static int
46865 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46866 swig_globalvar *var = v->vars;
46867 while (var) {
46868 if (strcmp(var->name,n) == 0) {
46869 return (*var->set_attr)(p);
46870 }
46871 var = var->next;
46872 }
46873 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46874 return 1;
46875 }
46876
46877 static PyTypeObject varlinktype = {
46878 PyObject_HEAD_INIT(0)
46879 0, /* Number of items in variable part (ob_size) */
46880 (char *)"swigvarlink", /* Type name (tp_name) */
46881 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46882 0, /* Itemsize (tp_itemsize) */
46883 0, /* Deallocator (tp_dealloc) */
46884 (printfunc) swig_varlink_print, /* Print (tp_print) */
46885 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46886 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46887 0, /* tp_compare */
46888 (reprfunc) swig_varlink_repr, /* tp_repr */
46889 0, /* tp_as_number */
46890 0, /* tp_as_sequence */
46891 0, /* tp_as_mapping */
46892 0, /* tp_hash */
46893 0, /* tp_call */
46894 0, /* tp_str */
46895 0, /* tp_getattro */
46896 0, /* tp_setattro */
46897 0, /* tp_as_buffer */
46898 0, /* tp_flags */
46899 0, /* tp_doc */
46900 #if PY_VERSION_HEX >= 0x02000000
46901 0, /* tp_traverse */
46902 0, /* tp_clear */
46903 #endif
46904 #if PY_VERSION_HEX >= 0x02010000
46905 0, /* tp_richcompare */
46906 0, /* tp_weaklistoffset */
46907 #endif
46908 #if PY_VERSION_HEX >= 0x02020000
46909 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46910 #endif
46911 #if PY_VERSION_HEX >= 0x02030000
46912 0, /* tp_del */
46913 #endif
46914 #ifdef COUNT_ALLOCS
46915 0,0,0,0 /* tp_alloc -> tp_next */
46916 #endif
46917 };
46918
46919 /* Create a variable linking object for use later */
46920 static PyObject *
46921 SWIG_Python_newvarlink(void) {
46922 swig_varlinkobject *result = 0;
46923 result = PyMem_NEW(swig_varlinkobject,1);
46924 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46925 result->ob_type = &varlinktype;
46926 result->vars = 0;
46927 result->ob_refcnt = 0;
46928 Py_XINCREF((PyObject *) result);
46929 return ((PyObject*) result);
46930 }
46931
46932 static void
46933 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46934 swig_varlinkobject *v;
46935 swig_globalvar *gv;
46936 v= (swig_varlinkobject *) p;
46937 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46938 gv->name = (char *) malloc(strlen(name)+1);
46939 strcpy(gv->name,name);
46940 gv->get_attr = get_attr;
46941 gv->set_attr = set_attr;
46942 gv->next = v->vars;
46943 v->vars = gv;
46944 }
46945
46946 /* -----------------------------------------------------------------------------
46947 * constants/methods manipulation
46948 * ----------------------------------------------------------------------------- */
46949
46950 /* Install Constants */
46951 static void
46952 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46953 PyObject *obj = 0;
46954 size_t i;
46955 for (i = 0; constants[i].type; i++) {
46956 switch(constants[i].type) {
46957 case SWIG_PY_INT:
46958 obj = PyInt_FromLong(constants[i].lvalue);
46959 break;
46960 case SWIG_PY_FLOAT:
46961 obj = PyFloat_FromDouble(constants[i].dvalue);
46962 break;
46963 case SWIG_PY_STRING:
46964 if (constants[i].pvalue) {
46965 obj = PyString_FromString((char *) constants[i].pvalue);
46966 } else {
46967 Py_INCREF(Py_None);
46968 obj = Py_None;
46969 }
46970 break;
46971 case SWIG_PY_POINTER:
46972 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46973 break;
46974 case SWIG_PY_BINARY:
46975 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46976 break;
46977 default:
46978 obj = 0;
46979 break;
46980 }
46981 if (obj) {
46982 PyDict_SetItemString(d,constants[i].name,obj);
46983 Py_DECREF(obj);
46984 }
46985 }
46986 }
46987
46988 /* -----------------------------------------------------------------------------*/
46989 /* Fix SwigMethods to carry the callback ptrs when needed */
46990 /* -----------------------------------------------------------------------------*/
46991
46992 static void
46993 SWIG_Python_FixMethods(PyMethodDef *methods,
46994 swig_const_info *const_table,
46995 swig_type_info **types,
46996 swig_type_info **types_initial) {
46997 size_t i;
46998 for (i = 0; methods[i].ml_name; ++i) {
46999 char *c = methods[i].ml_doc;
47000 if (c && (c = strstr(c, "swig_ptr: "))) {
47001 int j;
47002 swig_const_info *ci = 0;
47003 char *name = c + 10;
47004 for (j = 0; const_table[j].type; j++) {
47005 if (strncmp(const_table[j].name, name,
47006 strlen(const_table[j].name)) == 0) {
47007 ci = &(const_table[j]);
47008 break;
47009 }
47010 }
47011 if (ci) {
47012 size_t shift = (ci->ptype) - types;
47013 swig_type_info *ty = types_initial[shift];
47014 size_t ldoc = (c - methods[i].ml_doc);
47015 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47016 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47017 char *buff = ndoc;
47018 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47019 strncpy(buff, methods[i].ml_doc, ldoc);
47020 buff += ldoc;
47021 strncpy(buff, "swig_ptr: ", 10);
47022 buff += 10;
47023 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47024 methods[i].ml_doc = ndoc;
47025 }
47026 }
47027 }
47028 }
47029
47030 /* -----------------------------------------------------------------------------*
47031 * Initialize type list
47032 * -----------------------------------------------------------------------------*/
47033
47034 #if PY_MAJOR_VERSION < 2
47035 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47036 is copied out of Python/modsupport.c in python version 2.3.4 */
47037 static int
47038 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47039 {
47040 PyObject *dict;
47041 if (!PyModule_Check(m)) {
47042 PyErr_SetString(PyExc_TypeError,
47043 "PyModule_AddObject() needs module as first arg");
47044 return -1;
47045 }
47046 if (!o) {
47047 PyErr_SetString(PyExc_TypeError,
47048 "PyModule_AddObject() needs non-NULL value");
47049 return -1;
47050 }
47051
47052 dict = PyModule_GetDict(m);
47053 if (dict == NULL) {
47054 /* Internal error -- modules must have a dict! */
47055 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47056 PyModule_GetName(m));
47057 return -1;
47058 }
47059 if (PyDict_SetItemString(dict, name, o))
47060 return -1;
47061 Py_DECREF(o);
47062 return 0;
47063 }
47064 #endif
47065
47066 static swig_type_info **
47067 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47068 static PyMethodDef swig_empty_runtime_method_table[] = {
47069 {
47070 NULL, NULL, 0, NULL
47071 }
47072 };/* Sentinel */
47073
47074 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47075 swig_empty_runtime_method_table);
47076 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47077 if (pointer && module) {
47078 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47079 }
47080 return type_list_handle;
47081 }
47082
47083 static swig_type_info **
47084 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47085 swig_type_info **type_pointer;
47086
47087 /* first check if module already created */
47088 type_pointer = SWIG_Python_GetTypeListHandle();
47089 if (type_pointer) {
47090 return type_pointer;
47091 } else {
47092 /* create a new module and variable */
47093 return SWIG_Python_SetTypeListHandle(type_list_handle);
47094 }
47095 }
47096
47097 #ifdef __cplusplus
47098 }
47099 #endif
47100
47101 /* -----------------------------------------------------------------------------*
47102 * Partial Init method
47103 * -----------------------------------------------------------------------------*/
47104
47105 #ifdef SWIG_LINK_RUNTIME
47106 #ifdef __cplusplus
47107 extern "C"
47108 #endif
47109 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47110 #endif
47111
47112 #ifdef __cplusplus
47113 extern "C"
47114 #endif
47115 SWIGEXPORT(void) SWIG_init(void) {
47116 static PyObject *SWIG_globals = 0;
47117 static int typeinit = 0;
47118 PyObject *m, *d;
47119 int i;
47120 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47121
47122 /* Fix SwigMethods to carry the callback ptrs when needed */
47123 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47124
47125 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47126 d = PyModule_GetDict(m);
47127
47128 if (!typeinit) {
47129 #ifdef SWIG_LINK_RUNTIME
47130 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47131 #else
47132 # ifndef SWIG_STATIC_RUNTIME
47133 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47134 # endif
47135 #endif
47136 for (i = 0; swig_types_initial[i]; i++) {
47137 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47138 }
47139 typeinit = 1;
47140 }
47141 SWIG_InstallConstants(d,swig_const_table);
47142
47143
47144 #ifndef wxPyUSE_EXPORT
47145 // Make our API structure a CObject so other modules can import it
47146 // from this module.
47147 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47148 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47149 Py_XDECREF(cobj);
47150 #endif
47151
47152 {
47153 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48756 }
48757 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48758 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48759 {
48760 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48911 }
48912 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48913 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48914 {
48915 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48922 }
48923
48924 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48925
48926
48927 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48928
48929 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48930 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48931 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48932 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48933 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48934 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48935 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48936 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48937 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48938 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
48939 {
48940 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48944 }
48945 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48946 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48947 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
48948 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
48949 {
48950 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48987 }
48988 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48989 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48990 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48991 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48992 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48993 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48994 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48995 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48996 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48997 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48998 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48999 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49000 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49001 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49002 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49003 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49004 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49005 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49006 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49007 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49008 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49009 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49010 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49011 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49012 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49013 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49014 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49015 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49016 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49017 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49018 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49019 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49020 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49021 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49022 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49023 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49024 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49025 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49026 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49027 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49028 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49029 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49030 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49031 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49032 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49033 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49034 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49035 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49036 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49037 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49038 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49039 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49040 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49041 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49042 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49043 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49044 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49045 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49046 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49047 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49048 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49049 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49050 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49051 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49052 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49053 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49054 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49055 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49056 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49057 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49058 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49059 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49060 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49061 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49062 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49063 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49064 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49065 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49066 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49067 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49068 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49069 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49070 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49071 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49072 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49073 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49074 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49075 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49076 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49077 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49078 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49079 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49080 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49081 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49082 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49083 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49084 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49085 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49086 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49087 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49088 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49089 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49090 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49091 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49092 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49093 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49094 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49095 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49096 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49097 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49098 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49099 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49100 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49101 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49102 {
49103 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49140 }
49141 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49142 {
49143 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49159 }
49160 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49161 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49162 {
49163 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49176 }
49177 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49178 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49179 {
49180 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49187 }
49188 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49189 {
49190 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49245 }
49246
49247 // Initialize threading, some globals and such
49248 __wxPyPreStart(d);
49249
49250
49251 // Although these are defined in __version__ they need to be here too so
49252 // that an assert can be done to ensure that the wxPython and the wxWindows
49253 // versions match.
49254 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49255 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49256 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49257
49258 }
49259
wxWidgets (Impactor)