]> 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
Changed the hardcoded table name to be in all caps for those DBs that only allow...
[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_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxGBSpan swig_types[79]
1421 #define SWIGTYPE_p_wxPropagateOnce swig_types[80]
1422 #define SWIGTYPE_p_wxAcceleratorTable swig_types[81]
1423 #define SWIGTYPE_p_char swig_types[82]
1424 #define SWIGTYPE_p_wxGBPosition swig_types[83]
1425 #define SWIGTYPE_p_wxImage swig_types[84]
1426 #define SWIGTYPE_p_wxFrame swig_types[85]
1427 #define SWIGTYPE_p_wxScrollWinEvent swig_types[86]
1428 #define SWIGTYPE_p_wxPaperSize swig_types[87]
1429 #define SWIGTYPE_p_wxImageHistogram swig_types[88]
1430 #define SWIGTYPE_p_wxPoint swig_types[89]
1431 #define SWIGTYPE_p_wxCursor swig_types[90]
1432 #define SWIGTYPE_p_wxObject swig_types[91]
1433 #define SWIGTYPE_p_wxInputStream swig_types[92]
1434 #define SWIGTYPE_p_wxOutputStream swig_types[93]
1435 #define SWIGTYPE_p_wxPyInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxDateTime swig_types[95]
1437 #define SWIGTYPE_p_wxKeyEvent swig_types[96]
1438 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[97]
1439 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[98]
1440 #define SWIGTYPE_p_unsigned_long swig_types[99]
1441 #define SWIGTYPE_p_wxWindow swig_types[100]
1442 #define SWIGTYPE_p_wxMenuBar swig_types[101]
1443 #define SWIGTYPE_p_wxFileSystem swig_types[102]
1444 #define SWIGTYPE_p_wxBitmap swig_types[103]
1445 #define SWIGTYPE_unsigned_int swig_types[104]
1446 #define SWIGTYPE_p_unsigned_int swig_types[105]
1447 #define SWIGTYPE_p_wxMenuEvent swig_types[106]
1448 #define SWIGTYPE_p_wxContextMenuEvent swig_types[107]
1449 #define SWIGTYPE_p_unsigned_char swig_types[108]
1450 #define SWIGTYPE_p_wxEraseEvent swig_types[109]
1451 #define SWIGTYPE_p_wxMouseEvent swig_types[110]
1452 #define SWIGTYPE_p_wxCloseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxPyApp swig_types[112]
1454 #define SWIGTYPE_p_wxCommandEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyCommandEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyDropTarget swig_types[115]
1457 #define SWIGTYPE_p_wxQuantize swig_types[116]
1458 #define SWIGTYPE_p_wxChildFocusEvent swig_types[117]
1459 #define SWIGTYPE_p_wxFocusEvent swig_types[118]
1460 #define SWIGTYPE_p_wxDropFilesEvent swig_types[119]
1461 #define SWIGTYPE_p_wxControlWithItems swig_types[120]
1462 #define SWIGTYPE_p_wxColour swig_types[121]
1463 #define SWIGTYPE_p_wxValidator swig_types[122]
1464 #define SWIGTYPE_p_wxPyValidator swig_types[123]
1465 static swig_type_info *swig_types[125];
1466
1467 /* -------- TYPES TABLE (END) -------- */
1468
1469
1470 /*-----------------------------------------------
1471 @(target):= _core_.so
1472 ------------------------------------------------*/
1473 #define SWIG_init init_core_
1474
1475 #define SWIG_name "_core_"
1476
1477 #include "wx/wxPython/wxPython_int.h"
1478 #include "wx/wxPython/pyclasses.h"
1479
1480
1481 #ifndef wxPyUSE_EXPORT
1482 // Helper functions for dealing with SWIG objects and such. These are
1483 // located here so they know about the SWIG types and functions declared
1484 // in the wrapper code.
1485
1486 #include <wx/hashmap.h>
1487 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1488
1489
1490 // Maintains a hashmap of className to swig_type_info pointers. Given the
1491 // name of a class either looks up the type info in the cache, or scans the
1492 // SWIG tables for it.
1493 extern PyObject* wxPyPtrTypeMap;
1494 static
1495 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1496
1497 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1498
1499 if (typeInfoCache == NULL)
1500 typeInfoCache = new wxPyTypeInfoHashMap;
1501
1502 wxString name(className);
1503 swig_type_info* swigType = (*typeInfoCache)[name];
1504
1505 if (! swigType) {
1506 // it wasn't in the cache, so look it up from SWIG
1507 name.Append(wxT(" *"));
1508 swigType = SWIG_TypeQuery(name.mb_str());
1509
1510 // if it still wasn't found, try looking for a mapped name
1511 if (!swigType) {
1512 PyObject* item;
1513 name = className;
1514
1515 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1516 (char*)(const char*)name.mbc_str())) != NULL) {
1517 name = wxString(PyString_AsString(item), *wxConvCurrent);
1518 name.Append(wxT(" *"));
1519 swigType = SWIG_TypeQuery(name.mb_str());
1520 }
1521 }
1522 if (swigType) {
1523 // and add it to the map if found
1524 (*typeInfoCache)[className] = swigType;
1525 }
1526 }
1527 return swigType;
1528 }
1529
1530
1531 // Check if a class name is a type known to SWIG
1532 bool wxPyCheckSwigType(const wxChar* className) {
1533
1534 swig_type_info* swigType = wxPyFindSwigType(className);
1535 return swigType != NULL;
1536 }
1537
1538
1539 // Given a pointer to a C++ object and a class name, construct a Python proxy
1540 // object for it.
1541 PyObject* wxPyConstructObject(void* ptr,
1542 const wxChar* className,
1543 int setThisOwn) {
1544
1545 swig_type_info* swigType = wxPyFindSwigType(className);
1546 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1547
1548 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1549 }
1550
1551
1552 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1553 // Ensures that the proxy object is of the specified (or derived) type. If
1554 // not able to perform the conversion then a Python exception is set and the
1555 // error should be handled properly in the caller. Returns True on success.
1556 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1557 const wxChar* className) {
1558
1559 swig_type_info* swigType = wxPyFindSwigType(className);
1560 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1561
1562 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1563 }
1564
1565
1566 // Make a SWIGified pointer object suitable for a .this attribute
1567 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1568
1569 PyObject* robj = NULL;
1570
1571 swig_type_info* swigType = wxPyFindSwigType(className);
1572 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1573
1574 #ifdef SWIG_COBJECT_TYPES
1575 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1576 #else
1577 {
1578 char result[1024];
1579 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1580 PyString_FromString(result) : 0;
1581 }
1582 #endif
1583
1584 return robj;
1585 }
1586
1587
1588
1589
1590 // Export a C API in a struct. Other modules will be able to load this from
1591 // the wx._core_ module and will then have safe access to these functions,
1592 // even if they are located in another shared library.
1593 static wxPyCoreAPI API = {
1594
1595 wxPyCheckSwigType,
1596 wxPyConstructObject,
1597 wxPyConvertSwigPtr,
1598 wxPyMakeSwigPtr,
1599
1600 wxPyBeginAllowThreads,
1601 wxPyEndAllowThreads,
1602 wxPyBeginBlockThreads,
1603 wxPyEndBlockThreads,
1604
1605 wxPy_ConvertList,
1606
1607 wxString_in_helper,
1608 Py2wxString,
1609 wx2PyString,
1610
1611 byte_LIST_helper,
1612 int_LIST_helper,
1613 long_LIST_helper,
1614 string_LIST_helper,
1615 wxPoint_LIST_helper,
1616 wxBitmap_LIST_helper,
1617 wxString_LIST_helper,
1618 wxAcceleratorEntry_LIST_helper,
1619
1620 wxSize_helper,
1621 wxPoint_helper,
1622 wxRealPoint_helper,
1623 wxRect_helper,
1624 wxColour_helper,
1625 wxPoint2D_helper,
1626
1627 wxPySimple_typecheck,
1628 wxColour_typecheck,
1629
1630 wxPyCBH_setCallbackInfo,
1631 wxPyCBH_findCallback,
1632 wxPyCBH_callCallback,
1633 wxPyCBH_callCallbackObj,
1634 wxPyCBH_delete,
1635
1636 wxPyMake_wxObject,
1637 wxPyMake_wxSizer,
1638 wxPyPtrTypeMap_Add,
1639 wxPy2int_seq_helper,
1640 wxPy4int_seq_helper,
1641 wxArrayString2PyList_helper,
1642 wxArrayInt2PyList_helper,
1643
1644 wxPyClientData_dtor,
1645 wxPyUserData_dtor,
1646 wxPyOORClientData_dtor,
1647
1648 wxPyCBInputStream_create,
1649
1650 wxPyInstance_Check,
1651 wxPySwigInstance_Check,
1652
1653 wxPyCheckForApp
1654
1655 };
1656
1657 #endif
1658
1659
1660 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1661 #define SWIG_From_int PyInt_FromLong
1662 /*@@*/
1663
1664
1665 #if ! wxUSE_HOTKEY
1666 enum wxHotkeyModifier
1667 {
1668 wxMOD_NONE = 0,
1669 wxMOD_ALT = 1,
1670 wxMOD_CONTROL = 2,
1671 wxMOD_SHIFT = 4,
1672 wxMOD_WIN = 8
1673 };
1674 #define wxEVT_HOTKEY 9999
1675 #endif
1676
1677 static const wxString wxPyEmptyString(wxEmptyString);
1678 static wxString wxObject_GetClassName(wxObject *self){
1679 return self->GetClassInfo()->GetClassName();
1680 }
1681 static void wxObject_Destroy(wxObject *self){
1682 delete self;
1683 }
1684
1685 #ifndef __WXMAC__
1686 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1687 #endif
1688
1689
1690 #include <limits.h>
1691
1692
1693 SWIGINTERN int
1694 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1695 const char *errmsg)
1696 {
1697 if (value < min_value) {
1698 if (errmsg) {
1699 PyErr_Format(PyExc_OverflowError,
1700 "value %ld is less than '%s' minimum %ld",
1701 value, errmsg, min_value);
1702 }
1703 return 0;
1704 } else if (value > max_value) {
1705 if (errmsg) {
1706 PyErr_Format(PyExc_OverflowError,
1707 "value %ld is greater than '%s' maximum %ld",
1708 value, errmsg, max_value);
1709 }
1710 return 0;
1711 }
1712 return 1;
1713 }
1714
1715
1716 SWIGINTERN int
1717 SWIG_AsVal_long(PyObject* obj, long* val)
1718 {
1719 if (PyNumber_Check(obj)) {
1720 if (val) *val = PyInt_AsLong(obj);
1721 return 1;
1722 }
1723 else {
1724 SWIG_type_error("number", obj);
1725 }
1726 return 0;
1727 }
1728
1729
1730 #if INT_MAX != LONG_MAX
1731 SWIGINTERN int
1732 SWIG_AsVal_int(PyObject *obj, int *val)
1733 {
1734 const char* errmsg = val ? "int" : (char*)0;
1735 long v;
1736 if (SWIG_AsVal_long(obj, &v)) {
1737 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1738 if (val) *val = (int)(v);
1739 return 1;
1740 } else {
1741 return 0;
1742 }
1743 } else {
1744 PyErr_Clear();
1745 }
1746 if (val) {
1747 SWIG_type_error(errmsg, obj);
1748 }
1749 return 0;
1750 }
1751 #else
1752 SWIGINTERNSHORT int
1753 SWIG_AsVal_int(PyObject *obj, int *val)
1754 {
1755 return SWIG_AsVal_long(obj,(long*)val);
1756 }
1757 #endif
1758
1759
1760 SWIGINTERNSHORT int
1761 SWIG_As_int(PyObject* obj)
1762 {
1763 int v;
1764 if (!SWIG_AsVal_int(obj, &v)) {
1765 /*
1766 this is needed to make valgrind/purify happier.
1767 */
1768 memset((void*)&v, 0, sizeof(int));
1769 }
1770 return v;
1771 }
1772
1773
1774 SWIGINTERNSHORT int
1775 SWIG_Check_int(PyObject* obj)
1776 {
1777 return SWIG_AsVal_int(obj, (int*)0);
1778 }
1779
1780 static PyObject *wxSize_Get(wxSize *self){
1781 bool blocked = wxPyBeginBlockThreads();
1782 PyObject* tup = PyTuple_New(2);
1783 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1784 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1785 wxPyEndBlockThreads(blocked);
1786 return tup;
1787 }
1788
1789 SWIGINTERN int
1790 SWIG_AsVal_double(PyObject *obj, double* val)
1791 {
1792 if (PyNumber_Check(obj)) {
1793 if (val) *val = PyFloat_AsDouble(obj);
1794 return 1;
1795 }
1796 else {
1797 SWIG_type_error("number", obj);
1798 }
1799 return 0;
1800 }
1801
1802
1803 SWIGINTERNSHORT double
1804 SWIG_As_double(PyObject* obj)
1805 {
1806 double v;
1807 if (!SWIG_AsVal_double(obj, &v)) {
1808 /*
1809 this is needed to make valgrind/purify happier.
1810 */
1811 memset((void*)&v, 0, sizeof(double));
1812 }
1813 return v;
1814 }
1815
1816
1817 SWIGINTERNSHORT int
1818 SWIG_Check_double(PyObject* obj)
1819 {
1820 return SWIG_AsVal_double(obj, (double*)0);
1821 }
1822
1823
1824 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1825 #define SWIG_From_double PyFloat_FromDouble
1826 /*@@*/
1827
1828 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1829 self->x = x;
1830 self->y = y;
1831 }
1832 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1833 bool blocked = wxPyBeginBlockThreads();
1834 PyObject* tup = PyTuple_New(2);
1835 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1836 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1837 wxPyEndBlockThreads(blocked);
1838 return tup;
1839 }
1840
1841 SWIGINTERNSHORT long
1842 SWIG_As_long(PyObject* obj)
1843 {
1844 long v;
1845 if (!SWIG_AsVal_long(obj, &v)) {
1846 /*
1847 this is needed to make valgrind/purify happier.
1848 */
1849 memset((void*)&v, 0, sizeof(long));
1850 }
1851 return v;
1852 }
1853
1854
1855 SWIGINTERNSHORT int
1856 SWIG_Check_long(PyObject* obj)
1857 {
1858 return SWIG_AsVal_long(obj, (long*)0);
1859 }
1860
1861 static void wxPoint_Set(wxPoint *self,long x,long y){
1862 self->x = x;
1863 self->y = y;
1864 }
1865 static PyObject *wxPoint_Get(wxPoint *self){
1866 bool blocked = wxPyBeginBlockThreads();
1867 PyObject* tup = PyTuple_New(2);
1868 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1869 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1870 wxPyEndBlockThreads(blocked);
1871 return tup;
1872 }
1873 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1874 self->x = x;
1875 self->y = y;
1876 self->width = width;
1877 self->height = height;
1878 }
1879 static PyObject *wxRect_Get(wxRect *self){
1880 bool blocked = wxPyBeginBlockThreads();
1881 PyObject* tup = PyTuple_New(4);
1882 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1883 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1884 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1885 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1886 wxPyEndBlockThreads(blocked);
1887 return tup;
1888 }
1889
1890 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1891 wxRegion reg1(*r1);
1892 wxRegion reg2(*r2);
1893 wxRect dest(0,0,0,0);
1894 PyObject* obj;
1895
1896 reg1.Intersect(reg2);
1897 dest = reg1.GetBox();
1898
1899 if (dest != wxRect(0,0,0,0)) {
1900 bool blocked = wxPyBeginBlockThreads();
1901 wxRect* newRect = new wxRect(dest);
1902 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1903 wxPyEndBlockThreads(blocked);
1904 return obj;
1905 }
1906 Py_INCREF(Py_None);
1907 return Py_None;
1908 }
1909
1910
1911 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1912 PyObject* o2;
1913 PyObject* o3;
1914
1915 if (!target) {
1916 target = o;
1917 } else if (target == Py_None) {
1918 Py_DECREF(Py_None);
1919 target = o;
1920 } else {
1921 if (!PyTuple_Check(target)) {
1922 o2 = target;
1923 target = PyTuple_New(1);
1924 PyTuple_SetItem(target, 0, o2);
1925 }
1926 o3 = PyTuple_New(1);
1927 PyTuple_SetItem(o3, 0, o);
1928
1929 o2 = target;
1930 target = PySequence_Concat(o2, o3);
1931 Py_DECREF(o2);
1932 Py_DECREF(o3);
1933 }
1934 return target;
1935 }
1936
1937
1938 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1939 self->m_x = x;
1940 self->m_y = y;
1941 }
1942 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1943 bool blocked = wxPyBeginBlockThreads();
1944 PyObject* tup = PyTuple_New(2);
1945 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1946 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1947 wxPyEndBlockThreads(blocked);
1948 return tup;
1949 }
1950
1951 #include "wx/wxPython/pyistream.h"
1952
1953 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1954 wxInputStream* wxis = wxPyCBInputStream::create(p);
1955 if (wxis)
1956 return new wxPyInputStream(wxis);
1957 else
1958 return NULL;
1959 }
1960
1961 SWIGINTERNSHORT PyObject*
1962 SWIG_From_char(char c)
1963 {
1964 return PyString_FromStringAndSize(&c,1);
1965 }
1966
1967
1968 SWIGINTERNSHORT PyObject*
1969 SWIG_From_unsigned_SS_long(unsigned long value)
1970 {
1971 return (value > LONG_MAX) ?
1972 PyLong_FromUnsignedLong(value)
1973 : PyInt_FromLong((long)(value));
1974 }
1975
1976
1977 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1978 SWIGINTERN int
1979 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1980 {
1981 static swig_type_info* pchar_info = 0;
1982 char* vptr = 0;
1983 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1984 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1985 if (cptr) *cptr = vptr;
1986 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1987 return SWIG_OLDOBJ;
1988 } else {
1989 PyErr_Clear();
1990 if (PyString_Check(obj)) {
1991 if (cptr) {
1992 *cptr = PyString_AS_STRING(obj);
1993 if (psize) {
1994 *psize = PyString_GET_SIZE(obj) + 1;
1995 }
1996 }
1997 return SWIG_PYSTR;
1998 }
1999 }
2000 if (cptr) {
2001 SWIG_type_error("char *", obj);
2002 }
2003 return 0;
2004 }
2005
2006
2007 SWIGINTERN int
2008 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2009 {
2010 char* cptr; size_t csize;
2011 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2012 /* in C you can do:
2013
2014 char x[5] = "hello";
2015
2016 ie, assing the array using an extra '0' char.
2017 */
2018 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2019 if (csize <= size) {
2020 if (val) {
2021 if (csize) memcpy(val, cptr, csize);
2022 if (csize < size) memset(val + csize, 0, size - csize);
2023 }
2024 return 1;
2025 }
2026 }
2027 if (val) {
2028 PyErr_Format(PyExc_TypeError,
2029 "a char array of maximum size %lu is expected",
2030 (unsigned long) size);
2031 }
2032 return 0;
2033 }
2034
2035
2036 SWIGINTERN int
2037 SWIG_AsVal_char(PyObject *obj, char *val)
2038 {
2039 const char* errmsg = val ? "char" : (char*)0;
2040 long v;
2041 if (SWIG_AsVal_long(obj, &v)) {
2042 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2043 if (val) *val = (char)(v);
2044 return 1;
2045 } else {
2046 return 0;
2047 }
2048 } else {
2049 PyErr_Clear();
2050 return SWIG_AsCharArray(obj, val, 1);
2051 }
2052 }
2053
2054
2055 SWIGINTERNSHORT char
2056 SWIG_As_char(PyObject* obj)
2057 {
2058 char v;
2059 if (!SWIG_AsVal_char(obj, &v)) {
2060 /*
2061 this is needed to make valgrind/purify happier.
2062 */
2063 memset((void*)&v, 0, sizeof(char));
2064 }
2065 return v;
2066 }
2067
2068
2069 SWIGINTERNSHORT int
2070 SWIG_Check_char(PyObject* obj)
2071 {
2072 return SWIG_AsVal_char(obj, (char*)0);
2073 }
2074
2075
2076 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2077 #define SWIG_From_long PyInt_FromLong
2078 /*@@*/
2079
2080 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2081 // We use only strings for the streams, not unicode
2082 PyObject* str = PyObject_Str(obj);
2083 if (! str) {
2084 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2085 return;
2086 }
2087 self->Write(PyString_AS_STRING(str),
2088 PyString_GET_SIZE(str));
2089 Py_DECREF(str);
2090 }
2091
2092 #include "wx/wxPython/pyistream.h"
2093
2094
2095 class wxPyFileSystemHandler : public wxFileSystemHandler
2096 {
2097 public:
2098 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2099
2100 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2101 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2102 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2103 DEC_PYCALLBACK_STRING__pure(FindNext);
2104
2105 wxString GetProtocol(const wxString& location) {
2106 return wxFileSystemHandler::GetProtocol(location);
2107 }
2108
2109 wxString GetLeftLocation(const wxString& location) {
2110 return wxFileSystemHandler::GetLeftLocation(location);
2111 }
2112
2113 wxString GetAnchor(const wxString& location) {
2114 return wxFileSystemHandler::GetAnchor(location);
2115 }
2116
2117 wxString GetRightLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetRightLocation(location);
2119 }
2120
2121 wxString GetMimeTypeFromExt(const wxString& location) {
2122 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2123 }
2124
2125 PYPRIVATE;
2126 };
2127
2128
2129 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2130 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2131 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2132 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2133
2134
2135 SWIGINTERN int
2136 SWIG_AsVal_bool(PyObject *obj, bool *val)
2137 {
2138 if (obj == Py_True) {
2139 if (val) *val = true;
2140 return 1;
2141 }
2142 if (obj == Py_False) {
2143 if (val) *val = false;
2144 return 1;
2145 }
2146 int res = 0;
2147 if (SWIG_AsVal_int(obj, &res)) {
2148 if (val) *val = res ? true : false;
2149 return 1;
2150 } else {
2151 PyErr_Clear();
2152 }
2153 if (val) {
2154 SWIG_type_error("bool", obj);
2155 }
2156 return 0;
2157 }
2158
2159
2160 SWIGINTERNSHORT bool
2161 SWIG_As_bool(PyObject* obj)
2162 {
2163 bool v;
2164 if (!SWIG_AsVal_bool(obj, &v)) {
2165 /*
2166 this is needed to make valgrind/purify happier.
2167 */
2168 memset((void*)&v, 0, sizeof(bool));
2169 }
2170 return v;
2171 }
2172
2173
2174 SWIGINTERNSHORT int
2175 SWIG_Check_bool(PyObject* obj)
2176 {
2177 return SWIG_AsVal_bool(obj, (bool*)0);
2178 }
2179
2180 static wxString FileSystem_URLToFileName(wxString const &url){
2181 wxFileName fname = wxFileSystem::URLToFileName(url);
2182 return fname.GetFullPath();
2183 }
2184
2185 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2186 wxImage& image,
2187 long type) {
2188 wxMemoryFSHandler::AddFile(filename, image, type);
2189 }
2190
2191 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2192 const wxBitmap& bitmap,
2193 long type) {
2194 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2195 }
2196
2197 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2198 PyObject* data) {
2199 if (! PyString_Check(data)) {
2200 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2201 "Expected string object"));
2202 return;
2203 }
2204
2205 bool blocked = wxPyBeginBlockThreads();
2206 void* ptr = (void*)PyString_AsString(data);
2207 size_t size = PyString_Size(data);
2208 wxPyEndBlockThreads(blocked);
2209
2210 wxMemoryFSHandler::AddFile(filename, ptr, size);
2211 }
2212
2213
2214 #include "wx/wxPython/pyistream.h"
2215
2216
2217 SWIGINTERN int
2218 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2219 {
2220 long v = 0;
2221 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2222 SWIG_type_error("unsigned number", obj);
2223 }
2224 else if (val)
2225 *val = (unsigned long)v;
2226 return 1;
2227 }
2228
2229
2230 SWIGINTERNSHORT int
2231 SWIG_CheckUnsignedLongInRange(unsigned long value,
2232 unsigned long max_value,
2233 const char *errmsg)
2234 {
2235 if (value > max_value) {
2236 if (errmsg) {
2237 PyErr_Format(PyExc_OverflowError,
2238 "value %lu is greater than '%s' minimum %lu",
2239 value, errmsg, max_value);
2240 }
2241 return 0;
2242 }
2243 return 1;
2244 }
2245
2246
2247 SWIGINTERN int
2248 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2249 {
2250 const char* errmsg = val ? "unsigned char" : (char*)0;
2251 unsigned long v;
2252 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2253 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2254 if (val) *val = (unsigned char)(v);
2255 return 1;
2256 } else {
2257 return 0;
2258 }
2259 } else {
2260 PyErr_Clear();
2261 }
2262 if (val) {
2263 SWIG_type_error(errmsg, obj);
2264 }
2265 return 0;
2266 }
2267
2268
2269 SWIGINTERNSHORT unsigned char
2270 SWIG_As_unsigned_SS_char(PyObject* obj)
2271 {
2272 unsigned char v;
2273 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2274 /*
2275 this is needed to make valgrind/purify happier.
2276 */
2277 memset((void*)&v, 0, sizeof(unsigned char));
2278 }
2279 return v;
2280 }
2281
2282
2283 SWIGINTERNSHORT int
2284 SWIG_Check_unsigned_SS_char(PyObject* obj)
2285 {
2286 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2287 }
2288
2289
2290 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2291 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2292 /*@@*/
2293
2294
2295 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2296 if (width > 0 && height > 0)
2297 return new wxImage(width, height, clear);
2298 else
2299 return new wxImage;
2300 }
2301 static wxImage *new_wxImage(wxBitmap const &bitmap){
2302 return new wxImage(bitmap.ConvertToImage());
2303 }
2304 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2305 // Copy the source data so the wxImage can clean it up later
2306 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2307 if (copy == NULL) {
2308 PyErr_NoMemory();
2309 return NULL;
2310 }
2311 memcpy(copy, data, width*height*3);
2312 return new wxImage(width, height, copy, false);
2313 }
2314 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2315 // Copy the source data so the wxImage can clean it up later
2316 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2317 if (dcopy == NULL) {
2318 PyErr_NoMemory();
2319 return NULL;
2320 }
2321 memcpy(dcopy, data, width*height*3);
2322 unsigned char* acopy = (unsigned char*)malloc(width*height);
2323 if (acopy == NULL) {
2324 PyErr_NoMemory();
2325 return NULL;
2326 }
2327 memcpy(acopy, alpha, width*height);
2328
2329 return new wxImage(width, height, dcopy, acopy, false);
2330 }
2331 static wxSize wxImage_GetSize(wxImage *self){
2332 wxSize size(self->GetWidth(), self->GetHeight());
2333 return size;
2334 }
2335 static PyObject *wxImage_GetData(wxImage *self){
2336 unsigned char* data = self->GetData();
2337 int len = self->GetWidth() * self->GetHeight() * 3;
2338 PyObject* rv;
2339 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2340 return rv;
2341 }
2342 static void wxImage_SetData(wxImage *self,PyObject *data){
2343 unsigned char* dataPtr;
2344
2345 if (! PyString_Check(data)) {
2346 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2347 "Expected string object"));
2348 return /* NULL */ ;
2349 }
2350
2351 size_t len = self->GetWidth() * self->GetHeight() * 3;
2352 dataPtr = (unsigned char*) malloc(len);
2353 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2354 self->SetData(dataPtr);
2355 // wxImage takes ownership of dataPtr...
2356 }
2357 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2358 unsigned char* data = self->GetData();
2359 int len = self->GetWidth() * self->GetHeight() * 3;
2360 PyObject* rv;
2361 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2362 return rv;
2363 }
2364 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2365 unsigned char* buffer;
2366 int size;
2367
2368 bool blocked = wxPyBeginBlockThreads();
2369 if (!PyArg_Parse(data, "t#", &buffer, &size))
2370 goto done;
2371
2372 if (size != self->GetWidth() * self->GetHeight() * 3) {
2373 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2374 goto done;
2375 }
2376 self->SetData(buffer);
2377 done:
2378 wxPyEndBlockThreads(blocked);
2379 }
2380 static PyObject *wxImage_GetAlphaData(wxImage *self){
2381 unsigned char* data = self->GetAlpha();
2382 if (! data) {
2383 RETURN_NONE();
2384 } else {
2385 int len = self->GetWidth() * self->GetHeight();
2386 PyObject* rv;
2387 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2388 return rv;
2389 }
2390 }
2391 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2392 unsigned char* dataPtr;
2393
2394 if (! PyString_Check(data)) {
2395 PyErr_SetString(PyExc_TypeError, "Expected string object");
2396 return /* NULL */ ;
2397 }
2398
2399 size_t len = self->GetWidth() * self->GetHeight();
2400 dataPtr = (unsigned char*) malloc(len);
2401 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2402 self->SetAlpha(dataPtr);
2403 // wxImage takes ownership of dataPtr...
2404 }
2405 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2406 unsigned char* data = self->GetAlpha();
2407 int len = self->GetWidth() * self->GetHeight();
2408 PyObject* rv;
2409 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2410 return rv;
2411 }
2412 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2413 unsigned char* buffer;
2414 int size;
2415
2416 bool blocked = wxPyBeginBlockThreads();
2417 if (!PyArg_Parse(data, "t#", &buffer, &size))
2418 goto done;
2419
2420 if (size != self->GetWidth() * self->GetHeight()) {
2421 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2422 goto done;
2423 }
2424 self->SetAlpha(buffer);
2425 done:
2426 wxPyEndBlockThreads(blocked);
2427 }
2428
2429 SWIGINTERNSHORT unsigned long
2430 SWIG_As_unsigned_SS_long(PyObject* obj)
2431 {
2432 unsigned long v;
2433 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2434 /*
2435 this is needed to make valgrind/purify happier.
2436 */
2437 memset((void*)&v, 0, sizeof(unsigned long));
2438 }
2439 return v;
2440 }
2441
2442
2443 SWIGINTERNSHORT int
2444 SWIG_Check_unsigned_SS_long(PyObject* obj)
2445 {
2446 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2447 }
2448
2449 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2450 wxBitmap bitmap(*self, depth);
2451 return bitmap;
2452 }
2453 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2454 wxImage mono = self->ConvertToMono( red, green, blue );
2455 wxBitmap bitmap( mono, 1 );
2456 return bitmap;
2457 }
2458 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2459 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2460 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2461 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2462 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2463
2464 #include <wx/quantize.h>
2465
2466 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2467 return wxQuantize::Quantize(src, dest,
2468 //NULL, // palette
2469 desiredNoColours,
2470 NULL, // eightBitData
2471 flags);
2472 }
2473 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2474 if (PyCallable_Check(func)) {
2475 self->Connect(id, lastId, eventType,
2476 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2477 new wxPyCallback(func));
2478 }
2479 else if (func == Py_None) {
2480 self->Disconnect(id, lastId, eventType,
2481 (wxObjectEventFunction)
2482 &wxPyCallback::EventThunker);
2483 }
2484 else {
2485 wxPyBLOCK_THREADS(
2486 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2487 }
2488 }
2489 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2490 return self->Disconnect(id, lastId, eventType,
2491 (wxObjectEventFunction)
2492 &wxPyCallback::EventThunker);
2493 }
2494 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2495 if (_self && _self != Py_None) {
2496 self->SetClientObject(new wxPyOORClientData(_self, incref));
2497 }
2498 else {
2499 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2500 if (data) {
2501 self->SetClientObject(NULL); // This will delete it too
2502 }
2503 }
2504 }
2505
2506 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2507 #if wxUSE_UNICODE
2508 return self->GetUnicodeKey();
2509 #else
2510 return 0;
2511 #endif
2512 }
2513
2514 #if UINT_MAX < LONG_MAX
2515 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2516 #define SWIG_From_unsigned_SS_int SWIG_From_long
2517 /*@@*/
2518 #else
2519 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2520 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2521 /*@@*/
2522 #endif
2523
2524
2525 #if UINT_MAX != ULONG_MAX
2526 SWIGINTERN int
2527 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2528 {
2529 const char* errmsg = val ? "unsigned int" : (char*)0;
2530 unsigned long v;
2531 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2532 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2533 if (val) *val = (unsigned int)(v);
2534 return 1;
2535 }
2536 } else {
2537 PyErr_Clear();
2538 }
2539 if (val) {
2540 SWIG_type_error(errmsg, obj);
2541 }
2542 return 0;
2543 }
2544 #else
2545 SWIGINTERNSHORT unsigned int
2546 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2547 {
2548 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2549 }
2550 #endif
2551
2552
2553 SWIGINTERNSHORT unsigned int
2554 SWIG_As_unsigned_SS_int(PyObject* obj)
2555 {
2556 unsigned int v;
2557 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2558 /*
2559 this is needed to make valgrind/purify happier.
2560 */
2561 memset((void*)&v, 0, sizeof(unsigned int));
2562 }
2563 return v;
2564 }
2565
2566
2567 SWIGINTERNSHORT int
2568 SWIG_Check_unsigned_SS_int(PyObject* obj)
2569 {
2570 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2571 }
2572
2573 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2574 self->m_size = size;
2575 }
2576 static void wxMoveEvent_SetPosition(wxMoveEvent *self,wxPoint pos){
2577 self->m_pos = pos;
2578 }
2579 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2580 int count = self->GetNumberOfFiles();
2581 wxString* files = self->GetFiles();
2582 PyObject* list = PyList_New(count);
2583
2584 if (!list) {
2585 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2586 return NULL;
2587 }
2588
2589 for (int i=0; i<count; i++) {
2590 PyList_SetItem(list, i, wx2PyString(files[i]));
2591 }
2592 return list;
2593 }
2594
2595
2596 static wxPyApp *new_wxPyApp(){
2597 wxPythonApp = new wxPyApp();
2598 return wxPythonApp;
2599 }
2600 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2601
2602 void wxApp_CleanUp() {
2603 __wxPyCleanup();
2604 }
2605
2606
2607 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2608
2609
2610 SWIGINTERNSHORT int
2611 SWIG_AsCharPtr(PyObject *obj, char **val)
2612 {
2613 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2614 return 1;
2615 }
2616 if (val) {
2617 PyErr_Clear();
2618 SWIG_type_error("char *", obj);
2619 }
2620 return 0;
2621 }
2622
2623
2624 SWIGINTERN PyObject *
2625 SWIG_FromCharPtr(const char* cptr)
2626 {
2627 if (cptr) {
2628 size_t size = strlen(cptr);
2629 if (size > INT_MAX) {
2630 return SWIG_NewPointerObj((char*)(cptr),
2631 SWIG_TypeQuery("char *"), 0);
2632 } else {
2633 if (size != 0) {
2634 return PyString_FromStringAndSize(cptr, size);
2635 } else {
2636 return PyString_FromString(cptr);
2637 }
2638 }
2639 }
2640 Py_INCREF(Py_None);
2641 return Py_None;
2642 }
2643
2644
2645 #ifdef __WXMAC__
2646
2647 // A dummy class that raises an exception if used...
2648 class wxEventLoop
2649 {
2650 public:
2651 wxEventLoop() { wxPyRaiseNotImplemented(); }
2652 int Run() { return 0; }
2653 void Exit(int rc = 0) {}
2654 bool Pending() const { return false; }
2655 bool Dispatch() { return false; }
2656 bool IsRunning() const { return false; }
2657 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2658 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2659 };
2660
2661 #else
2662
2663 #include <wx/evtloop.h>
2664
2665 #endif
2666
2667
2668
2669 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2670 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2671 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2672 static PyObject *wxWindow_GetChildren(wxWindow *self){
2673 wxWindowList& list = self->GetChildren();
2674 return wxPy_ConvertList(&list);
2675 }
2676 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2677 #if wxUSE_HOTKEY
2678 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2679 #else
2680 return false;
2681 #endif
2682 }
2683 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2684
2685
2686
2687 return false;
2688
2689 }
2690 static long wxWindow_GetHandle(wxWindow *self){
2691 return wxPyGetWinHandle(self);
2692 }
2693 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2694 self->AssociateHandle((WXWidget)handle);
2695 }
2696
2697 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2698 return wxWindow::FindWindowById(id, parent);
2699 }
2700
2701 wxWindow* wxFindWindowByName( const wxString& name,
2702 const wxWindow *parent = NULL ) {
2703 return wxWindow::FindWindowByName(name, parent);
2704 }
2705
2706 wxWindow* wxFindWindowByLabel( const wxString& label,
2707 const wxWindow *parent = NULL ) {
2708 return wxWindow::FindWindowByLabel(label, parent);
2709 }
2710
2711
2712 #ifdef __WXMSW__
2713 #include <wx/msw/private.h> // to get wxGetWindowId
2714 #endif
2715
2716
2717 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2718 #ifdef __WXMSW__
2719 WXHWND hWnd = (WXHWND)_hWnd;
2720 long id = wxGetWindowId(hWnd);
2721 wxWindow* win = new wxWindow;
2722 parent->AddChild(win);
2723 win->SetEventHandler(win);
2724 win->SetHWND(hWnd);
2725 win->SetId(id);
2726 win->SubclassWin(hWnd);
2727 win->AdoptAttributesFromHWND();
2728 win->SetupColours();
2729 return win;
2730 #else
2731 wxPyRaiseNotImplemented();
2732 return NULL;
2733 #endif
2734 }
2735
2736
2737 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2738 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2739 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2740
2741 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2742
2743 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2744 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2745 wxMenuItemList& list = self->GetMenuItems();
2746 return wxPy_ConvertList(&list);
2747 }
2748 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2749 static const wxString wxPyControlNameStr(wxControlNameStr);
2750 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2751 if (clientData) {
2752 wxPyClientData* data = new wxPyClientData(clientData);
2753 return self->Append(item, data);
2754 } else
2755 return self->Append(item);
2756 }
2757 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2758 if (clientData) {
2759 wxPyClientData* data = new wxPyClientData(clientData);
2760 return self->Insert(item, pos, data);
2761 } else
2762 return self->Insert(item, pos);
2763 }
2764 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2765 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2766 if (data) {
2767 Py_INCREF(data->m_obj);
2768 return data->m_obj;
2769 } else {
2770 Py_INCREF(Py_None);
2771 return Py_None;
2772 }
2773 }
2774 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2775 wxPyClientData* data = new wxPyClientData(clientData);
2776 self->SetClientObject(n, data);
2777 }
2778
2779
2780 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2781 wxPyUserData* data = NULL;
2782 if ( userData ) {
2783 bool blocked = wxPyBeginBlockThreads();
2784 data = new wxPyUserData(userData);
2785 wxPyEndBlockThreads(blocked);
2786 }
2787 return new wxSizerItem(window, proportion, flag, border, data);
2788 }
2789 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2790 wxPyUserData* data = NULL;
2791 if ( userData ) {
2792 bool blocked = wxPyBeginBlockThreads();
2793 data = new wxPyUserData(userData);
2794 wxPyEndBlockThreads(blocked);
2795 }
2796 return new wxSizerItem(width, height, proportion, flag, border, data);
2797 }
2798 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2799 wxPyUserData* data = NULL;
2800 if ( userData ) {
2801 bool blocked = wxPyBeginBlockThreads();
2802 data = new wxPyUserData(userData);
2803 wxPyEndBlockThreads(blocked);
2804 }
2805 return new wxSizerItem(sizer, proportion, flag, border, data);
2806 }
2807
2808 #include <float.h>
2809 SWIGINTERN int
2810 SWIG_CheckDoubleInRange(double value, double min_value,
2811 double max_value, const char* errmsg)
2812 {
2813 if (value < min_value) {
2814 if (errmsg) {
2815 PyErr_Format(PyExc_OverflowError,
2816 "value %g is less than %s minimum %g",
2817 value, errmsg, min_value);
2818 }
2819 return 0;
2820 } else if (value > max_value) {
2821 if (errmsg) {
2822 PyErr_Format(PyExc_OverflowError,
2823 "value %g is greater than %s maximum %g",
2824 value, errmsg, max_value);
2825 }
2826 return 0;
2827 }
2828 return 1;
2829 }
2830
2831
2832 SWIGINTERN int
2833 SWIG_AsVal_float(PyObject *obj, float *val)
2834 {
2835 const char* errmsg = val ? "float" : (char*)0;
2836 double v;
2837 if (SWIG_AsVal_double(obj, &v)) {
2838 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2839 if (val) *val = (float)(v);
2840 return 1;
2841 } else {
2842 return 0;
2843 }
2844 } else {
2845 PyErr_Clear();
2846 }
2847 if (val) {
2848 SWIG_type_error(errmsg, obj);
2849 }
2850 return 0;
2851 }
2852
2853
2854 SWIGINTERNSHORT float
2855 SWIG_As_float(PyObject* obj)
2856 {
2857 float v;
2858 if (!SWIG_AsVal_float(obj, &v)) {
2859 /*
2860 this is needed to make valgrind/purify happier.
2861 */
2862 memset((void*)&v, 0, sizeof(float));
2863 }
2864 return v;
2865 }
2866
2867
2868 SWIGINTERNSHORT int
2869 SWIG_Check_float(PyObject* obj)
2870 {
2871 return SWIG_AsVal_float(obj, (float*)0);
2872 }
2873
2874
2875 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2876 #define SWIG_From_float PyFloat_FromDouble
2877 /*@@*/
2878
2879 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2880 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2881 if (data) {
2882 Py_INCREF(data->m_obj);
2883 return data->m_obj;
2884 } else {
2885 Py_INCREF(Py_None);
2886 return Py_None;
2887 }
2888 }
2889
2890 // Figure out the type of the sizer item
2891
2892 struct wxPySizerItemInfo {
2893 wxPySizerItemInfo()
2894 : window(NULL), sizer(NULL), gotSize(false),
2895 size(wxDefaultSize), gotPos(false), pos(-1)
2896 {}
2897
2898 wxWindow* window;
2899 wxSizer* sizer;
2900 bool gotSize;
2901 wxSize size;
2902 bool gotPos;
2903 int pos;
2904 };
2905
2906 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2907
2908 wxPySizerItemInfo info;
2909 wxSize size;
2910 wxSize* sizePtr = &size;
2911
2912 // Find out what the type of the item is
2913 // try wxWindow
2914 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2915 PyErr_Clear();
2916 info.window = NULL;
2917
2918 // try wxSizer
2919 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2920 PyErr_Clear();
2921 info.sizer = NULL;
2922
2923 // try wxSize or (w,h)
2924 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2925 info.size = *sizePtr;
2926 info.gotSize = true;
2927 }
2928
2929 // or a single int
2930 if (checkIdx && PyInt_Check(item)) {
2931 info.pos = PyInt_AsLong(item);
2932 info.gotPos = true;
2933 }
2934 }
2935 }
2936
2937 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2938 // no expected type, figure out what kind of error message to generate
2939 if ( !checkSize && !checkIdx )
2940 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2941 else if ( checkSize && !checkIdx )
2942 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2943 else if ( !checkSize && checkIdx)
2944 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2945 else
2946 // can this one happen?
2947 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2948 }
2949
2950 return info;
2951 }
2952
2953 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2954 if (!self->GetClientObject())
2955 self->SetClientObject(new wxPyOORClientData(_self));
2956 }
2957 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2958
2959 wxPyUserData* data = NULL;
2960 bool blocked = wxPyBeginBlockThreads();
2961 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2962 if ( userData && (info.window || info.sizer || info.gotSize) )
2963 data = new wxPyUserData(userData);
2964 wxPyEndBlockThreads(blocked);
2965
2966 // Now call the real Add method if a valid item type was found
2967 if ( info.window )
2968 return self->Add(info.window, proportion, flag, border, data);
2969 else if ( info.sizer )
2970 return self->Add(info.sizer, proportion, flag, border, data);
2971 else if (info.gotSize)
2972 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2973 proportion, flag, border, data);
2974 else
2975 return NULL;
2976 }
2977 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2978
2979 wxPyUserData* data = NULL;
2980 bool blocked = wxPyBeginBlockThreads();
2981 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2982 if ( userData && (info.window || info.sizer || info.gotSize) )
2983 data = new wxPyUserData(userData);
2984 wxPyEndBlockThreads(blocked);
2985
2986 // Now call the real Insert method if a valid item type was found
2987 if ( info.window )
2988 return self->Insert(before, info.window, proportion, flag, border, data);
2989 else if ( info.sizer )
2990 return self->Insert(before, info.sizer, proportion, flag, border, data);
2991 else if (info.gotSize)
2992 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2993 proportion, flag, border, data);
2994 else
2995 return NULL;
2996 }
2997 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2998
2999 wxPyUserData* data = NULL;
3000 bool blocked = wxPyBeginBlockThreads();
3001 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3002 if ( userData && (info.window || info.sizer || info.gotSize) )
3003 data = new wxPyUserData(userData);
3004 wxPyEndBlockThreads(blocked);
3005
3006 // Now call the real Prepend method if a valid item type was found
3007 if ( info.window )
3008 return self->Prepend(info.window, proportion, flag, border, data);
3009 else if ( info.sizer )
3010 return self->Prepend(info.sizer, proportion, flag, border, data);
3011 else if (info.gotSize)
3012 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3013 proportion, flag, border, data);
3014 else
3015 return NULL;
3016 }
3017 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3018 bool blocked = wxPyBeginBlockThreads();
3019 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3020 wxPyEndBlockThreads(blocked);
3021 if ( info.window )
3022 return self->Remove(info.window);
3023 else if ( info.sizer )
3024 return self->Remove(info.sizer);
3025 else if ( info.gotPos )
3026 return self->Remove(info.pos);
3027 else
3028 return false;
3029 }
3030 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3031 bool blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3033 wxPyEndBlockThreads(blocked);
3034 if ( info.window )
3035 return self->Detach(info.window);
3036 else if ( info.sizer )
3037 return self->Detach(info.sizer);
3038 else if ( info.gotPos )
3039 return self->Detach(info.pos);
3040 else
3041 return false;
3042 }
3043 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3044 bool blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3046 wxPyEndBlockThreads(blocked);
3047 if ( info.window )
3048 return self->GetItem(info.window);
3049 else if ( info.sizer )
3050 return self->GetItem(info.sizer);
3051 else if ( info.gotPos )
3052 return self->GetItem(info.pos);
3053 else
3054 return NULL;
3055 }
3056 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3057 bool blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 self->SetItemMinSize(info.window, size);
3062 else if ( info.sizer )
3063 self->SetItemMinSize(info.sizer, size);
3064 else if ( info.gotPos )
3065 self->SetItemMinSize(info.pos, size);
3066 }
3067 static PyObject *wxSizer_GetChildren(wxSizer *self){
3068 wxSizerItemList& list = self->GetChildren();
3069 return wxPy_ConvertList(&list);
3070 }
3071 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3072 bool blocked = wxPyBeginBlockThreads();
3073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3074 wxPyEndBlockThreads(blocked);
3075 if ( info.window )
3076 return self->Show(info.window, show, recursive);
3077 else if ( info.sizer )
3078 return self->Show(info.sizer, show, recursive);
3079 else if ( info.gotPos )
3080 return self->Show(info.pos, show);
3081 else
3082 return false;
3083 }
3084 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3085 bool blocked = wxPyBeginBlockThreads();
3086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3087 wxPyEndBlockThreads(blocked);
3088 if ( info.window )
3089 return self->IsShown(info.window);
3090 else if ( info.sizer )
3091 return self->IsShown(info.sizer);
3092 else if ( info.gotPos )
3093 return self->IsShown(info.pos);
3094 else
3095 return false;
3096 }
3097
3098 // See pyclasses.h
3099 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3100 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3101 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3102
3103
3104
3105
3106 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3107 {
3108 if (source == Py_None) {
3109 **obj = wxGBPosition(-1,-1);
3110 return true;
3111 }
3112 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3113 }
3114
3115 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3116 {
3117 if (source == Py_None) {
3118 **obj = wxGBSpan(-1,-1);
3119 return true;
3120 }
3121 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3122 }
3123
3124
3125 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3126 self->SetRow(row);
3127 self->SetCol(col);
3128 }
3129 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3130 bool blocked = wxPyBeginBlockThreads();
3131 PyObject* tup = PyTuple_New(2);
3132 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3133 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3134 wxPyEndBlockThreads(blocked);
3135 return tup;
3136 }
3137 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3138 self->SetRowspan(rowspan);
3139 self->SetColspan(colspan);
3140 }
3141 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3142 bool blocked = wxPyBeginBlockThreads();
3143 PyObject* tup = PyTuple_New(2);
3144 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3145 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3146 wxPyEndBlockThreads(blocked);
3147 return tup;
3148 }
3149 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3150 wxPyUserData* data = NULL;
3151 if ( userData ) {
3152 bool blocked = wxPyBeginBlockThreads();
3153 data = new wxPyUserData(userData);
3154 wxPyEndBlockThreads(blocked);
3155 }
3156 return new wxGBSizerItem(window, pos, span, flag, border, data);
3157 }
3158 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3159 wxPyUserData* data = NULL;
3160 if ( userData ) {
3161 bool blocked = wxPyBeginBlockThreads();
3162 data = new wxPyUserData(userData);
3163 wxPyEndBlockThreads(blocked);
3164 }
3165 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3166 }
3167 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3168 wxPyUserData* data = NULL;
3169 if ( userData ) {
3170 bool blocked = wxPyBeginBlockThreads();
3171 data = new wxPyUserData(userData);
3172 wxPyEndBlockThreads(blocked);
3173 }
3174 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3175 }
3176 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3177 int row, col;
3178 self->GetEndPos(row, col);
3179 return wxGBPosition(row, col);
3180 }
3181 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3182
3183 wxPyUserData* data = NULL;
3184 bool blocked = wxPyBeginBlockThreads();
3185 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3186 if ( userData && (info.window || info.sizer || info.gotSize) )
3187 data = new wxPyUserData(userData);
3188 wxPyEndBlockThreads(blocked);
3189
3190 // Now call the real Add method if a valid item type was found
3191 if ( info.window )
3192 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3193 else if ( info.sizer )
3194 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3195 else if (info.gotSize)
3196 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3197 pos, span, flag, border, data);
3198 return NULL;
3199 }
3200
3201
3202 #ifdef __cplusplus
3203 extern "C" {
3204 #endif
3205 static int _wrap_EmptyString_set(PyObject *) {
3206 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3207 return 1;
3208 }
3209
3210
3211 static PyObject *_wrap_EmptyString_get(void) {
3212 PyObject *pyobj;
3213
3214 {
3215 #if wxUSE_UNICODE
3216 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3217 #else
3218 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3219 #endif
3220 }
3221 return pyobj;
3222 }
3223
3224
3225 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3226 PyObject *resultobj;
3227 wxObject *arg1 = (wxObject *) 0 ;
3228 wxString result;
3229 PyObject * obj0 = 0 ;
3230 char *kwnames[] = {
3231 (char *) "self", NULL
3232 };
3233
3234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3236 if (SWIG_arg_fail(1)) SWIG_fail;
3237 {
3238 PyThreadState* __tstate = wxPyBeginAllowThreads();
3239 result = wxObject_GetClassName(arg1);
3240
3241 wxPyEndAllowThreads(__tstate);
3242 if (PyErr_Occurred()) SWIG_fail;
3243 }
3244 {
3245 #if wxUSE_UNICODE
3246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3247 #else
3248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3249 #endif
3250 }
3251 return resultobj;
3252 fail:
3253 return NULL;
3254 }
3255
3256
3257 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3258 PyObject *resultobj;
3259 wxObject *arg1 = (wxObject *) 0 ;
3260 PyObject * obj0 = 0 ;
3261 char *kwnames[] = {
3262 (char *) "self", NULL
3263 };
3264
3265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3267 if (SWIG_arg_fail(1)) SWIG_fail;
3268 {
3269 PyThreadState* __tstate = wxPyBeginAllowThreads();
3270 wxObject_Destroy(arg1);
3271
3272 wxPyEndAllowThreads(__tstate);
3273 if (PyErr_Occurred()) SWIG_fail;
3274 }
3275 Py_INCREF(Py_None); resultobj = Py_None;
3276 return resultobj;
3277 fail:
3278 return NULL;
3279 }
3280
3281
3282 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3283 PyObject *obj;
3284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3285 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3286 Py_INCREF(obj);
3287 return Py_BuildValue((char *)"");
3288 }
3289 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3290 PyObject *resultobj;
3291 wxSize *arg1 = (wxSize *) 0 ;
3292 int arg2 ;
3293 PyObject * obj0 = 0 ;
3294 PyObject * obj1 = 0 ;
3295 char *kwnames[] = {
3296 (char *) "self",(char *) "x", NULL
3297 };
3298
3299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3301 if (SWIG_arg_fail(1)) SWIG_fail;
3302 {
3303 arg2 = (int)(SWIG_As_int(obj1));
3304 if (SWIG_arg_fail(2)) SWIG_fail;
3305 }
3306 if (arg1) (arg1)->x = arg2;
3307
3308 Py_INCREF(Py_None); resultobj = Py_None;
3309 return resultobj;
3310 fail:
3311 return NULL;
3312 }
3313
3314
3315 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxSize *arg1 = (wxSize *) 0 ;
3318 int result;
3319 PyObject * obj0 = 0 ;
3320 char *kwnames[] = {
3321 (char *) "self", NULL
3322 };
3323
3324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3326 if (SWIG_arg_fail(1)) SWIG_fail;
3327 result = (int) ((arg1)->x);
3328
3329 {
3330 resultobj = SWIG_From_int((int)(result));
3331 }
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3339 PyObject *resultobj;
3340 wxSize *arg1 = (wxSize *) 0 ;
3341 int arg2 ;
3342 PyObject * obj0 = 0 ;
3343 PyObject * obj1 = 0 ;
3344 char *kwnames[] = {
3345 (char *) "self",(char *) "y", NULL
3346 };
3347
3348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3350 if (SWIG_arg_fail(1)) SWIG_fail;
3351 {
3352 arg2 = (int)(SWIG_As_int(obj1));
3353 if (SWIG_arg_fail(2)) SWIG_fail;
3354 }
3355 if (arg1) (arg1)->y = arg2;
3356
3357 Py_INCREF(Py_None); resultobj = Py_None;
3358 return resultobj;
3359 fail:
3360 return NULL;
3361 }
3362
3363
3364 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3365 PyObject *resultobj;
3366 wxSize *arg1 = (wxSize *) 0 ;
3367 int result;
3368 PyObject * obj0 = 0 ;
3369 char *kwnames[] = {
3370 (char *) "self", NULL
3371 };
3372
3373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3375 if (SWIG_arg_fail(1)) SWIG_fail;
3376 result = (int) ((arg1)->y);
3377
3378 {
3379 resultobj = SWIG_From_int((int)(result));
3380 }
3381 return resultobj;
3382 fail:
3383 return NULL;
3384 }
3385
3386
3387 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3388 PyObject *resultobj;
3389 int arg1 = (int) 0 ;
3390 int arg2 = (int) 0 ;
3391 wxSize *result;
3392 PyObject * obj0 = 0 ;
3393 PyObject * obj1 = 0 ;
3394 char *kwnames[] = {
3395 (char *) "w",(char *) "h", NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3399 if (obj0) {
3400 {
3401 arg1 = (int)(SWIG_As_int(obj0));
3402 if (SWIG_arg_fail(1)) SWIG_fail;
3403 }
3404 }
3405 if (obj1) {
3406 {
3407 arg2 = (int)(SWIG_As_int(obj1));
3408 if (SWIG_arg_fail(2)) SWIG_fail;
3409 }
3410 }
3411 {
3412 PyThreadState* __tstate = wxPyBeginAllowThreads();
3413 result = (wxSize *)new wxSize(arg1,arg2);
3414
3415 wxPyEndAllowThreads(__tstate);
3416 if (PyErr_Occurred()) SWIG_fail;
3417 }
3418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3419 return resultobj;
3420 fail:
3421 return NULL;
3422 }
3423
3424
3425 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3426 PyObject *resultobj;
3427 wxSize *arg1 = (wxSize *) 0 ;
3428 PyObject * obj0 = 0 ;
3429 char *kwnames[] = {
3430 (char *) "self", NULL
3431 };
3432
3433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3435 if (SWIG_arg_fail(1)) SWIG_fail;
3436 {
3437 PyThreadState* __tstate = wxPyBeginAllowThreads();
3438 delete arg1;
3439
3440 wxPyEndAllowThreads(__tstate);
3441 if (PyErr_Occurred()) SWIG_fail;
3442 }
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 return resultobj;
3445 fail:
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxSize *arg1 = (wxSize *) 0 ;
3453 wxSize *arg2 = 0 ;
3454 bool result;
3455 wxSize temp2 ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self",(char *) "sz", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 arg2 = &temp2;
3467 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3468 }
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 {
3477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3478 }
3479 return resultobj;
3480 fail:
3481 return NULL;
3482 }
3483
3484
3485 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3486 PyObject *resultobj;
3487 wxSize *arg1 = (wxSize *) 0 ;
3488 wxSize *arg2 = 0 ;
3489 bool result;
3490 wxSize temp2 ;
3491 PyObject * obj0 = 0 ;
3492 PyObject * obj1 = 0 ;
3493 char *kwnames[] = {
3494 (char *) "self",(char *) "sz", NULL
3495 };
3496
3497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3499 if (SWIG_arg_fail(1)) SWIG_fail;
3500 {
3501 arg2 = &temp2;
3502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3503 }
3504 {
3505 PyThreadState* __tstate = wxPyBeginAllowThreads();
3506 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3507
3508 wxPyEndAllowThreads(__tstate);
3509 if (PyErr_Occurred()) SWIG_fail;
3510 }
3511 {
3512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3513 }
3514 return resultobj;
3515 fail:
3516 return NULL;
3517 }
3518
3519
3520 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3521 PyObject *resultobj;
3522 wxSize *arg1 = (wxSize *) 0 ;
3523 wxSize *arg2 = 0 ;
3524 wxSize result;
3525 wxSize temp2 ;
3526 PyObject * obj0 = 0 ;
3527 PyObject * obj1 = 0 ;
3528 char *kwnames[] = {
3529 (char *) "self",(char *) "sz", NULL
3530 };
3531
3532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3534 if (SWIG_arg_fail(1)) SWIG_fail;
3535 {
3536 arg2 = &temp2;
3537 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3538 }
3539 {
3540 PyThreadState* __tstate = wxPyBeginAllowThreads();
3541 result = (arg1)->operator +((wxSize const &)*arg2);
3542
3543 wxPyEndAllowThreads(__tstate);
3544 if (PyErr_Occurred()) SWIG_fail;
3545 }
3546 {
3547 wxSize * resultptr;
3548 resultptr = new wxSize((wxSize &)(result));
3549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxSize *arg1 = (wxSize *) 0 ;
3560 wxSize *arg2 = 0 ;
3561 wxSize result;
3562 wxSize temp2 ;
3563 PyObject * obj0 = 0 ;
3564 PyObject * obj1 = 0 ;
3565 char *kwnames[] = {
3566 (char *) "self",(char *) "sz", NULL
3567 };
3568
3569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(1)) SWIG_fail;
3572 {
3573 arg2 = &temp2;
3574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3575 }
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (arg1)->operator -((wxSize const &)*arg2);
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 {
3584 wxSize * resultptr;
3585 resultptr = new wxSize((wxSize &)(result));
3586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3587 }
3588 return resultobj;
3589 fail:
3590 return NULL;
3591 }
3592
3593
3594 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3595 PyObject *resultobj;
3596 wxSize *arg1 = (wxSize *) 0 ;
3597 wxSize *arg2 = 0 ;
3598 wxSize temp2 ;
3599 PyObject * obj0 = 0 ;
3600 PyObject * obj1 = 0 ;
3601 char *kwnames[] = {
3602 (char *) "self",(char *) "sz", NULL
3603 };
3604
3605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(1)) SWIG_fail;
3608 {
3609 arg2 = &temp2;
3610 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3611 }
3612 {
3613 PyThreadState* __tstate = wxPyBeginAllowThreads();
3614 (arg1)->IncTo((wxSize const &)*arg2);
3615
3616 wxPyEndAllowThreads(__tstate);
3617 if (PyErr_Occurred()) SWIG_fail;
3618 }
3619 Py_INCREF(Py_None); resultobj = Py_None;
3620 return resultobj;
3621 fail:
3622 return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 wxSize *arg1 = (wxSize *) 0 ;
3629 wxSize *arg2 = 0 ;
3630 wxSize temp2 ;
3631 PyObject * obj0 = 0 ;
3632 PyObject * obj1 = 0 ;
3633 char *kwnames[] = {
3634 (char *) "self",(char *) "sz", NULL
3635 };
3636
3637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3639 if (SWIG_arg_fail(1)) SWIG_fail;
3640 {
3641 arg2 = &temp2;
3642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3643 }
3644 {
3645 PyThreadState* __tstate = wxPyBeginAllowThreads();
3646 (arg1)->DecTo((wxSize const &)*arg2);
3647
3648 wxPyEndAllowThreads(__tstate);
3649 if (PyErr_Occurred()) SWIG_fail;
3650 }
3651 Py_INCREF(Py_None); resultobj = Py_None;
3652 return resultobj;
3653 fail:
3654 return NULL;
3655 }
3656
3657
3658 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3659 PyObject *resultobj;
3660 wxSize *arg1 = (wxSize *) 0 ;
3661 int arg2 ;
3662 int arg3 ;
3663 PyObject * obj0 = 0 ;
3664 PyObject * obj1 = 0 ;
3665 PyObject * obj2 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "self",(char *) "w",(char *) "h", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3672 if (SWIG_arg_fail(1)) SWIG_fail;
3673 {
3674 arg2 = (int)(SWIG_As_int(obj1));
3675 if (SWIG_arg_fail(2)) SWIG_fail;
3676 }
3677 {
3678 arg3 = (int)(SWIG_As_int(obj2));
3679 if (SWIG_arg_fail(3)) SWIG_fail;
3680 }
3681 {
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 (arg1)->Set(arg2,arg3);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 Py_INCREF(Py_None); resultobj = Py_None;
3689 return resultobj;
3690 fail:
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 wxSize *arg1 = (wxSize *) 0 ;
3698 int arg2 ;
3699 PyObject * obj0 = 0 ;
3700 PyObject * obj1 = 0 ;
3701 char *kwnames[] = {
3702 (char *) "self",(char *) "w", NULL
3703 };
3704
3705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3707 if (SWIG_arg_fail(1)) SWIG_fail;
3708 {
3709 arg2 = (int)(SWIG_As_int(obj1));
3710 if (SWIG_arg_fail(2)) SWIG_fail;
3711 }
3712 {
3713 PyThreadState* __tstate = wxPyBeginAllowThreads();
3714 (arg1)->SetWidth(arg2);
3715
3716 wxPyEndAllowThreads(__tstate);
3717 if (PyErr_Occurred()) SWIG_fail;
3718 }
3719 Py_INCREF(Py_None); resultobj = Py_None;
3720 return resultobj;
3721 fail:
3722 return NULL;
3723 }
3724
3725
3726 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3727 PyObject *resultobj;
3728 wxSize *arg1 = (wxSize *) 0 ;
3729 int arg2 ;
3730 PyObject * obj0 = 0 ;
3731 PyObject * obj1 = 0 ;
3732 char *kwnames[] = {
3733 (char *) "self",(char *) "h", NULL
3734 };
3735
3736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3738 if (SWIG_arg_fail(1)) SWIG_fail;
3739 {
3740 arg2 = (int)(SWIG_As_int(obj1));
3741 if (SWIG_arg_fail(2)) SWIG_fail;
3742 }
3743 {
3744 PyThreadState* __tstate = wxPyBeginAllowThreads();
3745 (arg1)->SetHeight(arg2);
3746
3747 wxPyEndAllowThreads(__tstate);
3748 if (PyErr_Occurred()) SWIG_fail;
3749 }
3750 Py_INCREF(Py_None); resultobj = Py_None;
3751 return resultobj;
3752 fail:
3753 return NULL;
3754 }
3755
3756
3757 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3758 PyObject *resultobj;
3759 wxSize *arg1 = (wxSize *) 0 ;
3760 int result;
3761 PyObject * obj0 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (int)((wxSize const *)arg1)->GetWidth();
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = SWIG_From_int((int)(result));
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 wxSize *arg1 = (wxSize *) 0 ;
3788 int result;
3789 PyObject * obj0 = 0 ;
3790 char *kwnames[] = {
3791 (char *) "self", NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3796 if (SWIG_arg_fail(1)) SWIG_fail;
3797 {
3798 PyThreadState* __tstate = wxPyBeginAllowThreads();
3799 result = (int)((wxSize const *)arg1)->GetHeight();
3800
3801 wxPyEndAllowThreads(__tstate);
3802 if (PyErr_Occurred()) SWIG_fail;
3803 }
3804 {
3805 resultobj = SWIG_From_int((int)(result));
3806 }
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 bool result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 wxSize *arg2 = 0 ;
3845 wxSize temp2 ;
3846 PyObject * obj0 = 0 ;
3847 PyObject * obj1 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self",(char *) "size", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 arg2 = &temp2;
3857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3858 }
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 (arg1)->SetDefaults((wxSize const &)*arg2);
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 Py_INCREF(Py_None); resultobj = Py_None;
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj;
3875 wxSize *arg1 = (wxSize *) 0 ;
3876 PyObject *result;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 result = (PyObject *)wxSize_Get(arg1);
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 resultobj = result;
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3900 PyObject *obj;
3901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3902 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3903 Py_INCREF(obj);
3904 return Py_BuildValue((char *)"");
3905 }
3906 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3907 PyObject *resultobj;
3908 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3909 double arg2 ;
3910 PyObject * obj0 = 0 ;
3911 PyObject * obj1 = 0 ;
3912 char *kwnames[] = {
3913 (char *) "self",(char *) "x", NULL
3914 };
3915
3916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3918 if (SWIG_arg_fail(1)) SWIG_fail;
3919 {
3920 arg2 = (double)(SWIG_As_double(obj1));
3921 if (SWIG_arg_fail(2)) SWIG_fail;
3922 }
3923 if (arg1) (arg1)->x = arg2;
3924
3925 Py_INCREF(Py_None); resultobj = Py_None;
3926 return resultobj;
3927 fail:
3928 return NULL;
3929 }
3930
3931
3932 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3933 PyObject *resultobj;
3934 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3935 double result;
3936 PyObject * obj0 = 0 ;
3937 char *kwnames[] = {
3938 (char *) "self", NULL
3939 };
3940
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3943 if (SWIG_arg_fail(1)) SWIG_fail;
3944 result = (double) ((arg1)->x);
3945
3946 {
3947 resultobj = SWIG_From_double((double)(result));
3948 }
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3956 PyObject *resultobj;
3957 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3958 double arg2 ;
3959 PyObject * obj0 = 0 ;
3960 PyObject * obj1 = 0 ;
3961 char *kwnames[] = {
3962 (char *) "self",(char *) "y", NULL
3963 };
3964
3965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3967 if (SWIG_arg_fail(1)) SWIG_fail;
3968 {
3969 arg2 = (double)(SWIG_As_double(obj1));
3970 if (SWIG_arg_fail(2)) SWIG_fail;
3971 }
3972 if (arg1) (arg1)->y = arg2;
3973
3974 Py_INCREF(Py_None); resultobj = Py_None;
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3984 double result;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 result = (double) ((arg1)->y);
3994
3995 {
3996 resultobj = SWIG_From_double((double)(result));
3997 }
3998 return resultobj;
3999 fail:
4000 return NULL;
4001 }
4002
4003
4004 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4005 PyObject *resultobj;
4006 double arg1 = (double) 0.0 ;
4007 double arg2 = (double) 0.0 ;
4008 wxRealPoint *result;
4009 PyObject * obj0 = 0 ;
4010 PyObject * obj1 = 0 ;
4011 char *kwnames[] = {
4012 (char *) "x",(char *) "y", NULL
4013 };
4014
4015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4016 if (obj0) {
4017 {
4018 arg1 = (double)(SWIG_As_double(obj0));
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 }
4021 }
4022 if (obj1) {
4023 {
4024 arg2 = (double)(SWIG_As_double(obj1));
4025 if (SWIG_arg_fail(2)) SWIG_fail;
4026 }
4027 }
4028 {
4029 PyThreadState* __tstate = wxPyBeginAllowThreads();
4030 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4031
4032 wxPyEndAllowThreads(__tstate);
4033 if (PyErr_Occurred()) SWIG_fail;
4034 }
4035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4036 return resultobj;
4037 fail:
4038 return NULL;
4039 }
4040
4041
4042 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4043 PyObject *resultobj;
4044 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4045 PyObject * obj0 = 0 ;
4046 char *kwnames[] = {
4047 (char *) "self", NULL
4048 };
4049
4050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4052 if (SWIG_arg_fail(1)) SWIG_fail;
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 delete arg1;
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4070 wxRealPoint *arg2 = 0 ;
4071 bool result;
4072 wxRealPoint temp2 ;
4073 PyObject * obj0 = 0 ;
4074 PyObject * obj1 = 0 ;
4075 char *kwnames[] = {
4076 (char *) "self",(char *) "pt", NULL
4077 };
4078
4079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 {
4083 arg2 = &temp2;
4084 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4085 }
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4089
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 {
4094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4095 }
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4105 wxRealPoint *arg2 = 0 ;
4106 bool result;
4107 wxRealPoint temp2 ;
4108 PyObject * obj0 = 0 ;
4109 PyObject * obj1 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "self",(char *) "pt", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4116 if (SWIG_arg_fail(1)) SWIG_fail;
4117 {
4118 arg2 = &temp2;
4119 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 {
4129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4130 }
4131 return resultobj;
4132 fail:
4133 return NULL;
4134 }
4135
4136
4137 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4138 PyObject *resultobj;
4139 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4140 wxRealPoint *arg2 = 0 ;
4141 wxRealPoint result;
4142 wxRealPoint temp2 ;
4143 PyObject * obj0 = 0 ;
4144 PyObject * obj1 = 0 ;
4145 char *kwnames[] = {
4146 (char *) "self",(char *) "pt", NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4151 if (SWIG_arg_fail(1)) SWIG_fail;
4152 {
4153 arg2 = &temp2;
4154 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4155 }
4156 {
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4159
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 {
4164 wxRealPoint * resultptr;
4165 resultptr = new wxRealPoint((wxRealPoint &)(result));
4166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4167 }
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj;
4176 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4177 wxRealPoint *arg2 = 0 ;
4178 wxRealPoint result;
4179 wxRealPoint temp2 ;
4180 PyObject * obj0 = 0 ;
4181 PyObject * obj1 = 0 ;
4182 char *kwnames[] = {
4183 (char *) "self",(char *) "pt", NULL
4184 };
4185
4186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4188 if (SWIG_arg_fail(1)) SWIG_fail;
4189 {
4190 arg2 = &temp2;
4191 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4192 }
4193 {
4194 PyThreadState* __tstate = wxPyBeginAllowThreads();
4195 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4196
4197 wxPyEndAllowThreads(__tstate);
4198 if (PyErr_Occurred()) SWIG_fail;
4199 }
4200 {
4201 wxRealPoint * resultptr;
4202 resultptr = new wxRealPoint((wxRealPoint &)(result));
4203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4204 }
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj;
4213 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4214 double arg2 ;
4215 double arg3 ;
4216 PyObject * obj0 = 0 ;
4217 PyObject * obj1 = 0 ;
4218 PyObject * obj2 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "self",(char *) "x",(char *) "y", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4225 if (SWIG_arg_fail(1)) SWIG_fail;
4226 {
4227 arg2 = (double)(SWIG_As_double(obj1));
4228 if (SWIG_arg_fail(2)) SWIG_fail;
4229 }
4230 {
4231 arg3 = (double)(SWIG_As_double(obj2));
4232 if (SWIG_arg_fail(3)) SWIG_fail;
4233 }
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 wxRealPoint_Set(arg1,arg2,arg3);
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 Py_INCREF(Py_None); resultobj = Py_None;
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj;
4250 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4251 PyObject *result;
4252 PyObject * obj0 = 0 ;
4253 char *kwnames[] = {
4254 (char *) "self", NULL
4255 };
4256
4257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = (PyObject *)wxRealPoint_Get(arg1);
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 resultobj = result;
4268 return resultobj;
4269 fail:
4270 return NULL;
4271 }
4272
4273
4274 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4275 PyObject *obj;
4276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4277 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4278 Py_INCREF(obj);
4279 return Py_BuildValue((char *)"");
4280 }
4281 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxPoint *arg1 = (wxPoint *) 0 ;
4284 int arg2 ;
4285 PyObject * obj0 = 0 ;
4286 PyObject * obj1 = 0 ;
4287 char *kwnames[] = {
4288 (char *) "self",(char *) "x", NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4293 if (SWIG_arg_fail(1)) SWIG_fail;
4294 {
4295 arg2 = (int)(SWIG_As_int(obj1));
4296 if (SWIG_arg_fail(2)) SWIG_fail;
4297 }
4298 if (arg1) (arg1)->x = arg2;
4299
4300 Py_INCREF(Py_None); resultobj = Py_None;
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxPoint *arg1 = (wxPoint *) 0 ;
4310 int result;
4311 PyObject * obj0 = 0 ;
4312 char *kwnames[] = {
4313 (char *) "self", NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4318 if (SWIG_arg_fail(1)) SWIG_fail;
4319 result = (int) ((arg1)->x);
4320
4321 {
4322 resultobj = SWIG_From_int((int)(result));
4323 }
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj;
4332 wxPoint *arg1 = (wxPoint *) 0 ;
4333 int arg2 ;
4334 PyObject * obj0 = 0 ;
4335 PyObject * obj1 = 0 ;
4336 char *kwnames[] = {
4337 (char *) "self",(char *) "y", NULL
4338 };
4339
4340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4342 if (SWIG_arg_fail(1)) SWIG_fail;
4343 {
4344 arg2 = (int)(SWIG_As_int(obj1));
4345 if (SWIG_arg_fail(2)) SWIG_fail;
4346 }
4347 if (arg1) (arg1)->y = arg2;
4348
4349 Py_INCREF(Py_None); resultobj = Py_None;
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxPoint *arg1 = (wxPoint *) 0 ;
4359 int result;
4360 PyObject * obj0 = 0 ;
4361 char *kwnames[] = {
4362 (char *) "self", NULL
4363 };
4364
4365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4367 if (SWIG_arg_fail(1)) SWIG_fail;
4368 result = (int) ((arg1)->y);
4369
4370 {
4371 resultobj = SWIG_From_int((int)(result));
4372 }
4373 return resultobj;
4374 fail:
4375 return NULL;
4376 }
4377
4378
4379 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4380 PyObject *resultobj;
4381 int arg1 = (int) 0 ;
4382 int arg2 = (int) 0 ;
4383 wxPoint *result;
4384 PyObject * obj0 = 0 ;
4385 PyObject * obj1 = 0 ;
4386 char *kwnames[] = {
4387 (char *) "x",(char *) "y", NULL
4388 };
4389
4390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4391 if (obj0) {
4392 {
4393 arg1 = (int)(SWIG_As_int(obj0));
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 }
4396 }
4397 if (obj1) {
4398 {
4399 arg2 = (int)(SWIG_As_int(obj1));
4400 if (SWIG_arg_fail(2)) SWIG_fail;
4401 }
4402 }
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = (wxPoint *)new wxPoint(arg1,arg2);
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4411 return resultobj;
4412 fail:
4413 return NULL;
4414 }
4415
4416
4417 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4418 PyObject *resultobj;
4419 wxPoint *arg1 = (wxPoint *) 0 ;
4420 PyObject * obj0 = 0 ;
4421 char *kwnames[] = {
4422 (char *) "self", NULL
4423 };
4424
4425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4427 if (SWIG_arg_fail(1)) SWIG_fail;
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 delete arg1;
4431
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 Py_INCREF(Py_None); resultobj = Py_None;
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj;
4444 wxPoint *arg1 = (wxPoint *) 0 ;
4445 wxPoint *arg2 = 0 ;
4446 bool result;
4447 wxPoint temp2 ;
4448 PyObject * obj0 = 0 ;
4449 PyObject * obj1 = 0 ;
4450 char *kwnames[] = {
4451 (char *) "self",(char *) "pt", NULL
4452 };
4453
4454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4456 if (SWIG_arg_fail(1)) SWIG_fail;
4457 {
4458 arg2 = &temp2;
4459 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4460 }
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 {
4469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4470 }
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj;
4479 wxPoint *arg1 = (wxPoint *) 0 ;
4480 wxPoint *arg2 = 0 ;
4481 bool result;
4482 wxPoint temp2 ;
4483 PyObject * obj0 = 0 ;
4484 PyObject * obj1 = 0 ;
4485 char *kwnames[] = {
4486 (char *) "self",(char *) "pt", NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4491 if (SWIG_arg_fail(1)) SWIG_fail;
4492 {
4493 arg2 = &temp2;
4494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4495 }
4496 {
4497 PyThreadState* __tstate = wxPyBeginAllowThreads();
4498 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4499
4500 wxPyEndAllowThreads(__tstate);
4501 if (PyErr_Occurred()) SWIG_fail;
4502 }
4503 {
4504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4505 }
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4513 PyObject *resultobj;
4514 wxPoint *arg1 = (wxPoint *) 0 ;
4515 wxPoint *arg2 = 0 ;
4516 wxPoint result;
4517 wxPoint temp2 ;
4518 PyObject * obj0 = 0 ;
4519 PyObject * obj1 = 0 ;
4520 char *kwnames[] = {
4521 (char *) "self",(char *) "pt", NULL
4522 };
4523
4524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4526 if (SWIG_arg_fail(1)) SWIG_fail;
4527 {
4528 arg2 = &temp2;
4529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (arg1)->operator +((wxPoint const &)*arg2);
4534
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 wxPoint * resultptr;
4540 resultptr = new wxPoint((wxPoint &)(result));
4541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4542 }
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4550 PyObject *resultobj;
4551 wxPoint *arg1 = (wxPoint *) 0 ;
4552 wxPoint *arg2 = 0 ;
4553 wxPoint result;
4554 wxPoint temp2 ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 char *kwnames[] = {
4558 (char *) "self",(char *) "pt", NULL
4559 };
4560
4561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4563 if (SWIG_arg_fail(1)) SWIG_fail;
4564 {
4565 arg2 = &temp2;
4566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = (arg1)->operator -((wxPoint const &)*arg2);
4571
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 {
4576 wxPoint * resultptr;
4577 resultptr = new wxPoint((wxPoint &)(result));
4578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4579 }
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj;
4588 wxPoint *arg1 = (wxPoint *) 0 ;
4589 wxPoint *arg2 = 0 ;
4590 wxPoint *result;
4591 wxPoint temp2 ;
4592 PyObject * obj0 = 0 ;
4593 PyObject * obj1 = 0 ;
4594 char *kwnames[] = {
4595 (char *) "self",(char *) "pt", NULL
4596 };
4597
4598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4600 if (SWIG_arg_fail(1)) SWIG_fail;
4601 {
4602 arg2 = &temp2;
4603 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4604 }
4605 {
4606 PyThreadState* __tstate = wxPyBeginAllowThreads();
4607 {
4608 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4609 result = (wxPoint *) &_result_ref;
4610 }
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj;
4624 wxPoint *arg1 = (wxPoint *) 0 ;
4625 wxPoint *arg2 = 0 ;
4626 wxPoint *result;
4627 wxPoint temp2 ;
4628 PyObject * obj0 = 0 ;
4629 PyObject * obj1 = 0 ;
4630 char *kwnames[] = {
4631 (char *) "self",(char *) "pt", NULL
4632 };
4633
4634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4636 if (SWIG_arg_fail(1)) SWIG_fail;
4637 {
4638 arg2 = &temp2;
4639 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4640 }
4641 {
4642 PyThreadState* __tstate = wxPyBeginAllowThreads();
4643 {
4644 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4645 result = (wxPoint *) &_result_ref;
4646 }
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxPoint *arg1 = (wxPoint *) 0 ;
4661 long arg2 ;
4662 long arg3 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 PyObject * obj2 = 0 ;
4666 char *kwnames[] = {
4667 (char *) "self",(char *) "x",(char *) "y", NULL
4668 };
4669
4670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4672 if (SWIG_arg_fail(1)) SWIG_fail;
4673 {
4674 arg2 = (long)(SWIG_As_long(obj1));
4675 if (SWIG_arg_fail(2)) SWIG_fail;
4676 }
4677 {
4678 arg3 = (long)(SWIG_As_long(obj2));
4679 if (SWIG_arg_fail(3)) SWIG_fail;
4680 }
4681 {
4682 PyThreadState* __tstate = wxPyBeginAllowThreads();
4683 wxPoint_Set(arg1,arg2,arg3);
4684
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 Py_INCREF(Py_None); resultobj = Py_None;
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4696 PyObject *resultobj;
4697 wxPoint *arg1 = (wxPoint *) 0 ;
4698 PyObject *result;
4699 PyObject * obj0 = 0 ;
4700 char *kwnames[] = {
4701 (char *) "self", NULL
4702 };
4703
4704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4706 if (SWIG_arg_fail(1)) SWIG_fail;
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 result = (PyObject *)wxPoint_Get(arg1);
4710
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = result;
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4722 PyObject *obj;
4723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4724 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4725 Py_INCREF(obj);
4726 return Py_BuildValue((char *)"");
4727 }
4728 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4729 PyObject *resultobj;
4730 int arg1 = (int) 0 ;
4731 int arg2 = (int) 0 ;
4732 int arg3 = (int) 0 ;
4733 int arg4 = (int) 0 ;
4734 wxRect *result;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 PyObject * obj2 = 0 ;
4738 PyObject * obj3 = 0 ;
4739 char *kwnames[] = {
4740 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4741 };
4742
4743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4744 if (obj0) {
4745 {
4746 arg1 = (int)(SWIG_As_int(obj0));
4747 if (SWIG_arg_fail(1)) SWIG_fail;
4748 }
4749 }
4750 if (obj1) {
4751 {
4752 arg2 = (int)(SWIG_As_int(obj1));
4753 if (SWIG_arg_fail(2)) SWIG_fail;
4754 }
4755 }
4756 if (obj2) {
4757 {
4758 arg3 = (int)(SWIG_As_int(obj2));
4759 if (SWIG_arg_fail(3)) SWIG_fail;
4760 }
4761 }
4762 if (obj3) {
4763 {
4764 arg4 = (int)(SWIG_As_int(obj3));
4765 if (SWIG_arg_fail(4)) SWIG_fail;
4766 }
4767 }
4768 {
4769 PyThreadState* __tstate = wxPyBeginAllowThreads();
4770 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4771
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj;
4784 wxPoint *arg1 = 0 ;
4785 wxPoint *arg2 = 0 ;
4786 wxRect *result;
4787 wxPoint temp1 ;
4788 wxPoint temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "topLeft",(char *) "bottomRight", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4796 {
4797 arg1 = &temp1;
4798 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4799 }
4800 {
4801 arg2 = &temp2;
4802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4803 }
4804 {
4805 PyThreadState* __tstate = wxPyBeginAllowThreads();
4806 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj;
4820 wxPoint *arg1 = 0 ;
4821 wxSize *arg2 = 0 ;
4822 wxRect *result;
4823 wxPoint temp1 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "pos",(char *) "size", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4832 {
4833 arg1 = &temp1;
4834 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4835 }
4836 {
4837 arg2 = &temp2;
4838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4839 }
4840 {
4841 PyThreadState* __tstate = wxPyBeginAllowThreads();
4842 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj;
4856 wxSize *arg1 = 0 ;
4857 wxRect *result;
4858 wxSize temp1 ;
4859 PyObject * obj0 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "size", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4865 {
4866 arg1 = &temp1;
4867 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4868 }
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4872
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxRect *arg1 = (wxRect *) 0 ;
4886 PyObject * obj0 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "self", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(1)) SWIG_fail;
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 delete arg1;
4897
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 Py_INCREF(Py_None); resultobj = Py_None;
4902 return resultobj;
4903 fail:
4904 return NULL;
4905 }
4906
4907
4908 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj;
4910 wxRect *arg1 = (wxRect *) 0 ;
4911 int result;
4912 PyObject * obj0 = 0 ;
4913 char *kwnames[] = {
4914 (char *) "self", NULL
4915 };
4916
4917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4919 if (SWIG_arg_fail(1)) SWIG_fail;
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = (int)((wxRect const *)arg1)->GetX();
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 {
4928 resultobj = SWIG_From_int((int)(result));
4929 }
4930 return resultobj;
4931 fail:
4932 return NULL;
4933 }
4934
4935
4936 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj;
4938 wxRect *arg1 = (wxRect *) 0 ;
4939 int arg2 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 char *kwnames[] = {
4943 (char *) "self",(char *) "x", NULL
4944 };
4945
4946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4948 if (SWIG_arg_fail(1)) SWIG_fail;
4949 {
4950 arg2 = (int)(SWIG_As_int(obj1));
4951 if (SWIG_arg_fail(2)) SWIG_fail;
4952 }
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->SetX(arg2);
4956
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 Py_INCREF(Py_None); resultobj = Py_None;
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj;
4969 wxRect *arg1 = (wxRect *) 0 ;
4970 int result;
4971 PyObject * obj0 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "self", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(1)) SWIG_fail;
4979 {
4980 PyThreadState* __tstate = wxPyBeginAllowThreads();
4981 result = (int)(arg1)->GetY();
4982
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 resultobj = SWIG_From_int((int)(result));
4988 }
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj;
4997 wxRect *arg1 = (wxRect *) 0 ;
4998 int arg2 ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "self",(char *) "y", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5007 if (SWIG_arg_fail(1)) SWIG_fail;
5008 {
5009 arg2 = (int)(SWIG_As_int(obj1));
5010 if (SWIG_arg_fail(2)) SWIG_fail;
5011 }
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 (arg1)->SetY(arg2);
5015
5016 wxPyEndAllowThreads(__tstate);
5017 if (PyErr_Occurred()) SWIG_fail;
5018 }
5019 Py_INCREF(Py_None); resultobj = Py_None;
5020 return resultobj;
5021 fail:
5022 return NULL;
5023 }
5024
5025
5026 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj;
5028 wxRect *arg1 = (wxRect *) 0 ;
5029 int result;
5030 PyObject * obj0 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = (int)((wxRect const *)arg1)->GetWidth();
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = SWIG_From_int((int)(result));
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxRect *arg1 = (wxRect *) 0 ;
5057 int arg2 ;
5058 PyObject * obj0 = 0 ;
5059 PyObject * obj1 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "self",(char *) "w", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 {
5068 arg2 = (int)(SWIG_As_int(obj1));
5069 if (SWIG_arg_fail(2)) SWIG_fail;
5070 }
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 (arg1)->SetWidth(arg2);
5074
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 Py_INCREF(Py_None); resultobj = Py_None;
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxRect *arg1 = (wxRect *) 0 ;
5088 int result;
5089 PyObject * obj0 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "self", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (int)((wxRect const *)arg1)->GetHeight();
5100
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 {
5105 resultobj = SWIG_From_int((int)(result));
5106 }
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5114 PyObject *resultobj;
5115 wxRect *arg1 = (wxRect *) 0 ;
5116 int arg2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self",(char *) "h", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 arg2 = (int)(SWIG_As_int(obj1));
5128 if (SWIG_arg_fail(2)) SWIG_fail;
5129 }
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 (arg1)->SetHeight(arg2);
5133
5134 wxPyEndAllowThreads(__tstate);
5135 if (PyErr_Occurred()) SWIG_fail;
5136 }
5137 Py_INCREF(Py_None); resultobj = Py_None;
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 wxRect *arg1 = (wxRect *) 0 ;
5147 wxPoint result;
5148 PyObject * obj0 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "self", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5155 if (SWIG_arg_fail(1)) SWIG_fail;
5156 {
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = ((wxRect const *)arg1)->GetPosition();
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 {
5164 wxPoint * resultptr;
5165 resultptr = new wxPoint((wxPoint &)(result));
5166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5167 }
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5175 PyObject *resultobj;
5176 wxRect *arg1 = (wxRect *) 0 ;
5177 wxPoint *arg2 = 0 ;
5178 wxPoint temp2 ;
5179 PyObject * obj0 = 0 ;
5180 PyObject * obj1 = 0 ;
5181 char *kwnames[] = {
5182 (char *) "self",(char *) "p", NULL
5183 };
5184
5185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5187 if (SWIG_arg_fail(1)) SWIG_fail;
5188 {
5189 arg2 = &temp2;
5190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5191 }
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 (arg1)->SetPosition((wxPoint const &)*arg2);
5195
5196 wxPyEndAllowThreads(__tstate);
5197 if (PyErr_Occurred()) SWIG_fail;
5198 }
5199 Py_INCREF(Py_None); resultobj = Py_None;
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj;
5208 wxRect *arg1 = (wxRect *) 0 ;
5209 wxSize result;
5210 PyObject * obj0 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = ((wxRect const *)arg1)->GetSize();
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 {
5226 wxSize * resultptr;
5227 resultptr = new wxSize((wxSize &)(result));
5228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5229 }
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj;
5238 wxRect *arg1 = (wxRect *) 0 ;
5239 wxSize *arg2 = 0 ;
5240 wxSize temp2 ;
5241 PyObject * obj0 = 0 ;
5242 PyObject * obj1 = 0 ;
5243 char *kwnames[] = {
5244 (char *) "self",(char *) "s", NULL
5245 };
5246
5247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5249 if (SWIG_arg_fail(1)) SWIG_fail;
5250 {
5251 arg2 = &temp2;
5252 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5253 }
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 (arg1)->SetSize((wxSize const &)*arg2);
5257
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 Py_INCREF(Py_None); resultobj = Py_None;
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5269 PyObject *resultobj;
5270 wxRect *arg1 = (wxRect *) 0 ;
5271 wxPoint result;
5272 PyObject * obj0 = 0 ;
5273 char *kwnames[] = {
5274 (char *) "self", NULL
5275 };
5276
5277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5279 if (SWIG_arg_fail(1)) SWIG_fail;
5280 {
5281 PyThreadState* __tstate = wxPyBeginAllowThreads();
5282 result = ((wxRect const *)arg1)->GetTopLeft();
5283
5284 wxPyEndAllowThreads(__tstate);
5285 if (PyErr_Occurred()) SWIG_fail;
5286 }
5287 {
5288 wxPoint * resultptr;
5289 resultptr = new wxPoint((wxPoint &)(result));
5290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5291 }
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 wxPoint *arg2 = 0 ;
5302 wxPoint temp2 ;
5303 PyObject * obj0 = 0 ;
5304 PyObject * obj1 = 0 ;
5305 char *kwnames[] = {
5306 (char *) "self",(char *) "p", NULL
5307 };
5308
5309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5311 if (SWIG_arg_fail(1)) SWIG_fail;
5312 {
5313 arg2 = &temp2;
5314 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5315 }
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5319
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 Py_INCREF(Py_None); resultobj = Py_None;
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5331 PyObject *resultobj;
5332 wxRect *arg1 = (wxRect *) 0 ;
5333 wxPoint result;
5334 PyObject * obj0 = 0 ;
5335 char *kwnames[] = {
5336 (char *) "self", NULL
5337 };
5338
5339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5341 if (SWIG_arg_fail(1)) SWIG_fail;
5342 {
5343 PyThreadState* __tstate = wxPyBeginAllowThreads();
5344 result = ((wxRect const *)arg1)->GetBottomRight();
5345
5346 wxPyEndAllowThreads(__tstate);
5347 if (PyErr_Occurred()) SWIG_fail;
5348 }
5349 {
5350 wxPoint * resultptr;
5351 resultptr = new wxPoint((wxPoint &)(result));
5352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5361 PyObject *resultobj;
5362 wxRect *arg1 = (wxRect *) 0 ;
5363 wxPoint *arg2 = 0 ;
5364 wxPoint temp2 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char *kwnames[] = {
5368 (char *) "self",(char *) "p", NULL
5369 };
5370
5371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5373 if (SWIG_arg_fail(1)) SWIG_fail;
5374 {
5375 arg2 = &temp2;
5376 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5377 }
5378 {
5379 PyThreadState* __tstate = wxPyBeginAllowThreads();
5380 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5381
5382 wxPyEndAllowThreads(__tstate);
5383 if (PyErr_Occurred()) SWIG_fail;
5384 }
5385 Py_INCREF(Py_None); resultobj = Py_None;
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj;
5394 wxRect *arg1 = (wxRect *) 0 ;
5395 int result;
5396 PyObject * obj0 = 0 ;
5397 char *kwnames[] = {
5398 (char *) "self", NULL
5399 };
5400
5401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5403 if (SWIG_arg_fail(1)) SWIG_fail;
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = (int)((wxRect const *)arg1)->GetLeft();
5407
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 resultobj = SWIG_From_int((int)(result));
5413 }
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5421 PyObject *resultobj;
5422 wxRect *arg1 = (wxRect *) 0 ;
5423 int result;
5424 PyObject * obj0 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (int)((wxRect const *)arg1)->GetTop();
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 resultobj = SWIG_From_int((int)(result));
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5449 PyObject *resultobj;
5450 wxRect *arg1 = (wxRect *) 0 ;
5451 int result;
5452 PyObject * obj0 = 0 ;
5453 char *kwnames[] = {
5454 (char *) "self", NULL
5455 };
5456
5457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5459 if (SWIG_arg_fail(1)) SWIG_fail;
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 result = (int)((wxRect const *)arg1)->GetBottom();
5463
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 resultobj = SWIG_From_int((int)(result));
5469 }
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj;
5478 wxRect *arg1 = (wxRect *) 0 ;
5479 int result;
5480 PyObject * obj0 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5487 if (SWIG_arg_fail(1)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (int)((wxRect const *)arg1)->GetRight();
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = SWIG_From_int((int)(result));
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int arg2 ;
5508 PyObject * obj0 = 0 ;
5509 PyObject * obj1 = 0 ;
5510 char *kwnames[] = {
5511 (char *) "self",(char *) "left", NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5516 if (SWIG_arg_fail(1)) SWIG_fail;
5517 {
5518 arg2 = (int)(SWIG_As_int(obj1));
5519 if (SWIG_arg_fail(2)) SWIG_fail;
5520 }
5521 {
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 (arg1)->SetLeft(arg2);
5524
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 Py_INCREF(Py_None); resultobj = Py_None;
5529 return resultobj;
5530 fail:
5531 return NULL;
5532 }
5533
5534
5535 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5536 PyObject *resultobj;
5537 wxRect *arg1 = (wxRect *) 0 ;
5538 int arg2 ;
5539 PyObject * obj0 = 0 ;
5540 PyObject * obj1 = 0 ;
5541 char *kwnames[] = {
5542 (char *) "self",(char *) "right", NULL
5543 };
5544
5545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5547 if (SWIG_arg_fail(1)) SWIG_fail;
5548 {
5549 arg2 = (int)(SWIG_As_int(obj1));
5550 if (SWIG_arg_fail(2)) SWIG_fail;
5551 }
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 (arg1)->SetRight(arg2);
5555
5556 wxPyEndAllowThreads(__tstate);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 Py_INCREF(Py_None); resultobj = Py_None;
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5567 PyObject *resultobj;
5568 wxRect *arg1 = (wxRect *) 0 ;
5569 int arg2 ;
5570 PyObject * obj0 = 0 ;
5571 PyObject * obj1 = 0 ;
5572 char *kwnames[] = {
5573 (char *) "self",(char *) "top", NULL
5574 };
5575
5576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5578 if (SWIG_arg_fail(1)) SWIG_fail;
5579 {
5580 arg2 = (int)(SWIG_As_int(obj1));
5581 if (SWIG_arg_fail(2)) SWIG_fail;
5582 }
5583 {
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 (arg1)->SetTop(arg2);
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 Py_INCREF(Py_None); resultobj = Py_None;
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj;
5599 wxRect *arg1 = (wxRect *) 0 ;
5600 int arg2 ;
5601 PyObject * obj0 = 0 ;
5602 PyObject * obj1 = 0 ;
5603 char *kwnames[] = {
5604 (char *) "self",(char *) "bottom", NULL
5605 };
5606
5607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5609 if (SWIG_arg_fail(1)) SWIG_fail;
5610 {
5611 arg2 = (int)(SWIG_As_int(obj1));
5612 if (SWIG_arg_fail(2)) SWIG_fail;
5613 }
5614 {
5615 PyThreadState* __tstate = wxPyBeginAllowThreads();
5616 (arg1)->SetBottom(arg2);
5617
5618 wxPyEndAllowThreads(__tstate);
5619 if (PyErr_Occurred()) SWIG_fail;
5620 }
5621 Py_INCREF(Py_None); resultobj = Py_None;
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj;
5630 wxRect *arg1 = (wxRect *) 0 ;
5631 int arg2 ;
5632 int arg3 ;
5633 wxRect *result;
5634 PyObject * obj0 = 0 ;
5635 PyObject * obj1 = 0 ;
5636 PyObject * obj2 = 0 ;
5637 char *kwnames[] = {
5638 (char *) "self",(char *) "dx",(char *) "dy", NULL
5639 };
5640
5641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5643 if (SWIG_arg_fail(1)) SWIG_fail;
5644 {
5645 arg2 = (int)(SWIG_As_int(obj1));
5646 if (SWIG_arg_fail(2)) SWIG_fail;
5647 }
5648 {
5649 arg3 = (int)(SWIG_As_int(obj2));
5650 if (SWIG_arg_fail(3)) SWIG_fail;
5651 }
5652 {
5653 PyThreadState* __tstate = wxPyBeginAllowThreads();
5654 {
5655 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5656 result = (wxRect *) &_result_ref;
5657 }
5658
5659 wxPyEndAllowThreads(__tstate);
5660 if (PyErr_Occurred()) SWIG_fail;
5661 }
5662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5670 PyObject *resultobj;
5671 wxRect *arg1 = (wxRect *) 0 ;
5672 int arg2 ;
5673 int arg3 ;
5674 wxRect *result;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 PyObject * obj2 = 0 ;
5678 char *kwnames[] = {
5679 (char *) "self",(char *) "dx",(char *) "dy", NULL
5680 };
5681
5682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5684 if (SWIG_arg_fail(1)) SWIG_fail;
5685 {
5686 arg2 = (int)(SWIG_As_int(obj1));
5687 if (SWIG_arg_fail(2)) SWIG_fail;
5688 }
5689 {
5690 arg3 = (int)(SWIG_As_int(obj2));
5691 if (SWIG_arg_fail(3)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 {
5696 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5697 result = (wxRect *) &_result_ref;
5698 }
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 wxRect *arg1 = (wxRect *) 0 ;
5713 int arg2 ;
5714 int arg3 ;
5715 PyObject * obj0 = 0 ;
5716 PyObject * obj1 = 0 ;
5717 PyObject * obj2 = 0 ;
5718 char *kwnames[] = {
5719 (char *) "self",(char *) "dx",(char *) "dy", NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5724 if (SWIG_arg_fail(1)) SWIG_fail;
5725 {
5726 arg2 = (int)(SWIG_As_int(obj1));
5727 if (SWIG_arg_fail(2)) SWIG_fail;
5728 }
5729 {
5730 arg3 = (int)(SWIG_As_int(obj2));
5731 if (SWIG_arg_fail(3)) SWIG_fail;
5732 }
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 (arg1)->Offset(arg2,arg3);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 Py_INCREF(Py_None); resultobj = Py_None;
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxRect *arg1 = (wxRect *) 0 ;
5750 wxPoint *arg2 = 0 ;
5751 wxPoint temp2 ;
5752 PyObject * obj0 = 0 ;
5753 PyObject * obj1 = 0 ;
5754 char *kwnames[] = {
5755 (char *) "self",(char *) "pt", NULL
5756 };
5757
5758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5760 if (SWIG_arg_fail(1)) SWIG_fail;
5761 {
5762 arg2 = &temp2;
5763 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5764 }
5765 {
5766 PyThreadState* __tstate = wxPyBeginAllowThreads();
5767 (arg1)->Offset((wxPoint const &)*arg2);
5768
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 Py_INCREF(Py_None); resultobj = Py_None;
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj;
5781 wxRect *arg1 = (wxRect *) 0 ;
5782 wxRect *arg2 = 0 ;
5783 wxRect result;
5784 wxRect temp2 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 char *kwnames[] = {
5788 (char *) "self",(char *) "rect", NULL
5789 };
5790
5791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5793 if (SWIG_arg_fail(1)) SWIG_fail;
5794 {
5795 arg2 = &temp2;
5796 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5797 }
5798 {
5799 PyThreadState* __tstate = wxPyBeginAllowThreads();
5800 result = (arg1)->Intersect((wxRect const &)*arg2);
5801
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 wxRect * resultptr;
5807 resultptr = new wxRect((wxRect &)(result));
5808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5809 }
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxRect *arg1 = (wxRect *) 0 ;
5819 wxRect *arg2 = 0 ;
5820 wxRect result;
5821 wxRect temp2 ;
5822 PyObject * obj0 = 0 ;
5823 PyObject * obj1 = 0 ;
5824 char *kwnames[] = {
5825 (char *) "self",(char *) "rect", NULL
5826 };
5827
5828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5830 if (SWIG_arg_fail(1)) SWIG_fail;
5831 {
5832 arg2 = &temp2;
5833 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (arg1)->Union((wxRect const &)*arg2);
5838
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 {
5843 wxRect * resultptr;
5844 resultptr = new wxRect((wxRect &)(result));
5845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5846 }
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect *result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 {
5912 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5913 result = (wxRect *) &_result_ref;
5914 }
5915
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 wxRect *arg1 = (wxRect *) 0 ;
5929 wxRect *arg2 = 0 ;
5930 bool result;
5931 wxRect temp2 ;
5932 PyObject * obj0 = 0 ;
5933 PyObject * obj1 = 0 ;
5934 char *kwnames[] = {
5935 (char *) "self",(char *) "rect", NULL
5936 };
5937
5938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5940 if (SWIG_arg_fail(1)) SWIG_fail;
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5948
5949 wxPyEndAllowThreads(__tstate);
5950 if (PyErr_Occurred()) SWIG_fail;
5951 }
5952 {
5953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5954 }
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxRect *arg1 = (wxRect *) 0 ;
5964 wxRect *arg2 = 0 ;
5965 bool result;
5966 wxRect temp2 ;
5967 PyObject * obj0 = 0 ;
5968 PyObject * obj1 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "self",(char *) "rect", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 {
5977 arg2 = &temp2;
5978 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5979 }
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5983
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 {
5988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5989 }
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj;
5998 wxRect *arg1 = (wxRect *) 0 ;
5999 int arg2 ;
6000 int arg3 ;
6001 bool result;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 PyObject * obj2 = 0 ;
6005 char *kwnames[] = {
6006 (char *) "self",(char *) "x",(char *) "y", NULL
6007 };
6008
6009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6011 if (SWIG_arg_fail(1)) SWIG_fail;
6012 {
6013 arg2 = (int)(SWIG_As_int(obj1));
6014 if (SWIG_arg_fail(2)) SWIG_fail;
6015 }
6016 {
6017 arg3 = (int)(SWIG_As_int(obj2));
6018 if (SWIG_arg_fail(3)) SWIG_fail;
6019 }
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6029 }
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj;
6038 wxRect *arg1 = (wxRect *) 0 ;
6039 wxPoint *arg2 = 0 ;
6040 bool result;
6041 wxPoint temp2 ;
6042 PyObject * obj0 = 0 ;
6043 PyObject * obj1 = 0 ;
6044 char *kwnames[] = {
6045 (char *) "self",(char *) "pt", NULL
6046 };
6047
6048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6050 if (SWIG_arg_fail(1)) SWIG_fail;
6051 {
6052 arg2 = &temp2;
6053 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6054 }
6055 {
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6058
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 {
6063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6064 }
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj;
6073 wxRect *arg1 = (wxRect *) 0 ;
6074 wxRect *arg2 = 0 ;
6075 bool result;
6076 wxRect temp2 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "rect", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = &temp2;
6088 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6089 }
6090 {
6091 PyThreadState* __tstate = wxPyBeginAllowThreads();
6092 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6093
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 {
6098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6099 }
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6107 PyObject *resultobj;
6108 wxRect *arg1 = (wxRect *) 0 ;
6109 int arg2 ;
6110 PyObject * obj0 = 0 ;
6111 PyObject * obj1 = 0 ;
6112 char *kwnames[] = {
6113 (char *) "self",(char *) "x", NULL
6114 };
6115
6116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6118 if (SWIG_arg_fail(1)) SWIG_fail;
6119 {
6120 arg2 = (int)(SWIG_As_int(obj1));
6121 if (SWIG_arg_fail(2)) SWIG_fail;
6122 }
6123 if (arg1) (arg1)->x = arg2;
6124
6125 Py_INCREF(Py_None); resultobj = Py_None;
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxRect *arg1 = (wxRect *) 0 ;
6135 int result;
6136 PyObject * obj0 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 result = (int) ((arg1)->x);
6145
6146 {
6147 resultobj = SWIG_From_int((int)(result));
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 int arg2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char *kwnames[] = {
6162 (char *) "self",(char *) "y", NULL
6163 };
6164
6165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6167 if (SWIG_arg_fail(1)) SWIG_fail;
6168 {
6169 arg2 = (int)(SWIG_As_int(obj1));
6170 if (SWIG_arg_fail(2)) SWIG_fail;
6171 }
6172 if (arg1) (arg1)->y = arg2;
6173
6174 Py_INCREF(Py_None); resultobj = Py_None;
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxRect *arg1 = (wxRect *) 0 ;
6184 int result;
6185 PyObject * obj0 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 result = (int) ((arg1)->y);
6194
6195 {
6196 resultobj = SWIG_From_int((int)(result));
6197 }
6198 return resultobj;
6199 fail:
6200 return NULL;
6201 }
6202
6203
6204 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6205 PyObject *resultobj;
6206 wxRect *arg1 = (wxRect *) 0 ;
6207 int arg2 ;
6208 PyObject * obj0 = 0 ;
6209 PyObject * obj1 = 0 ;
6210 char *kwnames[] = {
6211 (char *) "self",(char *) "width", NULL
6212 };
6213
6214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 {
6218 arg2 = (int)(SWIG_As_int(obj1));
6219 if (SWIG_arg_fail(2)) SWIG_fail;
6220 }
6221 if (arg1) (arg1)->width = arg2;
6222
6223 Py_INCREF(Py_None); resultobj = Py_None;
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 int result;
6234 PyObject * obj0 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 result = (int) ((arg1)->width);
6243
6244 {
6245 resultobj = SWIG_From_int((int)(result));
6246 }
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 wxRect *arg1 = (wxRect *) 0 ;
6256 int arg2 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self",(char *) "height", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 arg2 = (int)(SWIG_As_int(obj1));
6268 if (SWIG_arg_fail(2)) SWIG_fail;
6269 }
6270 if (arg1) (arg1)->height = arg2;
6271
6272 Py_INCREF(Py_None); resultobj = Py_None;
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int result;
6283 PyObject * obj0 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 result = (int) ((arg1)->height);
6292
6293 {
6294 resultobj = SWIG_From_int((int)(result));
6295 }
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj;
6304 wxRect *arg1 = (wxRect *) 0 ;
6305 int arg2 = (int) 0 ;
6306 int arg3 = (int) 0 ;
6307 int arg4 = (int) 0 ;
6308 int arg5 = (int) 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 PyObject * obj2 = 0 ;
6312 PyObject * obj3 = 0 ;
6313 PyObject * obj4 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 if (obj1) {
6322 {
6323 arg2 = (int)(SWIG_As_int(obj1));
6324 if (SWIG_arg_fail(2)) SWIG_fail;
6325 }
6326 }
6327 if (obj2) {
6328 {
6329 arg3 = (int)(SWIG_As_int(obj2));
6330 if (SWIG_arg_fail(3)) SWIG_fail;
6331 }
6332 }
6333 if (obj3) {
6334 {
6335 arg4 = (int)(SWIG_As_int(obj3));
6336 if (SWIG_arg_fail(4)) SWIG_fail;
6337 }
6338 }
6339 if (obj4) {
6340 {
6341 arg5 = (int)(SWIG_As_int(obj4));
6342 if (SWIG_arg_fail(5)) SWIG_fail;
6343 }
6344 }
6345 {
6346 PyThreadState* __tstate = wxPyBeginAllowThreads();
6347 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6348
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 Py_INCREF(Py_None); resultobj = Py_None;
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 PyObject *result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6370 if (SWIG_arg_fail(1)) SWIG_fail;
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (PyObject *)wxRect_Get(arg1);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 resultobj = result;
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6386 PyObject *obj;
6387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6388 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6389 Py_INCREF(obj);
6390 return Py_BuildValue((char *)"");
6391 }
6392 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxRect *arg1 = (wxRect *) 0 ;
6395 wxRect *arg2 = (wxRect *) 0 ;
6396 PyObject *result;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "r1",(char *) "r2", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(2)) SWIG_fail;
6408 {
6409 if (!wxPyCheckForApp()) SWIG_fail;
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (PyObject *)wxIntersectRect(arg1,arg2);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = result;
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj;
6425 double arg1 = (double) 0.0 ;
6426 double arg2 = (double) 0.0 ;
6427 wxPoint2D *result;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "x",(char *) "y", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6435 if (obj0) {
6436 {
6437 arg1 = (double)(SWIG_As_double(obj0));
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 }
6440 }
6441 if (obj1) {
6442 {
6443 arg2 = (double)(SWIG_As_double(obj1));
6444 if (SWIG_arg_fail(2)) SWIG_fail;
6445 }
6446 }
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6450
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj;
6463 wxPoint2D *arg1 = 0 ;
6464 wxPoint2D *result;
6465 wxPoint2D temp1 ;
6466 PyObject * obj0 = 0 ;
6467 char *kwnames[] = {
6468 (char *) "pt", NULL
6469 };
6470
6471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6472 {
6473 arg1 = &temp1;
6474 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6475 }
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 wxPoint *arg1 = 0 ;
6493 wxPoint2D *result;
6494 wxPoint temp1 ;
6495 PyObject * obj0 = 0 ;
6496 char *kwnames[] = {
6497 (char *) "pt", NULL
6498 };
6499
6500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6501 {
6502 arg1 = &temp1;
6503 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6522 int *arg2 = (int *) 0 ;
6523 int *arg3 = (int *) 0 ;
6524 int temp2 ;
6525 int res2 = 0 ;
6526 int temp3 ;
6527 int res3 = 0 ;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6534 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6541
6542 wxPyEndAllowThreads(__tstate);
6543 if (PyErr_Occurred()) SWIG_fail;
6544 }
6545 Py_INCREF(Py_None); resultobj = Py_None;
6546 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6547 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6548 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6549 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj;
6558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6559 int *arg2 = (int *) 0 ;
6560 int *arg3 = (int *) 0 ;
6561 int temp2 ;
6562 int res2 = 0 ;
6563 int temp3 ;
6564 int res3 = 0 ;
6565 PyObject * obj0 = 0 ;
6566 char *kwnames[] = {
6567 (char *) "self", NULL
6568 };
6569
6570 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6571 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6574 if (SWIG_arg_fail(1)) SWIG_fail;
6575 {
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6578
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 Py_INCREF(Py_None); resultobj = Py_None;
6583 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6584 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6585 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6586 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 double result;
6597 PyObject * obj0 = 0 ;
6598 char *kwnames[] = {
6599 (char *) "self", NULL
6600 };
6601
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 {
6613 resultobj = SWIG_From_double((double)(result));
6614 }
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj;
6623 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6624 double result;
6625 PyObject * obj0 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self", NULL
6628 };
6629
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 {
6641 resultobj = SWIG_From_double((double)(result));
6642 }
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj;
6651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6652 double arg2 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 char *kwnames[] = {
6656 (char *) "self",(char *) "length", NULL
6657 };
6658
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(1)) SWIG_fail;
6662 {
6663 arg2 = (double)(SWIG_As_double(obj1));
6664 if (SWIG_arg_fail(2)) SWIG_fail;
6665 }
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 (arg1)->SetVectorLength(arg2);
6669
6670 wxPyEndAllowThreads(__tstate);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 Py_INCREF(Py_None); resultobj = Py_None;
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6681 PyObject *resultobj;
6682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6683 double arg2 ;
6684 PyObject * obj0 = 0 ;
6685 PyObject * obj1 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "self",(char *) "degrees", NULL
6688 };
6689
6690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6692 if (SWIG_arg_fail(1)) SWIG_fail;
6693 {
6694 arg2 = (double)(SWIG_As_double(obj1));
6695 if (SWIG_arg_fail(2)) SWIG_fail;
6696 }
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 (arg1)->SetVectorAngle(arg2);
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 Py_INCREF(Py_None); resultobj = Py_None;
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj;
6713 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6714 wxPoint2D *arg2 = 0 ;
6715 double result;
6716 wxPoint2D temp2 ;
6717 PyObject * obj0 = 0 ;
6718 PyObject * obj1 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self",(char *) "pt", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 arg2 = &temp2;
6728 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 {
6738 resultobj = SWIG_From_double((double)(result));
6739 }
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6747 PyObject *resultobj;
6748 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6749 wxPoint2D *arg2 = 0 ;
6750 double result;
6751 wxPoint2D temp2 ;
6752 PyObject * obj0 = 0 ;
6753 PyObject * obj1 = 0 ;
6754 char *kwnames[] = {
6755 (char *) "self",(char *) "pt", NULL
6756 };
6757
6758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6760 if (SWIG_arg_fail(1)) SWIG_fail;
6761 {
6762 arg2 = &temp2;
6763 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 {
6773 resultobj = SWIG_From_double((double)(result));
6774 }
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj;
6783 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6784 wxPoint2D *arg2 = 0 ;
6785 double result;
6786 wxPoint2D temp2 ;
6787 PyObject * obj0 = 0 ;
6788 PyObject * obj1 = 0 ;
6789 char *kwnames[] = {
6790 (char *) "self",(char *) "vec", NULL
6791 };
6792
6793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6795 if (SWIG_arg_fail(1)) SWIG_fail;
6796 {
6797 arg2 = &temp2;
6798 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6799 }
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6803
6804 wxPyEndAllowThreads(__tstate);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 {
6808 resultobj = SWIG_From_double((double)(result));
6809 }
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6819 wxPoint2D *arg2 = 0 ;
6820 double result;
6821 wxPoint2D temp2 ;
6822 PyObject * obj0 = 0 ;
6823 PyObject * obj1 = 0 ;
6824 char *kwnames[] = {
6825 (char *) "self",(char *) "vec", NULL
6826 };
6827
6828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6830 if (SWIG_arg_fail(1)) SWIG_fail;
6831 {
6832 arg2 = &temp2;
6833 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6834 }
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 {
6843 resultobj = SWIG_From_double((double)(result));
6844 }
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6852 PyObject *resultobj;
6853 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6854 wxPoint2D result;
6855 PyObject * obj0 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = (arg1)->operator -();
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 {
6871 wxPoint2D * resultptr;
6872 resultptr = new wxPoint2D((wxPoint2D &)(result));
6873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj;
6883 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6884 wxPoint2D *arg2 = 0 ;
6885 wxPoint2D *result;
6886 wxPoint2D temp2 ;
6887 PyObject * obj0 = 0 ;
6888 PyObject * obj1 = 0 ;
6889 char *kwnames[] = {
6890 (char *) "self",(char *) "pt", NULL
6891 };
6892
6893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6895 if (SWIG_arg_fail(1)) SWIG_fail;
6896 {
6897 arg2 = &temp2;
6898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6899 }
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 {
6903 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6904 result = (wxPoint2D *) &_result_ref;
6905 }
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6918 PyObject *resultobj;
6919 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6920 wxPoint2D *arg2 = 0 ;
6921 wxPoint2D *result;
6922 wxPoint2D temp2 ;
6923 PyObject * obj0 = 0 ;
6924 PyObject * obj1 = 0 ;
6925 char *kwnames[] = {
6926 (char *) "self",(char *) "pt", NULL
6927 };
6928
6929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6931 if (SWIG_arg_fail(1)) SWIG_fail;
6932 {
6933 arg2 = &temp2;
6934 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6935 }
6936 {
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 {
6939 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6940 result = (wxPoint2D *) &_result_ref;
6941 }
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6954 PyObject *resultobj;
6955 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6956 wxPoint2D *arg2 = 0 ;
6957 wxPoint2D *result;
6958 wxPoint2D temp2 ;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self",(char *) "pt", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 arg2 = &temp2;
6970 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6971 }
6972 {
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 {
6975 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6976 result = (wxPoint2D *) &_result_ref;
6977 }
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj;
6991 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6992 wxPoint2D *arg2 = 0 ;
6993 wxPoint2D *result;
6994 wxPoint2D temp2 ;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 char *kwnames[] = {
6998 (char *) "self",(char *) "pt", NULL
6999 };
7000
7001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7003 if (SWIG_arg_fail(1)) SWIG_fail;
7004 {
7005 arg2 = &temp2;
7006 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7007 }
7008 {
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 {
7011 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7012 result = (wxPoint2D *) &_result_ref;
7013 }
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7028 wxPoint2D *arg2 = 0 ;
7029 bool result;
7030 wxPoint2D temp2 ;
7031 PyObject * obj0 = 0 ;
7032 PyObject * obj1 = 0 ;
7033 char *kwnames[] = {
7034 (char *) "self",(char *) "pt", NULL
7035 };
7036
7037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7039 if (SWIG_arg_fail(1)) SWIG_fail;
7040 {
7041 arg2 = &temp2;
7042 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7043 }
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7047
7048 wxPyEndAllowThreads(__tstate);
7049 if (PyErr_Occurred()) SWIG_fail;
7050 }
7051 {
7052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7053 }
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj;
7062 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7063 wxPoint2D *arg2 = 0 ;
7064 bool result;
7065 wxPoint2D temp2 ;
7066 PyObject * obj0 = 0 ;
7067 PyObject * obj1 = 0 ;
7068 char *kwnames[] = {
7069 (char *) "self",(char *) "pt", NULL
7070 };
7071
7072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7074 if (SWIG_arg_fail(1)) SWIG_fail;
7075 {
7076 arg2 = &temp2;
7077 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7078 }
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7082
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 {
7087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7098 double arg2 ;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char *kwnames[] = {
7102 (char *) "self",(char *) "m_x", NULL
7103 };
7104
7105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7107 if (SWIG_arg_fail(1)) SWIG_fail;
7108 {
7109 arg2 = (double)(SWIG_As_double(obj1));
7110 if (SWIG_arg_fail(2)) SWIG_fail;
7111 }
7112 if (arg1) (arg1)->m_x = arg2;
7113
7114 Py_INCREF(Py_None); resultobj = Py_None;
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7124 double result;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 result = (double) ((arg1)->m_x);
7134
7135 {
7136 resultobj = SWIG_From_double((double)(result));
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7147 double arg2 ;
7148 PyObject * obj0 = 0 ;
7149 PyObject * obj1 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self",(char *) "m_y", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 {
7158 arg2 = (double)(SWIG_As_double(obj1));
7159 if (SWIG_arg_fail(2)) SWIG_fail;
7160 }
7161 if (arg1) (arg1)->m_y = arg2;
7162
7163 Py_INCREF(Py_None); resultobj = Py_None;
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj;
7172 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7173 double result;
7174 PyObject * obj0 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 result = (double) ((arg1)->m_y);
7183
7184 {
7185 resultobj = SWIG_From_double((double)(result));
7186 }
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7196 double arg2 = (double) 0 ;
7197 double arg3 = (double) 0 ;
7198 PyObject * obj0 = 0 ;
7199 PyObject * obj1 = 0 ;
7200 PyObject * obj2 = 0 ;
7201 char *kwnames[] = {
7202 (char *) "self",(char *) "x",(char *) "y", NULL
7203 };
7204
7205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7207 if (SWIG_arg_fail(1)) SWIG_fail;
7208 if (obj1) {
7209 {
7210 arg2 = (double)(SWIG_As_double(obj1));
7211 if (SWIG_arg_fail(2)) SWIG_fail;
7212 }
7213 }
7214 if (obj2) {
7215 {
7216 arg3 = (double)(SWIG_As_double(obj2));
7217 if (SWIG_arg_fail(3)) SWIG_fail;
7218 }
7219 }
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 wxPoint2D_Set(arg1,arg2,arg3);
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 Py_INCREF(Py_None); resultobj = Py_None;
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7237 PyObject *result;
7238 PyObject * obj0 = 0 ;
7239 char *kwnames[] = {
7240 (char *) "self", NULL
7241 };
7242
7243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7245 if (SWIG_arg_fail(1)) SWIG_fail;
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (PyObject *)wxPoint2D_Get(arg1);
7249
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = result;
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7261 PyObject *obj;
7262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7263 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7264 Py_INCREF(obj);
7265 return Py_BuildValue((char *)"");
7266 }
7267 static int _wrap_DefaultPosition_set(PyObject *) {
7268 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7269 return 1;
7270 }
7271
7272
7273 static PyObject *_wrap_DefaultPosition_get(void) {
7274 PyObject *pyobj;
7275
7276 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7277 return pyobj;
7278 }
7279
7280
7281 static int _wrap_DefaultSize_set(PyObject *) {
7282 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7283 return 1;
7284 }
7285
7286
7287 static PyObject *_wrap_DefaultSize_get(void) {
7288 PyObject *pyobj;
7289
7290 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7291 return pyobj;
7292 }
7293
7294
7295 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 PyObject *arg1 = (PyObject *) 0 ;
7298 wxPyInputStream *result;
7299 PyObject * obj0 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "p", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7305 arg1 = obj0;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj;
7322 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7323 PyObject * obj0 = 0 ;
7324 char *kwnames[] = {
7325 (char *) "self", NULL
7326 };
7327
7328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7330 if (SWIG_arg_fail(1)) SWIG_fail;
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 delete arg1;
7334
7335 wxPyEndAllowThreads(__tstate);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 Py_INCREF(Py_None); resultobj = Py_None;
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj;
7347 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7348 PyObject * obj0 = 0 ;
7349 char *kwnames[] = {
7350 (char *) "self", NULL
7351 };
7352
7353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7355 if (SWIG_arg_fail(1)) SWIG_fail;
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 (arg1)->close();
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 Py_INCREF(Py_None); resultobj = Py_None;
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj;
7372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "self", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7380 if (SWIG_arg_fail(1)) SWIG_fail;
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 (arg1)->flush();
7384
7385 wxPyEndAllowThreads(__tstate);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 Py_INCREF(Py_None); resultobj = Py_None;
7389 return resultobj;
7390 fail:
7391 return NULL;
7392 }
7393
7394
7395 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7396 PyObject *resultobj;
7397 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7398 bool result;
7399 PyObject * obj0 = 0 ;
7400 char *kwnames[] = {
7401 (char *) "self", NULL
7402 };
7403
7404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(1)) SWIG_fail;
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 result = (bool)(arg1)->eof();
7410
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 {
7415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7424 PyObject *resultobj;
7425 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7426 int arg2 = (int) -1 ;
7427 PyObject *result;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self",(char *) "size", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 if (obj1) {
7438 {
7439 arg2 = (int)(SWIG_As_int(obj1));
7440 if (SWIG_arg_fail(2)) SWIG_fail;
7441 }
7442 }
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 result = (PyObject *)(arg1)->read(arg2);
7446
7447 wxPyEndAllowThreads(__tstate);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 resultobj = result;
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7460 int arg2 = (int) -1 ;
7461 PyObject *result;
7462 PyObject * obj0 = 0 ;
7463 PyObject * obj1 = 0 ;
7464 char *kwnames[] = {
7465 (char *) "self",(char *) "size", NULL
7466 };
7467
7468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(1)) SWIG_fail;
7471 if (obj1) {
7472 {
7473 arg2 = (int)(SWIG_As_int(obj1));
7474 if (SWIG_arg_fail(2)) SWIG_fail;
7475 }
7476 }
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 result = (PyObject *)(arg1)->readline(arg2);
7480
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 resultobj = result;
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj;
7493 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7494 int arg2 = (int) -1 ;
7495 PyObject *result;
7496 PyObject * obj0 = 0 ;
7497 PyObject * obj1 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self",(char *) "sizehint", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 if (obj1) {
7506 {
7507 arg2 = (int)(SWIG_As_int(obj1));
7508 if (SWIG_arg_fail(2)) SWIG_fail;
7509 }
7510 }
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (PyObject *)(arg1)->readlines(arg2);
7514
7515 wxPyEndAllowThreads(__tstate);
7516 if (PyErr_Occurred()) SWIG_fail;
7517 }
7518 resultobj = result;
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj;
7527 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7528 int arg2 ;
7529 int arg3 = (int) 0 ;
7530 PyObject * obj0 = 0 ;
7531 PyObject * obj1 = 0 ;
7532 PyObject * obj2 = 0 ;
7533 char *kwnames[] = {
7534 (char *) "self",(char *) "offset",(char *) "whence", NULL
7535 };
7536
7537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7539 if (SWIG_arg_fail(1)) SWIG_fail;
7540 {
7541 arg2 = (int)(SWIG_As_int(obj1));
7542 if (SWIG_arg_fail(2)) SWIG_fail;
7543 }
7544 if (obj2) {
7545 {
7546 arg3 = (int)(SWIG_As_int(obj2));
7547 if (SWIG_arg_fail(3)) SWIG_fail;
7548 }
7549 }
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 (arg1)->seek(arg2,arg3);
7553
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 Py_INCREF(Py_None); resultobj = Py_None;
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj;
7566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7567 int result;
7568 PyObject * obj0 = 0 ;
7569 char *kwnames[] = {
7570 (char *) "self", NULL
7571 };
7572
7573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7575 if (SWIG_arg_fail(1)) SWIG_fail;
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (int)(arg1)->tell();
7579
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = SWIG_From_int((int)(result));
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7595 char result;
7596 PyObject * obj0 = 0 ;
7597 char *kwnames[] = {
7598 (char *) "self", NULL
7599 };
7600
7601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7603 if (SWIG_arg_fail(1)) SWIG_fail;
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 result = (char)(arg1)->Peek();
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 {
7612 resultobj = SWIG_From_char((char)(result));
7613 }
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7623 char result;
7624 PyObject * obj0 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 PyThreadState* __tstate = wxPyBeginAllowThreads();
7634 result = (char)(arg1)->GetC();
7635
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 {
7640 resultobj = SWIG_From_char((char)(result));
7641 }
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj;
7650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7651 size_t result;
7652 PyObject * obj0 = 0 ;
7653 char *kwnames[] = {
7654 (char *) "self", NULL
7655 };
7656
7657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(1)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (size_t)(arg1)->LastRead();
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 bool result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (bool)(arg1)->CanRead();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 bool result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (bool)(arg1)->Eof();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 char arg2 ;
7736 bool result;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self",(char *) "c", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 arg2 = (char)(SWIG_As_char(obj1));
7748 if (SWIG_arg_fail(2)) SWIG_fail;
7749 }
7750 {
7751 PyThreadState* __tstate = wxPyBeginAllowThreads();
7752 result = (bool)(arg1)->Ungetch(arg2);
7753
7754 wxPyEndAllowThreads(__tstate);
7755 if (PyErr_Occurred()) SWIG_fail;
7756 }
7757 {
7758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7759 }
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj;
7768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7769 long arg2 ;
7770 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7771 long result;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 PyObject * obj2 = 0 ;
7775 char *kwnames[] = {
7776 (char *) "self",(char *) "pos",(char *) "mode", NULL
7777 };
7778
7779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7781 if (SWIG_arg_fail(1)) SWIG_fail;
7782 {
7783 arg2 = (long)(SWIG_As_long(obj1));
7784 if (SWIG_arg_fail(2)) SWIG_fail;
7785 }
7786 if (obj2) {
7787 {
7788 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7789 if (SWIG_arg_fail(3)) SWIG_fail;
7790 }
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = SWIG_From_long((long)(result));
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7811 long result;
7812 PyObject * obj0 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 PyThreadState* __tstate = wxPyBeginAllowThreads();
7822 result = (long)(arg1)->TellI();
7823
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 {
7828 resultobj = SWIG_From_long((long)(result));
7829 }
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7837 PyObject *obj;
7838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7839 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7840 Py_INCREF(obj);
7841 return Py_BuildValue((char *)"");
7842 }
7843 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7846 PyObject *arg2 = (PyObject *) 0 ;
7847 PyObject * obj0 = 0 ;
7848 PyObject * obj1 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "obj", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 arg2 = obj1;
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 wxOutputStream_write(arg1,arg2);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 Py_INCREF(Py_None); resultobj = Py_None;
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7872 PyObject *obj;
7873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7874 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7875 Py_INCREF(obj);
7876 return Py_BuildValue((char *)"");
7877 }
7878 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj;
7880 wxInputStream *arg1 = (wxInputStream *) 0 ;
7881 wxString *arg2 = 0 ;
7882 wxString *arg3 = 0 ;
7883 wxString *arg4 = 0 ;
7884 wxDateTime arg5 ;
7885 wxFSFile *result;
7886 wxPyInputStream *temp1 ;
7887 bool created1 ;
7888 bool temp2 = false ;
7889 bool temp3 = false ;
7890 bool temp4 = false ;
7891 PyObject * obj0 = 0 ;
7892 PyObject * obj1 = 0 ;
7893 PyObject * obj2 = 0 ;
7894 PyObject * obj3 = 0 ;
7895 PyObject * obj4 = 0 ;
7896 char *kwnames[] = {
7897 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7898 };
7899
7900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7901 {
7902 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7903 arg1 = temp1->m_wxis;
7904 created1 = false;
7905 } else {
7906 PyErr_Clear(); // clear the failure of the wxPyConvert above
7907 arg1 = wxPyCBInputStream_create(obj0, false);
7908 if (arg1 == NULL) {
7909 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7910 SWIG_fail;
7911 }
7912 created1 = true;
7913 }
7914 }
7915 {
7916 arg2 = wxString_in_helper(obj1);
7917 if (arg2 == NULL) SWIG_fail;
7918 temp2 = true;
7919 }
7920 {
7921 arg3 = wxString_in_helper(obj2);
7922 if (arg3 == NULL) SWIG_fail;
7923 temp3 = true;
7924 }
7925 {
7926 arg4 = wxString_in_helper(obj3);
7927 if (arg4 == NULL) SWIG_fail;
7928 temp4 = true;
7929 }
7930 {
7931 wxDateTime * argp;
7932 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7933 if (SWIG_arg_fail(5)) SWIG_fail;
7934 if (argp == NULL) {
7935 SWIG_null_ref("wxDateTime");
7936 }
7937 if (SWIG_arg_fail(5)) SWIG_fail;
7938 arg5 = *argp;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = wxPyMake_wxObject(result, 1);
7949 }
7950 {
7951 if (created1)
7952 delete arg1;
7953 }
7954 {
7955 if (temp2)
7956 delete arg2;
7957 }
7958 {
7959 if (temp3)
7960 delete arg3;
7961 }
7962 {
7963 if (temp4)
7964 delete arg4;
7965 }
7966 return resultobj;
7967 fail:
7968 {
7969 if (created1)
7970 delete arg1;
7971 }
7972 {
7973 if (temp2)
7974 delete arg2;
7975 }
7976 {
7977 if (temp3)
7978 delete arg3;
7979 }
7980 {
7981 if (temp4)
7982 delete arg4;
7983 }
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxFSFile *arg1 = (wxFSFile *) 0 ;
7991 PyObject * obj0 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "self", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
7997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
7998 if (SWIG_arg_fail(1)) SWIG_fail;
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 delete arg1;
8002
8003 wxPyEndAllowThreads(__tstate);
8004 if (PyErr_Occurred()) SWIG_fail;
8005 }
8006 Py_INCREF(Py_None); resultobj = Py_None;
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 wxFSFile *arg1 = (wxFSFile *) 0 ;
8016 wxInputStream *result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (wxInputStream *)(arg1)->GetStream();
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 {
8033 wxPyInputStream * _ptr = NULL;
8034
8035 if (result) {
8036 _ptr = new wxPyInputStream(result);
8037 }
8038 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8039 }
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8047 PyObject *resultobj;
8048 wxFSFile *arg1 = (wxFSFile *) 0 ;
8049 wxString *result;
8050 PyObject * obj0 = 0 ;
8051 char *kwnames[] = {
8052 (char *) "self", NULL
8053 };
8054
8055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8057 if (SWIG_arg_fail(1)) SWIG_fail;
8058 {
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 {
8061 wxString const &_result_ref = (arg1)->GetMimeType();
8062 result = (wxString *) &_result_ref;
8063 }
8064
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 #if wxUSE_UNICODE
8070 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8071 #else
8072 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8073 #endif
8074 }
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxFSFile *arg1 = (wxFSFile *) 0 ;
8084 wxString *result;
8085 PyObject * obj0 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 {
8096 wxString const &_result_ref = (arg1)->GetLocation();
8097 result = (wxString *) &_result_ref;
8098 }
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 {
8104 #if wxUSE_UNICODE
8105 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8106 #else
8107 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8108 #endif
8109 }
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxFSFile *arg1 = (wxFSFile *) 0 ;
8119 wxString *result;
8120 PyObject * obj0 = 0 ;
8121 char *kwnames[] = {
8122 (char *) "self", NULL
8123 };
8124
8125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8127 if (SWIG_arg_fail(1)) SWIG_fail;
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 {
8131 wxString const &_result_ref = (arg1)->GetAnchor();
8132 result = (wxString *) &_result_ref;
8133 }
8134
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 {
8139 #if wxUSE_UNICODE
8140 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8141 #else
8142 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8143 #endif
8144 }
8145 return resultobj;
8146 fail:
8147 return NULL;
8148 }
8149
8150
8151 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8152 PyObject *resultobj;
8153 wxFSFile *arg1 = (wxFSFile *) 0 ;
8154 wxDateTime result;
8155 PyObject * obj0 = 0 ;
8156 char *kwnames[] = {
8157 (char *) "self", NULL
8158 };
8159
8160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8162 if (SWIG_arg_fail(1)) SWIG_fail;
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (arg1)->GetModificationTime();
8166
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 {
8171 wxDateTime * resultptr;
8172 resultptr = new wxDateTime((wxDateTime &)(result));
8173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8174 }
8175 return resultobj;
8176 fail:
8177 return NULL;
8178 }
8179
8180
8181 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8182 PyObject *obj;
8183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8184 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8185 Py_INCREF(obj);
8186 return Py_BuildValue((char *)"");
8187 }
8188 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8189 PyObject *obj;
8190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8191 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8192 Py_INCREF(obj);
8193 return Py_BuildValue((char *)"");
8194 }
8195 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8196 PyObject *resultobj;
8197 wxPyFileSystemHandler *result;
8198 char *kwnames[] = {
8199 NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8206
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj;
8219 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8220 PyObject *arg2 = (PyObject *) 0 ;
8221 PyObject *arg3 = (PyObject *) 0 ;
8222 PyObject * obj0 = 0 ;
8223 PyObject * obj1 = 0 ;
8224 PyObject * obj2 = 0 ;
8225 char *kwnames[] = {
8226 (char *) "self",(char *) "self",(char *) "_class", NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8231 if (SWIG_arg_fail(1)) SWIG_fail;
8232 arg2 = obj1;
8233 arg3 = obj2;
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 (arg1)->_setCallbackInfo(arg2,arg3);
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 Py_INCREF(Py_None); resultobj = Py_None;
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8251 wxString *arg2 = 0 ;
8252 bool result;
8253 bool temp2 = false ;
8254 PyObject * obj0 = 0 ;
8255 PyObject * obj1 = 0 ;
8256 char *kwnames[] = {
8257 (char *) "self",(char *) "location", NULL
8258 };
8259
8260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8262 if (SWIG_arg_fail(1)) SWIG_fail;
8263 {
8264 arg2 = wxString_in_helper(obj1);
8265 if (arg2 == NULL) SWIG_fail;
8266 temp2 = true;
8267 }
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8271
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 {
8276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8277 }
8278 {
8279 if (temp2)
8280 delete arg2;
8281 }
8282 return resultobj;
8283 fail:
8284 {
8285 if (temp2)
8286 delete arg2;
8287 }
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj;
8294 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8295 wxFileSystem *arg2 = 0 ;
8296 wxString *arg3 = 0 ;
8297 wxFSFile *result;
8298 bool temp3 = false ;
8299 PyObject * obj0 = 0 ;
8300 PyObject * obj1 = 0 ;
8301 PyObject * obj2 = 0 ;
8302 char *kwnames[] = {
8303 (char *) "self",(char *) "fs",(char *) "location", NULL
8304 };
8305
8306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8308 if (SWIG_arg_fail(1)) SWIG_fail;
8309 {
8310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(2)) SWIG_fail;
8312 if (arg2 == NULL) {
8313 SWIG_null_ref("wxFileSystem");
8314 }
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 }
8317 {
8318 arg3 = wxString_in_helper(obj2);
8319 if (arg3 == NULL) SWIG_fail;
8320 temp3 = true;
8321 }
8322 {
8323 PyThreadState* __tstate = wxPyBeginAllowThreads();
8324 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8325
8326 wxPyEndAllowThreads(__tstate);
8327 if (PyErr_Occurred()) SWIG_fail;
8328 }
8329 {
8330 resultobj = wxPyMake_wxObject(result, 1);
8331 }
8332 {
8333 if (temp3)
8334 delete arg3;
8335 }
8336 return resultobj;
8337 fail:
8338 {
8339 if (temp3)
8340 delete arg3;
8341 }
8342 return NULL;
8343 }
8344
8345
8346 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj;
8348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8349 wxString *arg2 = 0 ;
8350 int arg3 = (int) 0 ;
8351 wxString result;
8352 bool temp2 = false ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 PyObject * obj2 = 0 ;
8356 char *kwnames[] = {
8357 (char *) "self",(char *) "spec",(char *) "flags", NULL
8358 };
8359
8360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8362 if (SWIG_arg_fail(1)) SWIG_fail;
8363 {
8364 arg2 = wxString_in_helper(obj1);
8365 if (arg2 == NULL) SWIG_fail;
8366 temp2 = true;
8367 }
8368 if (obj2) {
8369 {
8370 arg3 = (int)(SWIG_As_int(obj2));
8371 if (SWIG_arg_fail(3)) SWIG_fail;
8372 }
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8377
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 {
8382 #if wxUSE_UNICODE
8383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8384 #else
8385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8386 #endif
8387 }
8388 {
8389 if (temp2)
8390 delete arg2;
8391 }
8392 return resultobj;
8393 fail:
8394 {
8395 if (temp2)
8396 delete arg2;
8397 }
8398 return NULL;
8399 }
8400
8401
8402 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj;
8404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8405 wxString result;
8406 PyObject * obj0 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 result = (arg1)->FindNext();
8417
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 {
8422 #if wxUSE_UNICODE
8423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8424 #else
8425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8426 #endif
8427 }
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj;
8436 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8437 wxString *arg2 = 0 ;
8438 wxString result;
8439 bool temp2 = false ;
8440 PyObject * obj0 = 0 ;
8441 PyObject * obj1 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self",(char *) "location", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 arg2 = wxString_in_helper(obj1);
8451 if (arg2 == NULL) SWIG_fail;
8452 temp2 = true;
8453 }
8454 {
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (arg1)->GetProtocol((wxString const &)*arg2);
8457
8458 wxPyEndAllowThreads(__tstate);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 {
8462 #if wxUSE_UNICODE
8463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8464 #else
8465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8466 #endif
8467 }
8468 {
8469 if (temp2)
8470 delete arg2;
8471 }
8472 return resultobj;
8473 fail:
8474 {
8475 if (temp2)
8476 delete arg2;
8477 }
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj;
8484 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8485 wxString *arg2 = 0 ;
8486 wxString result;
8487 bool temp2 = false ;
8488 PyObject * obj0 = 0 ;
8489 PyObject * obj1 = 0 ;
8490 char *kwnames[] = {
8491 (char *) "self",(char *) "location", NULL
8492 };
8493
8494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8496 if (SWIG_arg_fail(1)) SWIG_fail;
8497 {
8498 arg2 = wxString_in_helper(obj1);
8499 if (arg2 == NULL) SWIG_fail;
8500 temp2 = true;
8501 }
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 #if wxUSE_UNICODE
8511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8512 #else
8513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8514 #endif
8515 }
8516 {
8517 if (temp2)
8518 delete arg2;
8519 }
8520 return resultobj;
8521 fail:
8522 {
8523 if (temp2)
8524 delete arg2;
8525 }
8526 return NULL;
8527 }
8528
8529
8530 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8531 PyObject *resultobj;
8532 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8533 wxString *arg2 = 0 ;
8534 wxString result;
8535 bool temp2 = false ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 char *kwnames[] = {
8539 (char *) "self",(char *) "location", NULL
8540 };
8541
8542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8544 if (SWIG_arg_fail(1)) SWIG_fail;
8545 {
8546 arg2 = wxString_in_helper(obj1);
8547 if (arg2 == NULL) SWIG_fail;
8548 temp2 = true;
8549 }
8550 {
8551 PyThreadState* __tstate = wxPyBeginAllowThreads();
8552 result = (arg1)->GetAnchor((wxString const &)*arg2);
8553
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 #if wxUSE_UNICODE
8559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8560 #else
8561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8562 #endif
8563 }
8564 {
8565 if (temp2)
8566 delete arg2;
8567 }
8568 return resultobj;
8569 fail:
8570 {
8571 if (temp2)
8572 delete arg2;
8573 }
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8581 wxString *arg2 = 0 ;
8582 wxString result;
8583 bool temp2 = false ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 char *kwnames[] = {
8587 (char *) "self",(char *) "location", NULL
8588 };
8589
8590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 {
8594 arg2 = wxString_in_helper(obj1);
8595 if (arg2 == NULL) SWIG_fail;
8596 temp2 = true;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8601
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 {
8606 #if wxUSE_UNICODE
8607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8608 #else
8609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8610 #endif
8611 }
8612 {
8613 if (temp2)
8614 delete arg2;
8615 }
8616 return resultobj;
8617 fail:
8618 {
8619 if (temp2)
8620 delete arg2;
8621 }
8622 return NULL;
8623 }
8624
8625
8626 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj;
8628 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8629 wxString *arg2 = 0 ;
8630 wxString result;
8631 bool temp2 = false ;
8632 PyObject * obj0 = 0 ;
8633 PyObject * obj1 = 0 ;
8634 char *kwnames[] = {
8635 (char *) "self",(char *) "location", NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 {
8642 arg2 = wxString_in_helper(obj1);
8643 if (arg2 == NULL) SWIG_fail;
8644 temp2 = true;
8645 }
8646 {
8647 PyThreadState* __tstate = wxPyBeginAllowThreads();
8648 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8649
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 {
8654 #if wxUSE_UNICODE
8655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8656 #else
8657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8658 #endif
8659 }
8660 {
8661 if (temp2)
8662 delete arg2;
8663 }
8664 return resultobj;
8665 fail:
8666 {
8667 if (temp2)
8668 delete arg2;
8669 }
8670 return NULL;
8671 }
8672
8673
8674 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8675 PyObject *obj;
8676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8677 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8678 Py_INCREF(obj);
8679 return Py_BuildValue((char *)"");
8680 }
8681 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj;
8683 wxFileSystem *result;
8684 char *kwnames[] = {
8685 NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (wxFileSystem *)new wxFileSystem();
8692
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 {
8697 resultobj = wxPyMake_wxObject(result, 1);
8698 }
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj;
8707 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8708 PyObject * obj0 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "self", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 delete arg1;
8719
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 Py_INCREF(Py_None); resultobj = Py_None;
8724 return resultobj;
8725 fail:
8726 return NULL;
8727 }
8728
8729
8730 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8731 PyObject *resultobj;
8732 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8733 wxString *arg2 = 0 ;
8734 bool arg3 = (bool) false ;
8735 bool temp2 = false ;
8736 PyObject * obj0 = 0 ;
8737 PyObject * obj1 = 0 ;
8738 PyObject * obj2 = 0 ;
8739 char *kwnames[] = {
8740 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8741 };
8742
8743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8745 if (SWIG_arg_fail(1)) SWIG_fail;
8746 {
8747 arg2 = wxString_in_helper(obj1);
8748 if (arg2 == NULL) SWIG_fail;
8749 temp2 = true;
8750 }
8751 if (obj2) {
8752 {
8753 arg3 = (bool)(SWIG_As_bool(obj2));
8754 if (SWIG_arg_fail(3)) SWIG_fail;
8755 }
8756 }
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 Py_INCREF(Py_None); resultobj = Py_None;
8765 {
8766 if (temp2)
8767 delete arg2;
8768 }
8769 return resultobj;
8770 fail:
8771 {
8772 if (temp2)
8773 delete arg2;
8774 }
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj;
8781 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8782 wxString result;
8783 PyObject * obj0 = 0 ;
8784 char *kwnames[] = {
8785 (char *) "self", NULL
8786 };
8787
8788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8790 if (SWIG_arg_fail(1)) SWIG_fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 result = (arg1)->GetPath();
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 {
8799 #if wxUSE_UNICODE
8800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8801 #else
8802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8803 #endif
8804 }
8805 return resultobj;
8806 fail:
8807 return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8812 PyObject *resultobj;
8813 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8814 wxString *arg2 = 0 ;
8815 wxFSFile *result;
8816 bool temp2 = false ;
8817 PyObject * obj0 = 0 ;
8818 PyObject * obj1 = 0 ;
8819 char *kwnames[] = {
8820 (char *) "self",(char *) "location", NULL
8821 };
8822
8823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8825 if (SWIG_arg_fail(1)) SWIG_fail;
8826 {
8827 arg2 = wxString_in_helper(obj1);
8828 if (arg2 == NULL) SWIG_fail;
8829 temp2 = true;
8830 }
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8834
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 {
8839 resultobj = wxPyMake_wxObject(result, 1);
8840 }
8841 {
8842 if (temp2)
8843 delete arg2;
8844 }
8845 return resultobj;
8846 fail:
8847 {
8848 if (temp2)
8849 delete arg2;
8850 }
8851 return NULL;
8852 }
8853
8854
8855 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8856 PyObject *resultobj;
8857 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8858 wxString *arg2 = 0 ;
8859 int arg3 = (int) 0 ;
8860 wxString result;
8861 bool temp2 = false ;
8862 PyObject * obj0 = 0 ;
8863 PyObject * obj1 = 0 ;
8864 PyObject * obj2 = 0 ;
8865 char *kwnames[] = {
8866 (char *) "self",(char *) "spec",(char *) "flags", NULL
8867 };
8868
8869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8871 if (SWIG_arg_fail(1)) SWIG_fail;
8872 {
8873 arg2 = wxString_in_helper(obj1);
8874 if (arg2 == NULL) SWIG_fail;
8875 temp2 = true;
8876 }
8877 if (obj2) {
8878 {
8879 arg3 = (int)(SWIG_As_int(obj2));
8880 if (SWIG_arg_fail(3)) SWIG_fail;
8881 }
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 {
8891 #if wxUSE_UNICODE
8892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8893 #else
8894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8895 #endif
8896 }
8897 {
8898 if (temp2)
8899 delete arg2;
8900 }
8901 return resultobj;
8902 fail:
8903 {
8904 if (temp2)
8905 delete arg2;
8906 }
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj;
8913 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8914 wxString result;
8915 PyObject * obj0 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "self", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 {
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 result = (arg1)->FindNext();
8926
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 {
8931 #if wxUSE_UNICODE
8932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8933 #else
8934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8935 #endif
8936 }
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj;
8945 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8946 PyObject * obj0 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "handler", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 wxFileSystem::AddHandler(arg1);
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 Py_INCREF(Py_None); resultobj = Py_None;
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 char *kwnames[] = {
8971 NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 wxFileSystem::CleanUpHandlers();
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 Py_INCREF(Py_None); resultobj = Py_None;
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 wxString *arg1 = 0 ;
8992 wxString result;
8993 bool temp1 = false ;
8994 PyObject * obj0 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "filename", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9000 {
9001 arg1 = wxString_in_helper(obj0);
9002 if (arg1 == NULL) SWIG_fail;
9003 temp1 = true;
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 {
9013 #if wxUSE_UNICODE
9014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9015 #else
9016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9017 #endif
9018 }
9019 {
9020 if (temp1)
9021 delete arg1;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp1)
9027 delete arg1;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxString *arg1 = 0 ;
9036 wxString result;
9037 bool temp1 = false ;
9038 PyObject * obj0 = 0 ;
9039 char *kwnames[] = {
9040 (char *) "url", NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9044 {
9045 arg1 = wxString_in_helper(obj0);
9046 if (arg1 == NULL) SWIG_fail;
9047 temp1 = true;
9048 }
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 result = FileSystem_URLToFileName((wxString const &)*arg1);
9052
9053 wxPyEndAllowThreads(__tstate);
9054 if (PyErr_Occurred()) SWIG_fail;
9055 }
9056 {
9057 #if wxUSE_UNICODE
9058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9059 #else
9060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9061 #endif
9062 }
9063 {
9064 if (temp1)
9065 delete arg1;
9066 }
9067 return resultobj;
9068 fail:
9069 {
9070 if (temp1)
9071 delete arg1;
9072 }
9073 return NULL;
9074 }
9075
9076
9077 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9078 PyObject *obj;
9079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9080 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9081 Py_INCREF(obj);
9082 return Py_BuildValue((char *)"");
9083 }
9084 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj;
9086 wxInternetFSHandler *result;
9087 char *kwnames[] = {
9088 NULL
9089 };
9090
9091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9095
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj;
9108 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9109 wxString *arg2 = 0 ;
9110 bool result;
9111 bool temp2 = false ;
9112 PyObject * obj0 = 0 ;
9113 PyObject * obj1 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "self",(char *) "location", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 {
9122 arg2 = wxString_in_helper(obj1);
9123 if (arg2 == NULL) SWIG_fail;
9124 temp2 = true;
9125 }
9126 {
9127 PyThreadState* __tstate = wxPyBeginAllowThreads();
9128 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9129
9130 wxPyEndAllowThreads(__tstate);
9131 if (PyErr_Occurred()) SWIG_fail;
9132 }
9133 {
9134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9135 }
9136 {
9137 if (temp2)
9138 delete arg2;
9139 }
9140 return resultobj;
9141 fail:
9142 {
9143 if (temp2)
9144 delete arg2;
9145 }
9146 return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj;
9152 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9153 wxFileSystem *arg2 = 0 ;
9154 wxString *arg3 = 0 ;
9155 wxFSFile *result;
9156 bool temp3 = false ;
9157 PyObject * obj0 = 0 ;
9158 PyObject * obj1 = 0 ;
9159 PyObject * obj2 = 0 ;
9160 char *kwnames[] = {
9161 (char *) "self",(char *) "fs",(char *) "location", NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9166 if (SWIG_arg_fail(1)) SWIG_fail;
9167 {
9168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9169 if (SWIG_arg_fail(2)) SWIG_fail;
9170 if (arg2 == NULL) {
9171 SWIG_null_ref("wxFileSystem");
9172 }
9173 if (SWIG_arg_fail(2)) SWIG_fail;
9174 }
9175 {
9176 arg3 = wxString_in_helper(obj2);
9177 if (arg3 == NULL) SWIG_fail;
9178 temp3 = true;
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9183
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 {
9188 resultobj = wxPyMake_wxObject(result, 1);
9189 }
9190 {
9191 if (temp3)
9192 delete arg3;
9193 }
9194 return resultobj;
9195 fail:
9196 {
9197 if (temp3)
9198 delete arg3;
9199 }
9200 return NULL;
9201 }
9202
9203
9204 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9205 PyObject *obj;
9206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9207 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9208 Py_INCREF(obj);
9209 return Py_BuildValue((char *)"");
9210 }
9211 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 wxZipFSHandler *result;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (wxZipFSHandler *)new wxZipFSHandler();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9236 wxString *arg2 = 0 ;
9237 bool result;
9238 bool temp2 = false ;
9239 PyObject * obj0 = 0 ;
9240 PyObject * obj1 = 0 ;
9241 char *kwnames[] = {
9242 (char *) "self",(char *) "location", NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9247 if (SWIG_arg_fail(1)) SWIG_fail;
9248 {
9249 arg2 = wxString_in_helper(obj1);
9250 if (arg2 == NULL) SWIG_fail;
9251 temp2 = true;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9262 }
9263 {
9264 if (temp2)
9265 delete arg2;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp2)
9271 delete arg2;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9278 PyObject *resultobj;
9279 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9280 wxFileSystem *arg2 = 0 ;
9281 wxString *arg3 = 0 ;
9282 wxFSFile *result;
9283 bool temp3 = false ;
9284 PyObject * obj0 = 0 ;
9285 PyObject * obj1 = 0 ;
9286 PyObject * obj2 = 0 ;
9287 char *kwnames[] = {
9288 (char *) "self",(char *) "fs",(char *) "location", NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9293 if (SWIG_arg_fail(1)) SWIG_fail;
9294 {
9295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9296 if (SWIG_arg_fail(2)) SWIG_fail;
9297 if (arg2 == NULL) {
9298 SWIG_null_ref("wxFileSystem");
9299 }
9300 if (SWIG_arg_fail(2)) SWIG_fail;
9301 }
9302 {
9303 arg3 = wxString_in_helper(obj2);
9304 if (arg3 == NULL) SWIG_fail;
9305 temp3 = true;
9306 }
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 resultobj = wxPyMake_wxObject(result, 1);
9316 }
9317 {
9318 if (temp3)
9319 delete arg3;
9320 }
9321 return resultobj;
9322 fail:
9323 {
9324 if (temp3)
9325 delete arg3;
9326 }
9327 return NULL;
9328 }
9329
9330
9331 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj;
9333 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9334 wxString *arg2 = 0 ;
9335 int arg3 = (int) 0 ;
9336 wxString result;
9337 bool temp2 = false ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 PyObject * obj2 = 0 ;
9341 char *kwnames[] = {
9342 (char *) "self",(char *) "spec",(char *) "flags", NULL
9343 };
9344
9345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9347 if (SWIG_arg_fail(1)) SWIG_fail;
9348 {
9349 arg2 = wxString_in_helper(obj1);
9350 if (arg2 == NULL) SWIG_fail;
9351 temp2 = true;
9352 }
9353 if (obj2) {
9354 {
9355 arg3 = (int)(SWIG_As_int(obj2));
9356 if (SWIG_arg_fail(3)) SWIG_fail;
9357 }
9358 }
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9362
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 {
9367 #if wxUSE_UNICODE
9368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9369 #else
9370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9371 #endif
9372 }
9373 {
9374 if (temp2)
9375 delete arg2;
9376 }
9377 return resultobj;
9378 fail:
9379 {
9380 if (temp2)
9381 delete arg2;
9382 }
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9390 wxString result;
9391 PyObject * obj0 = 0 ;
9392 char *kwnames[] = {
9393 (char *) "self", NULL
9394 };
9395
9396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (arg1)->FindNext();
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 #if wxUSE_UNICODE
9408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9409 #else
9410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9411 #endif
9412 }
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9420 PyObject *obj;
9421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9422 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9423 Py_INCREF(obj);
9424 return Py_BuildValue((char *)"");
9425 }
9426 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9427 PyObject *resultobj;
9428 wxString *arg1 = 0 ;
9429 wxImage *arg2 = 0 ;
9430 long arg3 ;
9431 bool temp1 = false ;
9432 PyObject * obj0 = 0 ;
9433 PyObject * obj1 = 0 ;
9434 PyObject * obj2 = 0 ;
9435 char *kwnames[] = {
9436 (char *) "filename",(char *) "image",(char *) "type", NULL
9437 };
9438
9439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9440 {
9441 arg1 = wxString_in_helper(obj0);
9442 if (arg1 == NULL) SWIG_fail;
9443 temp1 = true;
9444 }
9445 {
9446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9447 if (SWIG_arg_fail(2)) SWIG_fail;
9448 if (arg2 == NULL) {
9449 SWIG_null_ref("wxImage");
9450 }
9451 if (SWIG_arg_fail(2)) SWIG_fail;
9452 }
9453 {
9454 arg3 = (long)(SWIG_As_long(obj2));
9455 if (SWIG_arg_fail(3)) SWIG_fail;
9456 }
9457 {
9458 PyThreadState* __tstate = wxPyBeginAllowThreads();
9459 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9460
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 Py_INCREF(Py_None); resultobj = Py_None;
9465 {
9466 if (temp1)
9467 delete arg1;
9468 }
9469 return resultobj;
9470 fail:
9471 {
9472 if (temp1)
9473 delete arg1;
9474 }
9475 return NULL;
9476 }
9477
9478
9479 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj;
9481 wxString *arg1 = 0 ;
9482 wxBitmap *arg2 = 0 ;
9483 long arg3 ;
9484 bool temp1 = false ;
9485 PyObject * obj0 = 0 ;
9486 PyObject * obj1 = 0 ;
9487 PyObject * obj2 = 0 ;
9488 char *kwnames[] = {
9489 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9490 };
9491
9492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9493 {
9494 arg1 = wxString_in_helper(obj0);
9495 if (arg1 == NULL) SWIG_fail;
9496 temp1 = true;
9497 }
9498 {
9499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9500 if (SWIG_arg_fail(2)) SWIG_fail;
9501 if (arg2 == NULL) {
9502 SWIG_null_ref("wxBitmap");
9503 }
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 }
9506 {
9507 arg3 = (long)(SWIG_As_long(obj2));
9508 if (SWIG_arg_fail(3)) SWIG_fail;
9509 }
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 Py_INCREF(Py_None); resultobj = Py_None;
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp1)
9526 delete arg1;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxString *arg1 = 0 ;
9535 PyObject *arg2 = (PyObject *) 0 ;
9536 bool temp1 = false ;
9537 PyObject * obj0 = 0 ;
9538 PyObject * obj1 = 0 ;
9539 char *kwnames[] = {
9540 (char *) "filename",(char *) "data", NULL
9541 };
9542
9543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9544 {
9545 arg1 = wxString_in_helper(obj0);
9546 if (arg1 == NULL) SWIG_fail;
9547 temp1 = true;
9548 }
9549 arg2 = obj1;
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9553
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 Py_INCREF(Py_None); resultobj = Py_None;
9558 {
9559 if (temp1)
9560 delete arg1;
9561 }
9562 return resultobj;
9563 fail:
9564 {
9565 if (temp1)
9566 delete arg1;
9567 }
9568 return NULL;
9569 }
9570
9571
9572 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj;
9574 wxMemoryFSHandler *result;
9575 char *kwnames[] = {
9576 NULL
9577 };
9578
9579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9580 {
9581 PyThreadState* __tstate = wxPyBeginAllowThreads();
9582 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9583
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj;
9596 wxString *arg1 = 0 ;
9597 bool temp1 = false ;
9598 PyObject * obj0 = 0 ;
9599 char *kwnames[] = {
9600 (char *) "filename", NULL
9601 };
9602
9603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9604 {
9605 arg1 = wxString_in_helper(obj0);
9606 if (arg1 == NULL) SWIG_fail;
9607 temp1 = true;
9608 }
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 Py_INCREF(Py_None); resultobj = Py_None;
9617 {
9618 if (temp1)
9619 delete arg1;
9620 }
9621 return resultobj;
9622 fail:
9623 {
9624 if (temp1)
9625 delete arg1;
9626 }
9627 return NULL;
9628 }
9629
9630
9631 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj;
9633 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9634 wxString *arg2 = 0 ;
9635 bool result;
9636 bool temp2 = false ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char *kwnames[] = {
9640 (char *) "self",(char *) "location", NULL
9641 };
9642
9643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9645 if (SWIG_arg_fail(1)) SWIG_fail;
9646 {
9647 arg2 = wxString_in_helper(obj1);
9648 if (arg2 == NULL) SWIG_fail;
9649 temp2 = true;
9650 }
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9654
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 {
9659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9660 }
9661 {
9662 if (temp2)
9663 delete arg2;
9664 }
9665 return resultobj;
9666 fail:
9667 {
9668 if (temp2)
9669 delete arg2;
9670 }
9671 return NULL;
9672 }
9673
9674
9675 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj;
9677 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9678 wxFileSystem *arg2 = 0 ;
9679 wxString *arg3 = 0 ;
9680 wxFSFile *result;
9681 bool temp3 = false ;
9682 PyObject * obj0 = 0 ;
9683 PyObject * obj1 = 0 ;
9684 PyObject * obj2 = 0 ;
9685 char *kwnames[] = {
9686 (char *) "self",(char *) "fs",(char *) "location", NULL
9687 };
9688
9689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9691 if (SWIG_arg_fail(1)) SWIG_fail;
9692 {
9693 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(2)) SWIG_fail;
9695 if (arg2 == NULL) {
9696 SWIG_null_ref("wxFileSystem");
9697 }
9698 if (SWIG_arg_fail(2)) SWIG_fail;
9699 }
9700 {
9701 arg3 = wxString_in_helper(obj2);
9702 if (arg3 == NULL) SWIG_fail;
9703 temp3 = true;
9704 }
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9708
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 {
9713 resultobj = wxPyMake_wxObject(result, 1);
9714 }
9715 {
9716 if (temp3)
9717 delete arg3;
9718 }
9719 return resultobj;
9720 fail:
9721 {
9722 if (temp3)
9723 delete arg3;
9724 }
9725 return NULL;
9726 }
9727
9728
9729 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9730 PyObject *resultobj;
9731 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9732 wxString *arg2 = 0 ;
9733 int arg3 = (int) 0 ;
9734 wxString result;
9735 bool temp2 = false ;
9736 PyObject * obj0 = 0 ;
9737 PyObject * obj1 = 0 ;
9738 PyObject * obj2 = 0 ;
9739 char *kwnames[] = {
9740 (char *) "self",(char *) "spec",(char *) "flags", NULL
9741 };
9742
9743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9745 if (SWIG_arg_fail(1)) SWIG_fail;
9746 {
9747 arg2 = wxString_in_helper(obj1);
9748 if (arg2 == NULL) SWIG_fail;
9749 temp2 = true;
9750 }
9751 if (obj2) {
9752 {
9753 arg3 = (int)(SWIG_As_int(obj2));
9754 if (SWIG_arg_fail(3)) SWIG_fail;
9755 }
9756 }
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 #if wxUSE_UNICODE
9766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9767 #else
9768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9769 #endif
9770 }
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 return resultobj;
9776 fail:
9777 {
9778 if (temp2)
9779 delete arg2;
9780 }
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9788 wxString result;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = (arg1)->FindNext();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9818 PyObject *obj;
9819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9820 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9821 Py_INCREF(obj);
9822 return Py_BuildValue((char *)"");
9823 }
9824 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9827 wxString result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (arg1)->GetName();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 {
9844 #if wxUSE_UNICODE
9845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9846 #else
9847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9848 #endif
9849 }
9850 return resultobj;
9851 fail:
9852 return NULL;
9853 }
9854
9855
9856 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj;
9858 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9859 wxString result;
9860 PyObject * obj0 = 0 ;
9861 char *kwnames[] = {
9862 (char *) "self", NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9867 if (SWIG_arg_fail(1)) SWIG_fail;
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (arg1)->GetExtension();
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 {
9876 #if wxUSE_UNICODE
9877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9878 #else
9879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9880 #endif
9881 }
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9891 long result;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "self", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9899 if (SWIG_arg_fail(1)) SWIG_fail;
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = (long)(arg1)->GetType();
9903
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = SWIG_From_long((long)(result));
9909 }
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9919 wxString result;
9920 PyObject * obj0 = 0 ;
9921 char *kwnames[] = {
9922 (char *) "self", NULL
9923 };
9924
9925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9927 if (SWIG_arg_fail(1)) SWIG_fail;
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 result = (arg1)->GetMimeType();
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 {
9936 #if wxUSE_UNICODE
9937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9938 #else
9939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9940 #endif
9941 }
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj;
9950 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9951 wxString *arg2 = 0 ;
9952 bool result;
9953 bool temp2 = false ;
9954 PyObject * obj0 = 0 ;
9955 PyObject * obj1 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self",(char *) "name", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 arg2 = wxString_in_helper(obj1);
9965 if (arg2 == NULL) SWIG_fail;
9966 temp2 = true;
9967 }
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9977 }
9978 {
9979 if (temp2)
9980 delete arg2;
9981 }
9982 return resultobj;
9983 fail:
9984 {
9985 if (temp2)
9986 delete arg2;
9987 }
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9995 wxString *arg2 = 0 ;
9996 bool temp2 = false ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "self",(char *) "name", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10005 if (SWIG_arg_fail(1)) SWIG_fail;
10006 {
10007 arg2 = wxString_in_helper(obj1);
10008 if (arg2 == NULL) SWIG_fail;
10009 temp2 = true;
10010 }
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 (arg1)->SetName((wxString const &)*arg2);
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 Py_INCREF(Py_None); resultobj = Py_None;
10019 {
10020 if (temp2)
10021 delete arg2;
10022 }
10023 return resultobj;
10024 fail:
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return NULL;
10030 }
10031
10032
10033 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10034 PyObject *resultobj;
10035 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10036 wxString *arg2 = 0 ;
10037 bool temp2 = false ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 char *kwnames[] = {
10041 (char *) "self",(char *) "extension", NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10046 if (SWIG_arg_fail(1)) SWIG_fail;
10047 {
10048 arg2 = wxString_in_helper(obj1);
10049 if (arg2 == NULL) SWIG_fail;
10050 temp2 = true;
10051 }
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 (arg1)->SetExtension((wxString const &)*arg2);
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 Py_INCREF(Py_None); resultobj = Py_None;
10060 {
10061 if (temp2)
10062 delete arg2;
10063 }
10064 return resultobj;
10065 fail:
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return NULL;
10071 }
10072
10073
10074 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10075 PyObject *resultobj;
10076 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10077 long arg2 ;
10078 PyObject * obj0 = 0 ;
10079 PyObject * obj1 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "self",(char *) "type", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10086 if (SWIG_arg_fail(1)) SWIG_fail;
10087 {
10088 arg2 = (long)(SWIG_As_long(obj1));
10089 if (SWIG_arg_fail(2)) SWIG_fail;
10090 }
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 (arg1)->SetType(arg2);
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 Py_INCREF(Py_None); resultobj = Py_None;
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 wxString *arg2 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char *kwnames[] = {
10113 (char *) "self",(char *) "mimetype", NULL
10114 };
10115
10116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10118 if (SWIG_arg_fail(1)) SWIG_fail;
10119 {
10120 arg2 = wxString_in_helper(obj1);
10121 if (arg2 == NULL) SWIG_fail;
10122 temp2 = true;
10123 }
10124 {
10125 PyThreadState* __tstate = wxPyBeginAllowThreads();
10126 (arg1)->SetMimeType((wxString const &)*arg2);
10127
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 Py_INCREF(Py_None); resultobj = Py_None;
10132 {
10133 if (temp2)
10134 delete arg2;
10135 }
10136 return resultobj;
10137 fail:
10138 {
10139 if (temp2)
10140 delete arg2;
10141 }
10142 return NULL;
10143 }
10144
10145
10146 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10147 PyObject *obj;
10148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10149 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10150 Py_INCREF(obj);
10151 return Py_BuildValue((char *)"");
10152 }
10153 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxImageHistogram *result;
10156 char *kwnames[] = {
10157 NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10161 {
10162 PyThreadState* __tstate = wxPyBeginAllowThreads();
10163 result = (wxImageHistogram *)new wxImageHistogram();
10164
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10169 return resultobj;
10170 fail:
10171 return NULL;
10172 }
10173
10174
10175 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj;
10177 unsigned char arg1 ;
10178 unsigned char arg2 ;
10179 unsigned char arg3 ;
10180 unsigned long result;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 PyObject * obj2 = 0 ;
10184 char *kwnames[] = {
10185 (char *) "r",(char *) "g",(char *) "b", NULL
10186 };
10187
10188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10189 {
10190 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 }
10193 {
10194 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10195 if (SWIG_arg_fail(2)) SWIG_fail;
10196 }
10197 {
10198 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10199 if (SWIG_arg_fail(3)) SWIG_fail;
10200 }
10201 {
10202 PyThreadState* __tstate = wxPyBeginAllowThreads();
10203 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10204
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 {
10209 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10218 PyObject *resultobj;
10219 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10220 unsigned char *arg2 = (unsigned char *) 0 ;
10221 unsigned char *arg3 = (unsigned char *) 0 ;
10222 unsigned char *arg4 = (unsigned char *) 0 ;
10223 unsigned char arg5 = (unsigned char) 1 ;
10224 unsigned char arg6 = (unsigned char) 0 ;
10225 unsigned char arg7 = (unsigned char) 0 ;
10226 bool result;
10227 unsigned char temp2 ;
10228 int res2 = 0 ;
10229 unsigned char temp3 ;
10230 int res3 = 0 ;
10231 unsigned char temp4 ;
10232 int res4 = 0 ;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 PyObject * obj2 = 0 ;
10236 PyObject * obj3 = 0 ;
10237 char *kwnames[] = {
10238 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10239 };
10240
10241 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10242 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10243 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10246 if (SWIG_arg_fail(1)) SWIG_fail;
10247 if (obj1) {
10248 {
10249 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10250 if (SWIG_arg_fail(5)) SWIG_fail;
10251 }
10252 }
10253 if (obj2) {
10254 {
10255 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10256 if (SWIG_arg_fail(6)) SWIG_fail;
10257 }
10258 }
10259 if (obj3) {
10260 {
10261 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10262 if (SWIG_arg_fail(7)) SWIG_fail;
10263 }
10264 }
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10268
10269 wxPyEndAllowThreads(__tstate);
10270 if (PyErr_Occurred()) SWIG_fail;
10271 }
10272 {
10273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10274 }
10275 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10276 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10277 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10278 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10279 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10288 PyObject *obj;
10289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10290 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10291 Py_INCREF(obj);
10292 return Py_BuildValue((char *)"");
10293 }
10294 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj;
10296 wxString *arg1 = 0 ;
10297 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10298 int arg3 = (int) -1 ;
10299 wxImage *result;
10300 bool temp1 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 char *kwnames[] = {
10305 (char *) "name",(char *) "type",(char *) "index", NULL
10306 };
10307
10308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10309 {
10310 arg1 = wxString_in_helper(obj0);
10311 if (arg1 == NULL) SWIG_fail;
10312 temp1 = true;
10313 }
10314 if (obj1) {
10315 {
10316 arg2 = (long)(SWIG_As_long(obj1));
10317 if (SWIG_arg_fail(2)) SWIG_fail;
10318 }
10319 }
10320 if (obj2) {
10321 {
10322 arg3 = (int)(SWIG_As_int(obj2));
10323 if (SWIG_arg_fail(3)) SWIG_fail;
10324 }
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10329
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10334 {
10335 if (temp1)
10336 delete arg1;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp1)
10342 delete arg1;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj;
10350 wxImage *arg1 = (wxImage *) 0 ;
10351 PyObject * obj0 = 0 ;
10352 char *kwnames[] = {
10353 (char *) "self", NULL
10354 };
10355
10356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(1)) SWIG_fail;
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 delete arg1;
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxString *arg1 = 0 ;
10376 wxString *arg2 = 0 ;
10377 int arg3 = (int) -1 ;
10378 wxImage *result;
10379 bool temp1 = false ;
10380 bool temp2 = false ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 PyObject * obj2 = 0 ;
10384 char *kwnames[] = {
10385 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10386 };
10387
10388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10389 {
10390 arg1 = wxString_in_helper(obj0);
10391 if (arg1 == NULL) SWIG_fail;
10392 temp1 = true;
10393 }
10394 {
10395 arg2 = wxString_in_helper(obj1);
10396 if (arg2 == NULL) SWIG_fail;
10397 temp2 = true;
10398 }
10399 if (obj2) {
10400 {
10401 arg3 = (int)(SWIG_As_int(obj2));
10402 if (SWIG_arg_fail(3)) SWIG_fail;
10403 }
10404 }
10405 {
10406 PyThreadState* __tstate = wxPyBeginAllowThreads();
10407 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10408
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10413 {
10414 if (temp1)
10415 delete arg1;
10416 }
10417 {
10418 if (temp2)
10419 delete arg2;
10420 }
10421 return resultobj;
10422 fail:
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxInputStream *arg1 = 0 ;
10438 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10439 int arg3 = (int) -1 ;
10440 wxImage *result;
10441 wxPyInputStream *temp1 ;
10442 bool created1 ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445 PyObject * obj2 = 0 ;
10446 char *kwnames[] = {
10447 (char *) "stream",(char *) "type",(char *) "index", NULL
10448 };
10449
10450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10451 {
10452 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10453 arg1 = temp1->m_wxis;
10454 created1 = false;
10455 } else {
10456 PyErr_Clear(); // clear the failure of the wxPyConvert above
10457 arg1 = wxPyCBInputStream_create(obj0, false);
10458 if (arg1 == NULL) {
10459 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10460 SWIG_fail;
10461 }
10462 created1 = true;
10463 }
10464 }
10465 if (obj1) {
10466 {
10467 arg2 = (long)(SWIG_As_long(obj1));
10468 if (SWIG_arg_fail(2)) SWIG_fail;
10469 }
10470 }
10471 if (obj2) {
10472 {
10473 arg3 = (int)(SWIG_As_int(obj2));
10474 if (SWIG_arg_fail(3)) SWIG_fail;
10475 }
10476 }
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10480
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10485 {
10486 if (created1)
10487 delete arg1;
10488 }
10489 return resultobj;
10490 fail:
10491 {
10492 if (created1)
10493 delete arg1;
10494 }
10495 return NULL;
10496 }
10497
10498
10499 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10500 PyObject *resultobj;
10501 wxInputStream *arg1 = 0 ;
10502 wxString *arg2 = 0 ;
10503 int arg3 = (int) -1 ;
10504 wxImage *result;
10505 wxPyInputStream *temp1 ;
10506 bool created1 ;
10507 bool temp2 = false ;
10508 PyObject * obj0 = 0 ;
10509 PyObject * obj1 = 0 ;
10510 PyObject * obj2 = 0 ;
10511 char *kwnames[] = {
10512 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10513 };
10514
10515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10516 {
10517 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10518 arg1 = temp1->m_wxis;
10519 created1 = false;
10520 } else {
10521 PyErr_Clear(); // clear the failure of the wxPyConvert above
10522 arg1 = wxPyCBInputStream_create(obj0, false);
10523 if (arg1 == NULL) {
10524 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10525 SWIG_fail;
10526 }
10527 created1 = true;
10528 }
10529 }
10530 {
10531 arg2 = wxString_in_helper(obj1);
10532 if (arg2 == NULL) SWIG_fail;
10533 temp2 = true;
10534 }
10535 if (obj2) {
10536 {
10537 arg3 = (int)(SWIG_As_int(obj2));
10538 if (SWIG_arg_fail(3)) SWIG_fail;
10539 }
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10544
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10549 {
10550 if (created1)
10551 delete arg1;
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (created1)
10561 delete arg1;
10562 }
10563 {
10564 if (temp2)
10565 delete arg2;
10566 }
10567 return NULL;
10568 }
10569
10570
10571 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj;
10573 int arg1 = (int) 0 ;
10574 int arg2 = (int) 0 ;
10575 bool arg3 = (bool) true ;
10576 wxImage *result;
10577 PyObject * obj0 = 0 ;
10578 PyObject * obj1 = 0 ;
10579 PyObject * obj2 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "width",(char *) "height",(char *) "clear", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10585 if (obj0) {
10586 {
10587 arg1 = (int)(SWIG_As_int(obj0));
10588 if (SWIG_arg_fail(1)) SWIG_fail;
10589 }
10590 }
10591 if (obj1) {
10592 {
10593 arg2 = (int)(SWIG_As_int(obj1));
10594 if (SWIG_arg_fail(2)) SWIG_fail;
10595 }
10596 }
10597 if (obj2) {
10598 {
10599 arg3 = (bool)(SWIG_As_bool(obj2));
10600 if (SWIG_arg_fail(3)) SWIG_fail;
10601 }
10602 }
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10606
10607 wxPyEndAllowThreads(__tstate);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10618 PyObject *resultobj;
10619 wxBitmap *arg1 = 0 ;
10620 wxImage *result;
10621 PyObject * obj0 = 0 ;
10622 char *kwnames[] = {
10623 (char *) "bitmap", NULL
10624 };
10625
10626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10627 {
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 if (arg1 == NULL) {
10631 SWIG_null_ref("wxBitmap");
10632 }
10633 if (SWIG_arg_fail(1)) SWIG_fail;
10634 }
10635 {
10636 if (!wxPyCheckForApp()) SWIG_fail;
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10639
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj;
10652 int arg1 ;
10653 int arg2 ;
10654 unsigned char *arg3 = (unsigned char *) 0 ;
10655 wxImage *result;
10656 PyObject * obj0 = 0 ;
10657 PyObject * obj1 = 0 ;
10658 PyObject * obj2 = 0 ;
10659 char *kwnames[] = {
10660 (char *) "width",(char *) "height",(char *) "data", NULL
10661 };
10662
10663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10664 {
10665 arg1 = (int)(SWIG_As_int(obj0));
10666 if (SWIG_arg_fail(1)) SWIG_fail;
10667 }
10668 {
10669 arg2 = (int)(SWIG_As_int(obj1));
10670 if (SWIG_arg_fail(2)) SWIG_fail;
10671 }
10672 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10673 if (SWIG_arg_fail(3)) SWIG_fail;
10674 {
10675 PyThreadState* __tstate = wxPyBeginAllowThreads();
10676 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10677
10678 wxPyEndAllowThreads(__tstate);
10679 if (PyErr_Occurred()) SWIG_fail;
10680 }
10681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10682 return resultobj;
10683 fail:
10684 return NULL;
10685 }
10686
10687
10688 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10689 PyObject *resultobj;
10690 int arg1 ;
10691 int arg2 ;
10692 unsigned char *arg3 = (unsigned char *) 0 ;
10693 unsigned char *arg4 = (unsigned char *) 0 ;
10694 wxImage *result;
10695 PyObject * obj0 = 0 ;
10696 PyObject * obj1 = 0 ;
10697 PyObject * obj2 = 0 ;
10698 PyObject * obj3 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10704 {
10705 arg1 = (int)(SWIG_As_int(obj0));
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 }
10708 {
10709 arg2 = (int)(SWIG_As_int(obj1));
10710 if (SWIG_arg_fail(2)) SWIG_fail;
10711 }
10712 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10713 if (SWIG_arg_fail(3)) SWIG_fail;
10714 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10715 if (SWIG_arg_fail(4)) SWIG_fail;
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10719
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj;
10732 wxImage *arg1 = (wxImage *) 0 ;
10733 int arg2 ;
10734 int arg3 ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 PyObject * obj2 = 0 ;
10738 char *kwnames[] = {
10739 (char *) "self",(char *) "width",(char *) "height", NULL
10740 };
10741
10742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10744 if (SWIG_arg_fail(1)) SWIG_fail;
10745 {
10746 arg2 = (int)(SWIG_As_int(obj1));
10747 if (SWIG_arg_fail(2)) SWIG_fail;
10748 }
10749 {
10750 arg3 = (int)(SWIG_As_int(obj2));
10751 if (SWIG_arg_fail(3)) SWIG_fail;
10752 }
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 (arg1)->Create(arg2,arg3);
10756
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 Py_INCREF(Py_None); resultobj = Py_None;
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj;
10769 wxImage *arg1 = (wxImage *) 0 ;
10770 PyObject * obj0 = 0 ;
10771 char *kwnames[] = {
10772 (char *) "self", NULL
10773 };
10774
10775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10777 if (SWIG_arg_fail(1)) SWIG_fail;
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 (arg1)->Destroy();
10781
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 Py_INCREF(Py_None); resultobj = Py_None;
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj;
10794 wxImage *arg1 = (wxImage *) 0 ;
10795 int arg2 ;
10796 int arg3 ;
10797 SwigValueWrapper<wxImage > result;
10798 PyObject * obj0 = 0 ;
10799 PyObject * obj1 = 0 ;
10800 PyObject * obj2 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "self",(char *) "width",(char *) "height", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 {
10809 arg2 = (int)(SWIG_As_int(obj1));
10810 if (SWIG_arg_fail(2)) SWIG_fail;
10811 }
10812 {
10813 arg3 = (int)(SWIG_As_int(obj2));
10814 if (SWIG_arg_fail(3)) SWIG_fail;
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (arg1)->Scale(arg2,arg3);
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 {
10824 wxImage * resultptr;
10825 resultptr = new wxImage((wxImage &)(result));
10826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10827 }
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 wxImage *arg1 = (wxImage *) 0 ;
10837 int arg2 ;
10838 int arg3 ;
10839 SwigValueWrapper<wxImage > result;
10840 PyObject * obj0 = 0 ;
10841 PyObject * obj1 = 0 ;
10842 PyObject * obj2 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = (int)(SWIG_As_int(obj1));
10852 if (SWIG_arg_fail(2)) SWIG_fail;
10853 }
10854 {
10855 arg3 = (int)(SWIG_As_int(obj2));
10856 if (SWIG_arg_fail(3)) SWIG_fail;
10857 }
10858 {
10859 PyThreadState* __tstate = wxPyBeginAllowThreads();
10860 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10861
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 {
10866 wxImage * resultptr;
10867 resultptr = new wxImage((wxImage &)(result));
10868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10869 }
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj;
10878 wxImage *arg1 = (wxImage *) 0 ;
10879 int arg2 ;
10880 int arg3 ;
10881 wxImage *result;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 PyObject * obj2 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self",(char *) "width",(char *) "height", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 arg3 = (int)(SWIG_As_int(obj2));
10898 if (SWIG_arg_fail(3)) SWIG_fail;
10899 }
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 {
10903 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10904 result = (wxImage *) &_result_ref;
10905 }
10906
10907 wxPyEndAllowThreads(__tstate);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10918 PyObject *resultobj;
10919 wxImage *arg1 = (wxImage *) 0 ;
10920 int arg2 ;
10921 int arg3 ;
10922 unsigned char arg4 ;
10923 unsigned char arg5 ;
10924 unsigned char arg6 ;
10925 PyObject * obj0 = 0 ;
10926 PyObject * obj1 = 0 ;
10927 PyObject * obj2 = 0 ;
10928 PyObject * obj3 = 0 ;
10929 PyObject * obj4 = 0 ;
10930 PyObject * obj5 = 0 ;
10931 char *kwnames[] = {
10932 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10933 };
10934
10935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10937 if (SWIG_arg_fail(1)) SWIG_fail;
10938 {
10939 arg2 = (int)(SWIG_As_int(obj1));
10940 if (SWIG_arg_fail(2)) SWIG_fail;
10941 }
10942 {
10943 arg3 = (int)(SWIG_As_int(obj2));
10944 if (SWIG_arg_fail(3)) SWIG_fail;
10945 }
10946 {
10947 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10948 if (SWIG_arg_fail(4)) SWIG_fail;
10949 }
10950 {
10951 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10952 if (SWIG_arg_fail(5)) SWIG_fail;
10953 }
10954 {
10955 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10956 if (SWIG_arg_fail(6)) SWIG_fail;
10957 }
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj;
10974 wxImage *arg1 = (wxImage *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 unsigned char result;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "x",(char *) "y", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj;
11014 wxImage *arg1 = (wxImage *) 0 ;
11015 int arg2 ;
11016 int arg3 ;
11017 unsigned char result;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 PyObject * obj2 = 0 ;
11021 char *kwnames[] = {
11022 (char *) "self",(char *) "x",(char *) "y", NULL
11023 };
11024
11025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11027 if (SWIG_arg_fail(1)) SWIG_fail;
11028 {
11029 arg2 = (int)(SWIG_As_int(obj1));
11030 if (SWIG_arg_fail(2)) SWIG_fail;
11031 }
11032 {
11033 arg3 = (int)(SWIG_As_int(obj2));
11034 if (SWIG_arg_fail(3)) SWIG_fail;
11035 }
11036 {
11037 PyThreadState* __tstate = wxPyBeginAllowThreads();
11038 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11039
11040 wxPyEndAllowThreads(__tstate);
11041 if (PyErr_Occurred()) SWIG_fail;
11042 }
11043 {
11044 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11045 }
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11053 PyObject *resultobj;
11054 wxImage *arg1 = (wxImage *) 0 ;
11055 int arg2 ;
11056 int arg3 ;
11057 unsigned char result;
11058 PyObject * obj0 = 0 ;
11059 PyObject * obj1 = 0 ;
11060 PyObject * obj2 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "self",(char *) "x",(char *) "y", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 {
11069 arg2 = (int)(SWIG_As_int(obj1));
11070 if (SWIG_arg_fail(2)) SWIG_fail;
11071 }
11072 {
11073 arg3 = (int)(SWIG_As_int(obj2));
11074 if (SWIG_arg_fail(3)) SWIG_fail;
11075 }
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11079
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11085 }
11086 return resultobj;
11087 fail:
11088 return NULL;
11089 }
11090
11091
11092 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj;
11094 wxImage *arg1 = (wxImage *) 0 ;
11095 int arg2 ;
11096 int arg3 ;
11097 unsigned char arg4 ;
11098 PyObject * obj0 = 0 ;
11099 PyObject * obj1 = 0 ;
11100 PyObject * obj2 = 0 ;
11101 PyObject * obj3 = 0 ;
11102 char *kwnames[] = {
11103 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11104 };
11105
11106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11108 if (SWIG_arg_fail(1)) SWIG_fail;
11109 {
11110 arg2 = (int)(SWIG_As_int(obj1));
11111 if (SWIG_arg_fail(2)) SWIG_fail;
11112 }
11113 {
11114 arg3 = (int)(SWIG_As_int(obj2));
11115 if (SWIG_arg_fail(3)) SWIG_fail;
11116 }
11117 {
11118 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11119 if (SWIG_arg_fail(4)) SWIG_fail;
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 (arg1)->SetAlpha(arg2,arg3,arg4);
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 Py_INCREF(Py_None); resultobj = Py_None;
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj;
11137 wxImage *arg1 = (wxImage *) 0 ;
11138 int arg2 ;
11139 int arg3 ;
11140 unsigned char result;
11141 PyObject * obj0 = 0 ;
11142 PyObject * obj1 = 0 ;
11143 PyObject * obj2 = 0 ;
11144 char *kwnames[] = {
11145 (char *) "self",(char *) "x",(char *) "y", NULL
11146 };
11147
11148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11150 if (SWIG_arg_fail(1)) SWIG_fail;
11151 {
11152 arg2 = (int)(SWIG_As_int(obj1));
11153 if (SWIG_arg_fail(2)) SWIG_fail;
11154 }
11155 {
11156 arg3 = (int)(SWIG_As_int(obj2));
11157 if (SWIG_arg_fail(3)) SWIG_fail;
11158 }
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11168 }
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11176 PyObject *resultobj;
11177 wxImage *arg1 = (wxImage *) 0 ;
11178 bool result;
11179 PyObject * obj0 = 0 ;
11180 char *kwnames[] = {
11181 (char *) "self", NULL
11182 };
11183
11184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11186 if (SWIG_arg_fail(1)) SWIG_fail;
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (bool)(arg1)->HasAlpha();
11190
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 {
11195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11196 }
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11204 PyObject *resultobj;
11205 wxImage *arg1 = (wxImage *) 0 ;
11206 byte *arg2 = (byte *) 0 ;
11207 byte *arg3 = (byte *) 0 ;
11208 byte *arg4 = (byte *) 0 ;
11209 byte arg5 = (byte) 0 ;
11210 byte arg6 = (byte) 0 ;
11211 byte arg7 = (byte) 0 ;
11212 bool result;
11213 byte temp2 ;
11214 int res2 = 0 ;
11215 byte temp3 ;
11216 int res3 = 0 ;
11217 byte temp4 ;
11218 int res4 = 0 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 PyObject * obj2 = 0 ;
11222 PyObject * obj3 = 0 ;
11223 char *kwnames[] = {
11224 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11225 };
11226
11227 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11228 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11229 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 if (obj1) {
11234 {
11235 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11236 if (SWIG_arg_fail(5)) SWIG_fail;
11237 }
11238 }
11239 if (obj2) {
11240 {
11241 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11242 if (SWIG_arg_fail(6)) SWIG_fail;
11243 }
11244 }
11245 if (obj3) {
11246 {
11247 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11248 if (SWIG_arg_fail(7)) SWIG_fail;
11249 }
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 {
11259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11260 }
11261 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11262 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11263 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11264 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11265 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11267 return resultobj;
11268 fail:
11269 return NULL;
11270 }
11271
11272
11273 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11274 PyObject *resultobj;
11275 wxImage *arg1 = (wxImage *) 0 ;
11276 byte arg2 = (byte) 128 ;
11277 bool result;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 char *kwnames[] = {
11281 (char *) "self",(char *) "threshold", NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 if (obj1) {
11288 {
11289 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11290 if (SWIG_arg_fail(2)) SWIG_fail;
11291 }
11292 }
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 unsigned char arg2 ;
11313 unsigned char arg3 ;
11314 unsigned char arg4 ;
11315 bool result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 PyObject * obj2 = 0 ;
11319 PyObject * obj3 = 0 ;
11320 char *kwnames[] = {
11321 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11322 };
11323
11324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11326 if (SWIG_arg_fail(1)) SWIG_fail;
11327 {
11328 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11329 if (SWIG_arg_fail(2)) SWIG_fail;
11330 }
11331 {
11332 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11333 if (SWIG_arg_fail(3)) SWIG_fail;
11334 }
11335 {
11336 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11337 if (SWIG_arg_fail(4)) SWIG_fail;
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11342
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 {
11347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11348 }
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj;
11357 wxImage *arg1 = (wxImage *) 0 ;
11358 wxImage *arg2 = 0 ;
11359 byte arg3 ;
11360 byte arg4 ;
11361 byte arg5 ;
11362 bool result;
11363 PyObject * obj0 = 0 ;
11364 PyObject * obj1 = 0 ;
11365 PyObject * obj2 = 0 ;
11366 PyObject * obj3 = 0 ;
11367 PyObject * obj4 = 0 ;
11368 char *kwnames[] = {
11369 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11370 };
11371
11372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11374 if (SWIG_arg_fail(1)) SWIG_fail;
11375 {
11376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(2)) SWIG_fail;
11378 if (arg2 == NULL) {
11379 SWIG_null_ref("wxImage");
11380 }
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 {
11384 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11385 if (SWIG_arg_fail(3)) SWIG_fail;
11386 }
11387 {
11388 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11389 if (SWIG_arg_fail(4)) SWIG_fail;
11390 }
11391 {
11392 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11393 if (SWIG_arg_fail(5)) SWIG_fail;
11394 }
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11398
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 {
11403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404 }
11405 return resultobj;
11406 fail:
11407 return NULL;
11408 }
11409
11410
11411 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11412 PyObject *resultobj;
11413 wxString *arg1 = 0 ;
11414 bool result;
11415 bool temp1 = false ;
11416 PyObject * obj0 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "name", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11430
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11436 }
11437 {
11438 if (temp1)
11439 delete arg1;
11440 }
11441 return resultobj;
11442 fail:
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return NULL;
11448 }
11449
11450
11451 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj;
11453 wxString *arg1 = 0 ;
11454 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11455 int result;
11456 bool temp1 = false ;
11457 PyObject * obj0 = 0 ;
11458 PyObject * obj1 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "name",(char *) "type", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11464 {
11465 arg1 = wxString_in_helper(obj0);
11466 if (arg1 == NULL) SWIG_fail;
11467 temp1 = true;
11468 }
11469 if (obj1) {
11470 {
11471 arg2 = (long)(SWIG_As_long(obj1));
11472 if (SWIG_arg_fail(2)) SWIG_fail;
11473 }
11474 }
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11478
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = SWIG_From_int((int)(result));
11484 }
11485 {
11486 if (temp1)
11487 delete arg1;
11488 }
11489 return resultobj;
11490 fail:
11491 {
11492 if (temp1)
11493 delete arg1;
11494 }
11495 return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj;
11501 wxImage *arg1 = (wxImage *) 0 ;
11502 wxString *arg2 = 0 ;
11503 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11504 int arg4 = (int) -1 ;
11505 bool result;
11506 bool temp2 = false ;
11507 PyObject * obj0 = 0 ;
11508 PyObject * obj1 = 0 ;
11509 PyObject * obj2 = 0 ;
11510 PyObject * obj3 = 0 ;
11511 char *kwnames[] = {
11512 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11513 };
11514
11515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11517 if (SWIG_arg_fail(1)) SWIG_fail;
11518 {
11519 arg2 = wxString_in_helper(obj1);
11520 if (arg2 == NULL) SWIG_fail;
11521 temp2 = true;
11522 }
11523 if (obj2) {
11524 {
11525 arg3 = (long)(SWIG_As_long(obj2));
11526 if (SWIG_arg_fail(3)) SWIG_fail;
11527 }
11528 }
11529 if (obj3) {
11530 {
11531 arg4 = (int)(SWIG_As_int(obj3));
11532 if (SWIG_arg_fail(4)) SWIG_fail;
11533 }
11534 }
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11538
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11544 }
11545 {
11546 if (temp2)
11547 delete arg2;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp2)
11553 delete arg2;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj;
11561 wxImage *arg1 = (wxImage *) 0 ;
11562 wxString *arg2 = 0 ;
11563 wxString *arg3 = 0 ;
11564 int arg4 = (int) -1 ;
11565 bool result;
11566 bool temp2 = false ;
11567 bool temp3 = false ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 PyObject * obj3 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 arg2 = wxString_in_helper(obj1);
11581 if (arg2 == NULL) SWIG_fail;
11582 temp2 = true;
11583 }
11584 {
11585 arg3 = wxString_in_helper(obj2);
11586 if (arg3 == NULL) SWIG_fail;
11587 temp3 = true;
11588 }
11589 if (obj3) {
11590 {
11591 arg4 = (int)(SWIG_As_int(obj3));
11592 if (SWIG_arg_fail(4)) SWIG_fail;
11593 }
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11598
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11604 }
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 {
11610 if (temp3)
11611 delete arg3;
11612 }
11613 return resultobj;
11614 fail:
11615 {
11616 if (temp2)
11617 delete arg2;
11618 }
11619 {
11620 if (temp3)
11621 delete arg3;
11622 }
11623 return NULL;
11624 }
11625
11626
11627 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11628 PyObject *resultobj;
11629 wxImage *arg1 = (wxImage *) 0 ;
11630 wxString *arg2 = 0 ;
11631 int arg3 ;
11632 bool result;
11633 bool temp2 = false ;
11634 PyObject * obj0 = 0 ;
11635 PyObject * obj1 = 0 ;
11636 PyObject * obj2 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self",(char *) "name",(char *) "type", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 arg2 = wxString_in_helper(obj1);
11646 if (arg2 == NULL) SWIG_fail;
11647 temp2 = true;
11648 }
11649 {
11650 arg3 = (int)(SWIG_As_int(obj2));
11651 if (SWIG_arg_fail(3)) SWIG_fail;
11652 }
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11662 }
11663 {
11664 if (temp2)
11665 delete arg2;
11666 }
11667 return resultobj;
11668 fail:
11669 {
11670 if (temp2)
11671 delete arg2;
11672 }
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxImage *arg1 = (wxImage *) 0 ;
11680 wxString *arg2 = 0 ;
11681 wxString *arg3 = 0 ;
11682 bool result;
11683 bool temp2 = false ;
11684 bool temp3 = false ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 char *kwnames[] = {
11689 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11690 };
11691
11692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11694 if (SWIG_arg_fail(1)) SWIG_fail;
11695 {
11696 arg2 = wxString_in_helper(obj1);
11697 if (arg2 == NULL) SWIG_fail;
11698 temp2 = true;
11699 }
11700 {
11701 arg3 = wxString_in_helper(obj2);
11702 if (arg3 == NULL) SWIG_fail;
11703 temp3 = true;
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*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 {
11720 if (temp3)
11721 delete arg3;
11722 }
11723 return resultobj;
11724 fail:
11725 {
11726 if (temp2)
11727 delete arg2;
11728 }
11729 {
11730 if (temp3)
11731 delete arg3;
11732 }
11733 return NULL;
11734 }
11735
11736
11737 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11738 PyObject *resultobj;
11739 wxInputStream *arg1 = 0 ;
11740 bool result;
11741 wxPyInputStream *temp1 ;
11742 bool created1 ;
11743 PyObject * obj0 = 0 ;
11744 char *kwnames[] = {
11745 (char *) "stream", NULL
11746 };
11747
11748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11749 {
11750 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11751 arg1 = temp1->m_wxis;
11752 created1 = false;
11753 } else {
11754 PyErr_Clear(); // clear the failure of the wxPyConvert above
11755 arg1 = wxPyCBInputStream_create(obj0, false);
11756 if (arg1 == NULL) {
11757 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11758 SWIG_fail;
11759 }
11760 created1 = true;
11761 }
11762 }
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (bool)wxImage::CanRead(*arg1);
11766
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 {
11771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11772 }
11773 {
11774 if (created1)
11775 delete arg1;
11776 }
11777 return resultobj;
11778 fail:
11779 {
11780 if (created1)
11781 delete arg1;
11782 }
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxImage *arg1 = (wxImage *) 0 ;
11790 wxInputStream *arg2 = 0 ;
11791 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11792 int arg4 = (int) -1 ;
11793 bool result;
11794 wxPyInputStream *temp2 ;
11795 bool created2 ;
11796 PyObject * obj0 = 0 ;
11797 PyObject * obj1 = 0 ;
11798 PyObject * obj2 = 0 ;
11799 PyObject * obj3 = 0 ;
11800 char *kwnames[] = {
11801 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11802 };
11803
11804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11806 if (SWIG_arg_fail(1)) SWIG_fail;
11807 {
11808 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11809 arg2 = temp2->m_wxis;
11810 created2 = false;
11811 } else {
11812 PyErr_Clear(); // clear the failure of the wxPyConvert above
11813 arg2 = wxPyCBInputStream_create(obj1, false);
11814 if (arg2 == NULL) {
11815 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11816 SWIG_fail;
11817 }
11818 created2 = true;
11819 }
11820 }
11821 if (obj2) {
11822 {
11823 arg3 = (long)(SWIG_As_long(obj2));
11824 if (SWIG_arg_fail(3)) SWIG_fail;
11825 }
11826 }
11827 if (obj3) {
11828 {
11829 arg4 = (int)(SWIG_As_int(obj3));
11830 if (SWIG_arg_fail(4)) SWIG_fail;
11831 }
11832 }
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11836
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 {
11844 if (created2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (created2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj;
11859 wxImage *arg1 = (wxImage *) 0 ;
11860 wxInputStream *arg2 = 0 ;
11861 wxString *arg3 = 0 ;
11862 int arg4 = (int) -1 ;
11863 bool result;
11864 wxPyInputStream *temp2 ;
11865 bool created2 ;
11866 bool temp3 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 PyObject * obj2 = 0 ;
11870 PyObject * obj3 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11880 arg2 = temp2->m_wxis;
11881 created2 = false;
11882 } else {
11883 PyErr_Clear(); // clear the failure of the wxPyConvert above
11884 arg2 = wxPyCBInputStream_create(obj1, false);
11885 if (arg2 == NULL) {
11886 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11887 SWIG_fail;
11888 }
11889 created2 = true;
11890 }
11891 }
11892 {
11893 arg3 = wxString_in_helper(obj2);
11894 if (arg3 == NULL) SWIG_fail;
11895 temp3 = true;
11896 }
11897 if (obj3) {
11898 {
11899 arg4 = (int)(SWIG_As_int(obj3));
11900 if (SWIG_arg_fail(4)) SWIG_fail;
11901 }
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11906
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11912 }
11913 {
11914 if (created2)
11915 delete arg2;
11916 }
11917 {
11918 if (temp3)
11919 delete arg3;
11920 }
11921 return resultobj;
11922 fail:
11923 {
11924 if (created2)
11925 delete arg2;
11926 }
11927 {
11928 if (temp3)
11929 delete arg3;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxImage *arg1 = (wxImage *) 0 ;
11938 bool result;
11939 PyObject * obj0 = 0 ;
11940 char *kwnames[] = {
11941 (char *) "self", NULL
11942 };
11943
11944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11946 if (SWIG_arg_fail(1)) SWIG_fail;
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = (bool)(arg1)->Ok();
11950
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 {
11955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11956 }
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj;
11965 wxImage *arg1 = (wxImage *) 0 ;
11966 int result;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (int)(arg1)->GetWidth();
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = SWIG_From_int((int)(result));
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj;
11993 wxImage *arg1 = (wxImage *) 0 ;
11994 int result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (int)(arg1)->GetHeight();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = SWIG_From_int((int)(result));
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12020 PyObject *resultobj;
12021 wxImage *arg1 = (wxImage *) 0 ;
12022 wxSize result;
12023 PyObject * obj0 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = wxImage_GetSize(arg1);
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 wxSize * resultptr;
12040 resultptr = new wxSize((wxSize &)(result));
12041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxImage *arg1 = (wxImage *) 0 ;
12052 wxRect *arg2 = 0 ;
12053 SwigValueWrapper<wxImage > result;
12054 wxRect temp2 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char *kwnames[] = {
12058 (char *) "self",(char *) "rect", NULL
12059 };
12060
12061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12063 if (SWIG_arg_fail(1)) SWIG_fail;
12064 {
12065 arg2 = &temp2;
12066 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 {
12076 wxImage * resultptr;
12077 resultptr = new wxImage((wxImage &)(result));
12078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxImage *arg1 = (wxImage *) 0 ;
12089 SwigValueWrapper<wxImage > result;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = (arg1)->Copy();
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 wxImage * resultptr;
12107 resultptr = new wxImage((wxImage &)(result));
12108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj;
12118 wxImage *arg1 = (wxImage *) 0 ;
12119 wxImage *arg2 = 0 ;
12120 int arg3 ;
12121 int arg4 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 PyObject * obj2 = 0 ;
12125 PyObject * obj3 = 0 ;
12126 char *kwnames[] = {
12127 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12128 };
12129
12130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12132 if (SWIG_arg_fail(1)) SWIG_fail;
12133 {
12134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(2)) SWIG_fail;
12136 if (arg2 == NULL) {
12137 SWIG_null_ref("wxImage");
12138 }
12139 if (SWIG_arg_fail(2)) SWIG_fail;
12140 }
12141 {
12142 arg3 = (int)(SWIG_As_int(obj2));
12143 if (SWIG_arg_fail(3)) SWIG_fail;
12144 }
12145 {
12146 arg4 = (int)(SWIG_As_int(obj3));
12147 if (SWIG_arg_fail(4)) SWIG_fail;
12148 }
12149 {
12150 PyThreadState* __tstate = wxPyBeginAllowThreads();
12151 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12152
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 Py_INCREF(Py_None); resultobj = Py_None;
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxImage *arg1 = (wxImage *) 0 ;
12166 PyObject *result;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (PyObject *)wxImage_GetData(arg1);
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 resultobj = result;
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxImage *arg1 = (wxImage *) 0 ;
12192 PyObject *arg2 = (PyObject *) 0 ;
12193 PyObject * obj0 = 0 ;
12194 PyObject * obj1 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self",(char *) "data", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 arg2 = obj1;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 wxImage_SetData(arg1,arg2);
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 Py_INCREF(Py_None); resultobj = Py_None;
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxImage *arg1 = (wxImage *) 0 ;
12220 PyObject *result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = result;
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxImage *arg1 = (wxImage *) 0 ;
12246 PyObject *arg2 = (PyObject *) 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self",(char *) "data", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 arg2 = obj1;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 wxImage_SetDataBuffer(arg1,arg2);
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxImage *arg1 = (wxImage *) 0 ;
12274 PyObject *result;
12275 PyObject * obj0 = 0 ;
12276 char *kwnames[] = {
12277 (char *) "self", NULL
12278 };
12279
12280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12282 if (SWIG_arg_fail(1)) SWIG_fail;
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (PyObject *)wxImage_GetAlphaData(arg1);
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj;
12299 wxImage *arg1 = (wxImage *) 0 ;
12300 PyObject *arg2 = (PyObject *) 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self",(char *) "data", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 arg2 = obj1;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 wxImage_SetAlphaData(arg1,arg2);
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 Py_INCREF(Py_None); resultobj = Py_None;
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj;
12327 wxImage *arg1 = (wxImage *) 0 ;
12328 PyObject *result;
12329 PyObject * obj0 = 0 ;
12330 char *kwnames[] = {
12331 (char *) "self", NULL
12332 };
12333
12334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12336 if (SWIG_arg_fail(1)) SWIG_fail;
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12340
12341 wxPyEndAllowThreads(__tstate);
12342 if (PyErr_Occurred()) SWIG_fail;
12343 }
12344 resultobj = result;
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxImage *arg1 = (wxImage *) 0 ;
12354 PyObject *arg2 = (PyObject *) 0 ;
12355 PyObject * obj0 = 0 ;
12356 PyObject * obj1 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "data", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 arg2 = obj1;
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 wxImage_SetAlphaBuffer(arg1,arg2);
12368
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 Py_INCREF(Py_None); resultobj = Py_None;
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxImage *arg1 = (wxImage *) 0 ;
12382 unsigned char arg2 ;
12383 unsigned char arg3 ;
12384 unsigned char arg4 ;
12385 PyObject * obj0 = 0 ;
12386 PyObject * obj1 = 0 ;
12387 PyObject * obj2 = 0 ;
12388 PyObject * obj3 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12398 if (SWIG_arg_fail(2)) SWIG_fail;
12399 }
12400 {
12401 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12402 if (SWIG_arg_fail(3)) SWIG_fail;
12403 }
12404 {
12405 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12406 if (SWIG_arg_fail(4)) SWIG_fail;
12407 }
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 (arg1)->SetMaskColour(arg2,arg3,arg4);
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 Py_INCREF(Py_None); resultobj = Py_None;
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj;
12424 wxImage *arg1 = (wxImage *) 0 ;
12425 unsigned char result;
12426 PyObject * obj0 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 result = (unsigned char)(arg1)->GetMaskRed();
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 {
12442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12443 }
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj;
12452 wxImage *arg1 = (wxImage *) 0 ;
12453 unsigned char result;
12454 PyObject * obj0 = 0 ;
12455 char *kwnames[] = {
12456 (char *) "self", NULL
12457 };
12458
12459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(1)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (unsigned char)(arg1)->GetMaskGreen();
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj;
12480 wxImage *arg1 = (wxImage *) 0 ;
12481 unsigned char result;
12482 PyObject * obj0 = 0 ;
12483 char *kwnames[] = {
12484 (char *) "self", NULL
12485 };
12486
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12489 if (SWIG_arg_fail(1)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = (unsigned char)(arg1)->GetMaskBlue();
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 {
12498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12499 }
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12507 PyObject *resultobj;
12508 wxImage *arg1 = (wxImage *) 0 ;
12509 bool arg2 = (bool) true ;
12510 PyObject * obj0 = 0 ;
12511 PyObject * obj1 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self",(char *) "mask", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 if (obj1) {
12520 {
12521 arg2 = (bool)(SWIG_As_bool(obj1));
12522 if (SWIG_arg_fail(2)) SWIG_fail;
12523 }
12524 }
12525 {
12526 PyThreadState* __tstate = wxPyBeginAllowThreads();
12527 (arg1)->SetMask(arg2);
12528
12529 wxPyEndAllowThreads(__tstate);
12530 if (PyErr_Occurred()) SWIG_fail;
12531 }
12532 Py_INCREF(Py_None); resultobj = Py_None;
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj;
12541 wxImage *arg1 = (wxImage *) 0 ;
12542 bool result;
12543 PyObject * obj0 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (bool)(arg1)->HasMask();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 {
12559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12560 }
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxImage *arg1 = (wxImage *) 0 ;
12570 double arg2 ;
12571 wxPoint *arg3 = 0 ;
12572 bool arg4 = (bool) true ;
12573 wxPoint *arg5 = (wxPoint *) NULL ;
12574 SwigValueWrapper<wxImage > result;
12575 wxPoint temp3 ;
12576 PyObject * obj0 = 0 ;
12577 PyObject * obj1 = 0 ;
12578 PyObject * obj2 = 0 ;
12579 PyObject * obj3 = 0 ;
12580 PyObject * obj4 = 0 ;
12581 char *kwnames[] = {
12582 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12583 };
12584
12585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12587 if (SWIG_arg_fail(1)) SWIG_fail;
12588 {
12589 arg2 = (double)(SWIG_As_double(obj1));
12590 if (SWIG_arg_fail(2)) SWIG_fail;
12591 }
12592 {
12593 arg3 = &temp3;
12594 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12595 }
12596 if (obj3) {
12597 {
12598 arg4 = (bool)(SWIG_As_bool(obj3));
12599 if (SWIG_arg_fail(4)) SWIG_fail;
12600 }
12601 }
12602 if (obj4) {
12603 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(5)) SWIG_fail;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 {
12614 wxImage * resultptr;
12615 resultptr = new wxImage((wxImage &)(result));
12616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12617 }
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj;
12626 wxImage *arg1 = (wxImage *) 0 ;
12627 bool arg2 = (bool) true ;
12628 SwigValueWrapper<wxImage > result;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 char *kwnames[] = {
12632 (char *) "self",(char *) "clockwise", NULL
12633 };
12634
12635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12637 if (SWIG_arg_fail(1)) SWIG_fail;
12638 if (obj1) {
12639 {
12640 arg2 = (bool)(SWIG_As_bool(obj1));
12641 if (SWIG_arg_fail(2)) SWIG_fail;
12642 }
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = (arg1)->Rotate90(arg2);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 wxImage * resultptr;
12653 resultptr = new wxImage((wxImage &)(result));
12654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxImage *arg1 = (wxImage *) 0 ;
12665 bool arg2 = (bool) true ;
12666 SwigValueWrapper<wxImage > result;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "horizontally", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 if (obj1) {
12677 {
12678 arg2 = (bool)(SWIG_As_bool(obj1));
12679 if (SWIG_arg_fail(2)) SWIG_fail;
12680 }
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (arg1)->Mirror(arg2);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 {
12690 wxImage * resultptr;
12691 resultptr = new wxImage((wxImage &)(result));
12692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj;
12702 wxImage *arg1 = (wxImage *) 0 ;
12703 unsigned char arg2 ;
12704 unsigned char arg3 ;
12705 unsigned char arg4 ;
12706 unsigned char arg5 ;
12707 unsigned char arg6 ;
12708 unsigned char arg7 ;
12709 PyObject * obj0 = 0 ;
12710 PyObject * obj1 = 0 ;
12711 PyObject * obj2 = 0 ;
12712 PyObject * obj3 = 0 ;
12713 PyObject * obj4 = 0 ;
12714 PyObject * obj5 = 0 ;
12715 PyObject * obj6 = 0 ;
12716 char *kwnames[] = {
12717 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12718 };
12719
12720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12722 if (SWIG_arg_fail(1)) SWIG_fail;
12723 {
12724 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12725 if (SWIG_arg_fail(2)) SWIG_fail;
12726 }
12727 {
12728 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12729 if (SWIG_arg_fail(3)) SWIG_fail;
12730 }
12731 {
12732 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12733 if (SWIG_arg_fail(4)) SWIG_fail;
12734 }
12735 {
12736 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12737 if (SWIG_arg_fail(5)) SWIG_fail;
12738 }
12739 {
12740 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12741 if (SWIG_arg_fail(6)) SWIG_fail;
12742 }
12743 {
12744 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12745 if (SWIG_arg_fail(7)) SWIG_fail;
12746 }
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12750
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 Py_INCREF(Py_None); resultobj = Py_None;
12755 return resultobj;
12756 fail:
12757 return NULL;
12758 }
12759
12760
12761 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj;
12763 wxImage *arg1 = (wxImage *) 0 ;
12764 unsigned char arg2 ;
12765 unsigned char arg3 ;
12766 unsigned char arg4 ;
12767 SwigValueWrapper<wxImage > result;
12768 PyObject * obj0 = 0 ;
12769 PyObject * obj1 = 0 ;
12770 PyObject * obj2 = 0 ;
12771 PyObject * obj3 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 {
12780 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12781 if (SWIG_arg_fail(2)) SWIG_fail;
12782 }
12783 {
12784 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12785 if (SWIG_arg_fail(3)) SWIG_fail;
12786 }
12787 {
12788 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12789 if (SWIG_arg_fail(4)) SWIG_fail;
12790 }
12791 {
12792 PyThreadState* __tstate = wxPyBeginAllowThreads();
12793 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12794
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 wxImage * resultptr;
12800 resultptr = new wxImage((wxImage &)(result));
12801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12802 }
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12810 PyObject *resultobj;
12811 wxImage *arg1 = (wxImage *) 0 ;
12812 wxString *arg2 = 0 ;
12813 wxString *arg3 = 0 ;
12814 bool temp2 = false ;
12815 bool temp3 = false ;
12816 PyObject * obj0 = 0 ;
12817 PyObject * obj1 = 0 ;
12818 PyObject * obj2 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "name",(char *) "value", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 arg2 = wxString_in_helper(obj1);
12828 if (arg2 == NULL) SWIG_fail;
12829 temp2 = true;
12830 }
12831 {
12832 arg3 = wxString_in_helper(obj2);
12833 if (arg3 == NULL) SWIG_fail;
12834 temp3 = true;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12839
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 Py_INCREF(Py_None); resultobj = Py_None;
12844 {
12845 if (temp2)
12846 delete arg2;
12847 }
12848 {
12849 if (temp3)
12850 delete arg3;
12851 }
12852 return resultobj;
12853 fail:
12854 {
12855 if (temp2)
12856 delete arg2;
12857 }
12858 {
12859 if (temp3)
12860 delete arg3;
12861 }
12862 return NULL;
12863 }
12864
12865
12866 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxImage *arg1 = (wxImage *) 0 ;
12869 wxString *arg2 = 0 ;
12870 int arg3 ;
12871 bool temp2 = false ;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 PyObject * obj2 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "name",(char *) "value", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = wxString_in_helper(obj1);
12884 if (arg2 == NULL) SWIG_fail;
12885 temp2 = true;
12886 }
12887 {
12888 arg3 = (int)(SWIG_As_int(obj2));
12889 if (SWIG_arg_fail(3)) SWIG_fail;
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 (arg1)->SetOption((wxString const &)*arg2,arg3);
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 Py_INCREF(Py_None); resultobj = Py_None;
12899 {
12900 if (temp2)
12901 delete arg2;
12902 }
12903 return resultobj;
12904 fail:
12905 {
12906 if (temp2)
12907 delete arg2;
12908 }
12909 return NULL;
12910 }
12911
12912
12913 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12914 PyObject *resultobj;
12915 wxImage *arg1 = (wxImage *) 0 ;
12916 wxString *arg2 = 0 ;
12917 wxString result;
12918 bool temp2 = false ;
12919 PyObject * obj0 = 0 ;
12920 PyObject * obj1 = 0 ;
12921 char *kwnames[] = {
12922 (char *) "self",(char *) "name", NULL
12923 };
12924
12925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 {
12929 arg2 = wxString_in_helper(obj1);
12930 if (arg2 == NULL) SWIG_fail;
12931 temp2 = true;
12932 }
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12936
12937 wxPyEndAllowThreads(__tstate);
12938 if (PyErr_Occurred()) SWIG_fail;
12939 }
12940 {
12941 #if wxUSE_UNICODE
12942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12943 #else
12944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12945 #endif
12946 }
12947 {
12948 if (temp2)
12949 delete arg2;
12950 }
12951 return resultobj;
12952 fail:
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return NULL;
12958 }
12959
12960
12961 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12962 PyObject *resultobj;
12963 wxImage *arg1 = (wxImage *) 0 ;
12964 wxString *arg2 = 0 ;
12965 int result;
12966 bool temp2 = false ;
12967 PyObject * obj0 = 0 ;
12968 PyObject * obj1 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self",(char *) "name", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 arg2 = wxString_in_helper(obj1);
12978 if (arg2 == NULL) SWIG_fail;
12979 temp2 = true;
12980 }
12981 {
12982 PyThreadState* __tstate = wxPyBeginAllowThreads();
12983 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12984
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 resultobj = SWIG_From_int((int)(result));
12990 }
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return resultobj;
12996 fail:
12997 {
12998 if (temp2)
12999 delete arg2;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxImage *arg1 = (wxImage *) 0 ;
13008 wxString *arg2 = 0 ;
13009 bool result;
13010 bool temp2 = false ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self",(char *) "name", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13019 if (SWIG_arg_fail(1)) SWIG_fail;
13020 {
13021 arg2 = wxString_in_helper(obj1);
13022 if (arg2 == NULL) SWIG_fail;
13023 temp2 = true;
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13028
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 {
13033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13034 }
13035 {
13036 if (temp2)
13037 delete arg2;
13038 }
13039 return resultobj;
13040 fail:
13041 {
13042 if (temp2)
13043 delete arg2;
13044 }
13045 return NULL;
13046 }
13047
13048
13049 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj;
13051 wxImage *arg1 = (wxImage *) 0 ;
13052 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13053 unsigned long result;
13054 PyObject * obj0 = 0 ;
13055 PyObject * obj1 = 0 ;
13056 char *kwnames[] = {
13057 (char *) "self",(char *) "stopafter", NULL
13058 };
13059
13060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13062 if (SWIG_arg_fail(1)) SWIG_fail;
13063 if (obj1) {
13064 {
13065 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13066 if (SWIG_arg_fail(2)) SWIG_fail;
13067 }
13068 }
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 result = (unsigned long)(arg1)->CountColours(arg2);
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 {
13077 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13078 }
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13086 PyObject *resultobj;
13087 wxImage *arg1 = (wxImage *) 0 ;
13088 wxImageHistogram *arg2 = 0 ;
13089 unsigned long result;
13090 PyObject * obj0 = 0 ;
13091 PyObject * obj1 = 0 ;
13092 char *kwnames[] = {
13093 (char *) "self",(char *) "h", NULL
13094 };
13095
13096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13098 if (SWIG_arg_fail(1)) SWIG_fail;
13099 {
13100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13101 if (SWIG_arg_fail(2)) SWIG_fail;
13102 if (arg2 == NULL) {
13103 SWIG_null_ref("wxImageHistogram");
13104 }
13105 if (SWIG_arg_fail(2)) SWIG_fail;
13106 }
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13116 }
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13126 PyObject * obj0 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "handler", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 wxImage::AddHandler(arg1);
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 Py_INCREF(Py_None); resultobj = Py_None;
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj;
13150 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13151 PyObject * obj0 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "handler", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 wxImage::InsertHandler(arg1);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 Py_INCREF(Py_None); resultobj = Py_None;
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj;
13175 wxString *arg1 = 0 ;
13176 bool result;
13177 bool temp1 = false ;
13178 PyObject * obj0 = 0 ;
13179 char *kwnames[] = {
13180 (char *) "name", NULL
13181 };
13182
13183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13184 {
13185 arg1 = wxString_in_helper(obj0);
13186 if (arg1 == NULL) SWIG_fail;
13187 temp1 = true;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 {
13197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13198 }
13199 {
13200 if (temp1)
13201 delete arg1;
13202 }
13203 return resultobj;
13204 fail:
13205 {
13206 if (temp1)
13207 delete arg1;
13208 }
13209 return NULL;
13210 }
13211
13212
13213 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13214 PyObject *resultobj;
13215 wxString result;
13216 char *kwnames[] = {
13217 NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 result = wxImage::GetImageExtWildcard();
13224
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 {
13229 #if wxUSE_UNICODE
13230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13231 #else
13232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13233 #endif
13234 }
13235 return resultobj;
13236 fail:
13237 return NULL;
13238 }
13239
13240
13241 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj;
13243 wxImage *arg1 = (wxImage *) 0 ;
13244 int arg2 = (int) -1 ;
13245 wxBitmap result;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 char *kwnames[] = {
13249 (char *) "self",(char *) "depth", NULL
13250 };
13251
13252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13254 if (SWIG_arg_fail(1)) SWIG_fail;
13255 if (obj1) {
13256 {
13257 arg2 = (int)(SWIG_As_int(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 }
13261 {
13262 if (!wxPyCheckForApp()) SWIG_fail;
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 result = wxImage_ConvertToBitmap(arg1,arg2);
13265
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 {
13270 wxBitmap * resultptr;
13271 resultptr = new wxBitmap((wxBitmap &)(result));
13272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13273 }
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxImage *arg1 = (wxImage *) 0 ;
13283 unsigned char arg2 ;
13284 unsigned char arg3 ;
13285 unsigned char arg4 ;
13286 wxBitmap result;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 PyObject * obj2 = 0 ;
13290 PyObject * obj3 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 {
13299 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13300 if (SWIG_arg_fail(2)) SWIG_fail;
13301 }
13302 {
13303 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13304 if (SWIG_arg_fail(3)) SWIG_fail;
13305 }
13306 {
13307 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13308 if (SWIG_arg_fail(4)) SWIG_fail;
13309 }
13310 {
13311 if (!wxPyCheckForApp()) SWIG_fail;
13312 PyThreadState* __tstate = wxPyBeginAllowThreads();
13313 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13314
13315 wxPyEndAllowThreads(__tstate);
13316 if (PyErr_Occurred()) SWIG_fail;
13317 }
13318 {
13319 wxBitmap * resultptr;
13320 resultptr = new wxBitmap((wxBitmap &)(result));
13321 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13322 }
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13330 PyObject *obj;
13331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13332 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13333 Py_INCREF(obj);
13334 return Py_BuildValue((char *)"");
13335 }
13336 static int _wrap_NullImage_set(PyObject *) {
13337 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13338 return 1;
13339 }
13340
13341
13342 static PyObject *_wrap_NullImage_get(void) {
13343 PyObject *pyobj;
13344
13345 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13346 return pyobj;
13347 }
13348
13349
13350 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13351 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13352 return 1;
13353 }
13354
13355
13356 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13357 PyObject *pyobj;
13358
13359 {
13360 #if wxUSE_UNICODE
13361 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13362 #else
13363 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13364 #endif
13365 }
13366 return pyobj;
13367 }
13368
13369
13370 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13371 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13372 return 1;
13373 }
13374
13375
13376 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13377 PyObject *pyobj;
13378
13379 {
13380 #if wxUSE_UNICODE
13381 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13382 #else
13383 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13384 #endif
13385 }
13386 return pyobj;
13387 }
13388
13389
13390 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13391 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13392 return 1;
13393 }
13394
13395
13396 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13397 PyObject *pyobj;
13398
13399 {
13400 #if wxUSE_UNICODE
13401 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13402 #else
13403 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13404 #endif
13405 }
13406 return pyobj;
13407 }
13408
13409
13410 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13411 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13412 return 1;
13413 }
13414
13415
13416 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13417 PyObject *pyobj;
13418
13419 {
13420 #if wxUSE_UNICODE
13421 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13422 #else
13423 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13424 #endif
13425 }
13426 return pyobj;
13427 }
13428
13429
13430 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13431 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13432 return 1;
13433 }
13434
13435
13436 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13437 PyObject *pyobj;
13438
13439 {
13440 #if wxUSE_UNICODE
13441 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13442 #else
13443 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13444 #endif
13445 }
13446 return pyobj;
13447 }
13448
13449
13450 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj;
13452 wxBMPHandler *result;
13453 char *kwnames[] = {
13454 NULL
13455 };
13456
13457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 result = (wxBMPHandler *)new wxBMPHandler();
13461
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13466 return resultobj;
13467 fail:
13468 return NULL;
13469 }
13470
13471
13472 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13473 PyObject *obj;
13474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13475 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13476 Py_INCREF(obj);
13477 return Py_BuildValue((char *)"");
13478 }
13479 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13480 PyObject *resultobj;
13481 wxICOHandler *result;
13482 char *kwnames[] = {
13483 NULL
13484 };
13485
13486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (wxICOHandler *)new wxICOHandler();
13490
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13502 PyObject *obj;
13503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13504 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13505 Py_INCREF(obj);
13506 return Py_BuildValue((char *)"");
13507 }
13508 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj;
13510 wxCURHandler *result;
13511 char *kwnames[] = {
13512 NULL
13513 };
13514
13515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = (wxCURHandler *)new wxCURHandler();
13519
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13531 PyObject *obj;
13532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13533 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13534 Py_INCREF(obj);
13535 return Py_BuildValue((char *)"");
13536 }
13537 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxANIHandler *result;
13540 char *kwnames[] = {
13541 NULL
13542 };
13543
13544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = (wxANIHandler *)new wxANIHandler();
13548
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13560 PyObject *obj;
13561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13562 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13563 Py_INCREF(obj);
13564 return Py_BuildValue((char *)"");
13565 }
13566 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13567 PyObject *resultobj;
13568 wxPNGHandler *result;
13569 char *kwnames[] = {
13570 NULL
13571 };
13572
13573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (wxPNGHandler *)new wxPNGHandler();
13577
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13589 PyObject *obj;
13590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13591 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13592 Py_INCREF(obj);
13593 return Py_BuildValue((char *)"");
13594 }
13595 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj;
13597 wxGIFHandler *result;
13598 char *kwnames[] = {
13599 NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (wxGIFHandler *)new wxGIFHandler();
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13611 return resultobj;
13612 fail:
13613 return NULL;
13614 }
13615
13616
13617 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13618 PyObject *obj;
13619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13620 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13621 Py_INCREF(obj);
13622 return Py_BuildValue((char *)"");
13623 }
13624 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj;
13626 wxPCXHandler *result;
13627 char *kwnames[] = {
13628 NULL
13629 };
13630
13631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 result = (wxPCXHandler *)new wxPCXHandler();
13635
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13647 PyObject *obj;
13648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13649 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13650 Py_INCREF(obj);
13651 return Py_BuildValue((char *)"");
13652 }
13653 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxJPEGHandler *result;
13656 char *kwnames[] = {
13657 NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 result = (wxJPEGHandler *)new wxJPEGHandler();
13664
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13676 PyObject *obj;
13677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13678 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13679 Py_INCREF(obj);
13680 return Py_BuildValue((char *)"");
13681 }
13682 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj;
13684 wxPNMHandler *result;
13685 char *kwnames[] = {
13686 NULL
13687 };
13688
13689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13690 {
13691 PyThreadState* __tstate = wxPyBeginAllowThreads();
13692 result = (wxPNMHandler *)new wxPNMHandler();
13693
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13705 PyObject *obj;
13706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13707 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13708 Py_INCREF(obj);
13709 return Py_BuildValue((char *)"");
13710 }
13711 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj;
13713 wxXPMHandler *result;
13714 char *kwnames[] = {
13715 NULL
13716 };
13717
13718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 result = (wxXPMHandler *)new wxXPMHandler();
13722
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13734 PyObject *obj;
13735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13736 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13737 Py_INCREF(obj);
13738 return Py_BuildValue((char *)"");
13739 }
13740 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj;
13742 wxTIFFHandler *result;
13743 char *kwnames[] = {
13744 NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 result = (wxTIFFHandler *)new wxTIFFHandler();
13751
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13763 PyObject *obj;
13764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13765 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13766 Py_INCREF(obj);
13767 return Py_BuildValue((char *)"");
13768 }
13769 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj;
13771 wxImage *arg1 = 0 ;
13772 wxImage *arg2 = 0 ;
13773 int arg3 = (int) 236 ;
13774 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13775 bool result;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 PyObject * obj2 = 0 ;
13779 PyObject * obj3 = 0 ;
13780 char *kwnames[] = {
13781 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13782 };
13783
13784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13785 {
13786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13787 if (SWIG_arg_fail(1)) SWIG_fail;
13788 if (arg1 == NULL) {
13789 SWIG_null_ref("wxImage");
13790 }
13791 if (SWIG_arg_fail(1)) SWIG_fail;
13792 }
13793 {
13794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13795 if (SWIG_arg_fail(2)) SWIG_fail;
13796 if (arg2 == NULL) {
13797 SWIG_null_ref("wxImage");
13798 }
13799 if (SWIG_arg_fail(2)) SWIG_fail;
13800 }
13801 if (obj2) {
13802 {
13803 arg3 = (int)(SWIG_As_int(obj2));
13804 if (SWIG_arg_fail(3)) SWIG_fail;
13805 }
13806 }
13807 if (obj3) {
13808 {
13809 arg4 = (int)(SWIG_As_int(obj3));
13810 if (SWIG_arg_fail(4)) SWIG_fail;
13811 }
13812 }
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 {
13821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13822 }
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13830 PyObject *obj;
13831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13832 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13833 Py_INCREF(obj);
13834 return Py_BuildValue((char *)"");
13835 }
13836 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13837 PyObject *resultobj;
13838 wxEvtHandler *result;
13839 char *kwnames[] = {
13840 NULL
13841 };
13842
13843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 result = (wxEvtHandler *)new wxEvtHandler();
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13861 wxEvtHandler *result;
13862 PyObject * obj0 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self", NULL
13865 };
13866
13867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13869 if (SWIG_arg_fail(1)) SWIG_fail;
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 {
13878 resultobj = wxPyMake_wxObject(result, 0);
13879 }
13880 return resultobj;
13881 fail:
13882 return NULL;
13883 }
13884
13885
13886 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj;
13888 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13889 wxEvtHandler *result;
13890 PyObject * obj0 = 0 ;
13891 char *kwnames[] = {
13892 (char *) "self", NULL
13893 };
13894
13895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13897 if (SWIG_arg_fail(1)) SWIG_fail;
13898 {
13899 PyThreadState* __tstate = wxPyBeginAllowThreads();
13900 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13901
13902 wxPyEndAllowThreads(__tstate);
13903 if (PyErr_Occurred()) SWIG_fail;
13904 }
13905 {
13906 resultobj = wxPyMake_wxObject(result, 0);
13907 }
13908 return resultobj;
13909 fail:
13910 return NULL;
13911 }
13912
13913
13914 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13915 PyObject *resultobj;
13916 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13917 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13918 PyObject * obj0 = 0 ;
13919 PyObject * obj1 = 0 ;
13920 char *kwnames[] = {
13921 (char *) "self",(char *) "handler", NULL
13922 };
13923
13924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13926 if (SWIG_arg_fail(1)) SWIG_fail;
13927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(2)) SWIG_fail;
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 (arg1)->SetNextHandler(arg2);
13932
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 Py_INCREF(Py_None); resultobj = Py_None;
13937 return resultobj;
13938 fail:
13939 return NULL;
13940 }
13941
13942
13943 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13944 PyObject *resultobj;
13945 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13946 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13947 PyObject * obj0 = 0 ;
13948 PyObject * obj1 = 0 ;
13949 char *kwnames[] = {
13950 (char *) "self",(char *) "handler", NULL
13951 };
13952
13953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13955 if (SWIG_arg_fail(1)) SWIG_fail;
13956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13957 if (SWIG_arg_fail(2)) SWIG_fail;
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 (arg1)->SetPreviousHandler(arg2);
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 Py_INCREF(Py_None); resultobj = Py_None;
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13973 PyObject *resultobj;
13974 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13975 bool result;
13976 PyObject * obj0 = 0 ;
13977 char *kwnames[] = {
13978 (char *) "self", NULL
13979 };
13980
13981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13983 if (SWIG_arg_fail(1)) SWIG_fail;
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 result = (bool)(arg1)->GetEvtHandlerEnabled();
13987
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 {
13992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13993 }
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14001 PyObject *resultobj;
14002 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14003 bool arg2 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 char *kwnames[] = {
14007 (char *) "self",(char *) "enabled", NULL
14008 };
14009
14010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14012 if (SWIG_arg_fail(1)) SWIG_fail;
14013 {
14014 arg2 = (bool)(SWIG_As_bool(obj1));
14015 if (SWIG_arg_fail(2)) SWIG_fail;
14016 }
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 (arg1)->SetEvtHandlerEnabled(arg2);
14020
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 Py_INCREF(Py_None); resultobj = Py_None;
14025 return resultobj;
14026 fail:
14027 return NULL;
14028 }
14029
14030
14031 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14032 PyObject *resultobj;
14033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14034 wxEvent *arg2 = 0 ;
14035 bool result;
14036 PyObject * obj0 = 0 ;
14037 PyObject * obj1 = 0 ;
14038 char *kwnames[] = {
14039 (char *) "self",(char *) "event", NULL
14040 };
14041
14042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14044 if (SWIG_arg_fail(1)) SWIG_fail;
14045 {
14046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(2)) SWIG_fail;
14048 if (arg2 == NULL) {
14049 SWIG_null_ref("wxEvent");
14050 }
14051 if (SWIG_arg_fail(2)) SWIG_fail;
14052 }
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 result = (bool)(arg1)->ProcessEvent(*arg2);
14056
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 {
14061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14062 }
14063 return resultobj;
14064 fail:
14065 return NULL;
14066 }
14067
14068
14069 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj;
14071 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14072 wxEvent *arg2 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self",(char *) "event", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14084 if (SWIG_arg_fail(2)) SWIG_fail;
14085 if (arg2 == NULL) {
14086 SWIG_null_ref("wxEvent");
14087 }
14088 if (SWIG_arg_fail(2)) SWIG_fail;
14089 }
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 (arg1)->AddPendingEvent(*arg2);
14093
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 Py_INCREF(Py_None); resultobj = Py_None;
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj;
14106 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14107 PyObject * obj0 = 0 ;
14108 char *kwnames[] = {
14109 (char *) "self", NULL
14110 };
14111
14112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14114 if (SWIG_arg_fail(1)) SWIG_fail;
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 (arg1)->ProcessPendingEvents();
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 Py_INCREF(Py_None); resultobj = Py_None;
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14132 int arg2 ;
14133 int arg3 ;
14134 int arg4 ;
14135 PyObject *arg5 = (PyObject *) 0 ;
14136 PyObject * obj0 = 0 ;
14137 PyObject * obj1 = 0 ;
14138 PyObject * obj2 = 0 ;
14139 PyObject * obj3 = 0 ;
14140 PyObject * obj4 = 0 ;
14141 char *kwnames[] = {
14142 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14143 };
14144
14145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14147 if (SWIG_arg_fail(1)) SWIG_fail;
14148 {
14149 arg2 = (int)(SWIG_As_int(obj1));
14150 if (SWIG_arg_fail(2)) SWIG_fail;
14151 }
14152 {
14153 arg3 = (int)(SWIG_As_int(obj2));
14154 if (SWIG_arg_fail(3)) SWIG_fail;
14155 }
14156 {
14157 arg4 = (int)(SWIG_As_int(obj3));
14158 if (SWIG_arg_fail(4)) SWIG_fail;
14159 }
14160 arg5 = obj4;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 Py_INCREF(Py_None); resultobj = Py_None;
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14178 int arg2 ;
14179 int arg3 = (int) -1 ;
14180 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14181 bool result;
14182 PyObject * obj0 = 0 ;
14183 PyObject * obj1 = 0 ;
14184 PyObject * obj2 = 0 ;
14185 PyObject * obj3 = 0 ;
14186 char *kwnames[] = {
14187 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14188 };
14189
14190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14192 if (SWIG_arg_fail(1)) SWIG_fail;
14193 {
14194 arg2 = (int)(SWIG_As_int(obj1));
14195 if (SWIG_arg_fail(2)) SWIG_fail;
14196 }
14197 if (obj2) {
14198 {
14199 arg3 = (int)(SWIG_As_int(obj2));
14200 if (SWIG_arg_fail(3)) SWIG_fail;
14201 }
14202 }
14203 if (obj3) {
14204 {
14205 arg4 = (wxEventType)(SWIG_As_int(obj3));
14206 if (SWIG_arg_fail(4)) SWIG_fail;
14207 }
14208 }
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14218 }
14219 return resultobj;
14220 fail:
14221 return NULL;
14222 }
14223
14224
14225 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj;
14227 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14228 PyObject *arg2 = (PyObject *) 0 ;
14229 bool arg3 = (bool) true ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 PyObject * obj2 = 0 ;
14233 char *kwnames[] = {
14234 (char *) "self",(char *) "_self",(char *) "incref", NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 arg2 = obj1;
14241 if (obj2) {
14242 {
14243 arg3 = (bool)(SWIG_As_bool(obj2));
14244 if (SWIG_arg_fail(3)) SWIG_fail;
14245 }
14246 }
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 Py_INCREF(Py_None); resultobj = Py_None;
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14262 PyObject *obj;
14263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14264 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14265 Py_INCREF(obj);
14266 return Py_BuildValue((char *)"");
14267 }
14268 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxEventType result;
14271 char *kwnames[] = {
14272 NULL
14273 };
14274
14275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (wxEventType)wxNewEventType();
14279
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 {
14284 resultobj = SWIG_From_int((int)(result));
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj;
14294 wxEvent *arg1 = (wxEvent *) 0 ;
14295 PyObject * obj0 = 0 ;
14296 char *kwnames[] = {
14297 (char *) "self", NULL
14298 };
14299
14300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14302 if (SWIG_arg_fail(1)) SWIG_fail;
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 delete arg1;
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 Py_INCREF(Py_None); resultobj = Py_None;
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14318 PyObject *resultobj;
14319 wxEvent *arg1 = (wxEvent *) 0 ;
14320 wxEventType arg2 ;
14321 PyObject * obj0 = 0 ;
14322 PyObject * obj1 = 0 ;
14323 char *kwnames[] = {
14324 (char *) "self",(char *) "typ", NULL
14325 };
14326
14327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14329 if (SWIG_arg_fail(1)) SWIG_fail;
14330 {
14331 arg2 = (wxEventType)(SWIG_As_int(obj1));
14332 if (SWIG_arg_fail(2)) SWIG_fail;
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 (arg1)->SetEventType(arg2);
14337
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 Py_INCREF(Py_None); resultobj = Py_None;
14342 return resultobj;
14343 fail:
14344 return NULL;
14345 }
14346
14347
14348 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14349 PyObject *resultobj;
14350 wxEvent *arg1 = (wxEvent *) 0 ;
14351 wxEventType result;
14352 PyObject * obj0 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14363
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 {
14368 resultobj = SWIG_From_int((int)(result));
14369 }
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj;
14378 wxEvent *arg1 = (wxEvent *) 0 ;
14379 wxObject *result;
14380 PyObject * obj0 = 0 ;
14381 char *kwnames[] = {
14382 (char *) "self", NULL
14383 };
14384
14385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14387 if (SWIG_arg_fail(1)) SWIG_fail;
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14391
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = wxPyMake_wxObject(result, 0);
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxEvent *arg1 = (wxEvent *) 0 ;
14407 wxObject *arg2 = (wxObject *) 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "obj", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(2)) SWIG_fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 (arg1)->SetEventObject(arg2);
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 Py_INCREF(Py_None); resultobj = Py_None;
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj;
14435 wxEvent *arg1 = (wxEvent *) 0 ;
14436 long result;
14437 PyObject * obj0 = 0 ;
14438 char *kwnames[] = {
14439 (char *) "self", NULL
14440 };
14441
14442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14444 if (SWIG_arg_fail(1)) SWIG_fail;
14445 {
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14448
14449 wxPyEndAllowThreads(__tstate);
14450 if (PyErr_Occurred()) SWIG_fail;
14451 }
14452 {
14453 resultobj = SWIG_From_long((long)(result));
14454 }
14455 return resultobj;
14456 fail:
14457 return NULL;
14458 }
14459
14460
14461 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14462 PyObject *resultobj;
14463 wxEvent *arg1 = (wxEvent *) 0 ;
14464 long arg2 = (long) 0 ;
14465 PyObject * obj0 = 0 ;
14466 PyObject * obj1 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self",(char *) "ts", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 if (obj1) {
14475 {
14476 arg2 = (long)(SWIG_As_long(obj1));
14477 if (SWIG_arg_fail(2)) SWIG_fail;
14478 }
14479 }
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 (arg1)->SetTimestamp(arg2);
14483
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 Py_INCREF(Py_None); resultobj = Py_None;
14488 return resultobj;
14489 fail:
14490 return NULL;
14491 }
14492
14493
14494 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14495 PyObject *resultobj;
14496 wxEvent *arg1 = (wxEvent *) 0 ;
14497 int result;
14498 PyObject * obj0 = 0 ;
14499 char *kwnames[] = {
14500 (char *) "self", NULL
14501 };
14502
14503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14505 if (SWIG_arg_fail(1)) SWIG_fail;
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 result = (int)((wxEvent const *)arg1)->GetId();
14509
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 {
14514 resultobj = SWIG_From_int((int)(result));
14515 }
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj;
14524 wxEvent *arg1 = (wxEvent *) 0 ;
14525 int arg2 ;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 char *kwnames[] = {
14529 (char *) "self",(char *) "Id", NULL
14530 };
14531
14532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14534 if (SWIG_arg_fail(1)) SWIG_fail;
14535 {
14536 arg2 = (int)(SWIG_As_int(obj1));
14537 if (SWIG_arg_fail(2)) SWIG_fail;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 (arg1)->SetId(arg2);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 Py_INCREF(Py_None); resultobj = Py_None;
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxEvent *arg1 = (wxEvent *) 0 ;
14556 bool result;
14557 PyObject * obj0 = 0 ;
14558 char *kwnames[] = {
14559 (char *) "self", NULL
14560 };
14561
14562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14564 if (SWIG_arg_fail(1)) SWIG_fail;
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14568
14569 wxPyEndAllowThreads(__tstate);
14570 if (PyErr_Occurred()) SWIG_fail;
14571 }
14572 {
14573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14574 }
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj;
14583 wxEvent *arg1 = (wxEvent *) 0 ;
14584 bool arg2 = (bool) true ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self",(char *) "skip", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 if (obj1) {
14595 {
14596 arg2 = (bool)(SWIG_As_bool(obj1));
14597 if (SWIG_arg_fail(2)) SWIG_fail;
14598 }
14599 }
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 (arg1)->Skip(arg2);
14603
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 Py_INCREF(Py_None); resultobj = Py_None;
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxEvent *arg1 = (wxEvent *) 0 ;
14617 bool result;
14618 PyObject * obj0 = 0 ;
14619 char *kwnames[] = {
14620 (char *) "self", NULL
14621 };
14622
14623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14625 if (SWIG_arg_fail(1)) SWIG_fail;
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14629
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 {
14634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14635 }
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj;
14644 wxEvent *arg1 = (wxEvent *) 0 ;
14645 bool result;
14646 PyObject * obj0 = 0 ;
14647 char *kwnames[] = {
14648 (char *) "self", NULL
14649 };
14650
14651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14653 if (SWIG_arg_fail(1)) SWIG_fail;
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14663 }
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj;
14672 wxEvent *arg1 = (wxEvent *) 0 ;
14673 int result;
14674 PyObject * obj0 = 0 ;
14675 char *kwnames[] = {
14676 (char *) "self", NULL
14677 };
14678
14679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14681 if (SWIG_arg_fail(1)) SWIG_fail;
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 result = (int)(arg1)->StopPropagation();
14685
14686 wxPyEndAllowThreads(__tstate);
14687 if (PyErr_Occurred()) SWIG_fail;
14688 }
14689 {
14690 resultobj = SWIG_From_int((int)(result));
14691 }
14692 return resultobj;
14693 fail:
14694 return NULL;
14695 }
14696
14697
14698 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj;
14700 wxEvent *arg1 = (wxEvent *) 0 ;
14701 int arg2 ;
14702 PyObject * obj0 = 0 ;
14703 PyObject * obj1 = 0 ;
14704 char *kwnames[] = {
14705 (char *) "self",(char *) "propagationLevel", NULL
14706 };
14707
14708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14710 if (SWIG_arg_fail(1)) SWIG_fail;
14711 {
14712 arg2 = (int)(SWIG_As_int(obj1));
14713 if (SWIG_arg_fail(2)) SWIG_fail;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->ResumePropagation(arg2);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 Py_INCREF(Py_None); resultobj = Py_None;
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14730 PyObject *resultobj;
14731 wxEvent *arg1 = (wxEvent *) 0 ;
14732 wxEvent *result;
14733 PyObject * obj0 = 0 ;
14734 char *kwnames[] = {
14735 (char *) "self", NULL
14736 };
14737
14738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(1)) SWIG_fail;
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (wxEvent *)(arg1)->Clone();
14744
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14749 return resultobj;
14750 fail:
14751 return NULL;
14752 }
14753
14754
14755 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14756 PyObject *obj;
14757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14758 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14759 Py_INCREF(obj);
14760 return Py_BuildValue((char *)"");
14761 }
14762 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14763 PyObject *resultobj;
14764 wxEvent *arg1 = 0 ;
14765 wxPropagationDisabler *result;
14766 PyObject * obj0 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "event", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14772 {
14773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14774 if (SWIG_arg_fail(1)) SWIG_fail;
14775 if (arg1 == NULL) {
14776 SWIG_null_ref("wxEvent");
14777 }
14778 if (SWIG_arg_fail(1)) SWIG_fail;
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14797 PyObject * obj0 = 0 ;
14798 char *kwnames[] = {
14799 (char *) "self", NULL
14800 };
14801
14802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14804 if (SWIG_arg_fail(1)) SWIG_fail;
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 delete arg1;
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 Py_INCREF(Py_None); resultobj = Py_None;
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14820 PyObject *obj;
14821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14822 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14823 Py_INCREF(obj);
14824 return Py_BuildValue((char *)"");
14825 }
14826 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj;
14828 wxEvent *arg1 = 0 ;
14829 wxPropagateOnce *result;
14830 PyObject * obj0 = 0 ;
14831 char *kwnames[] = {
14832 (char *) "event", NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14836 {
14837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14838 if (SWIG_arg_fail(1)) SWIG_fail;
14839 if (arg1 == NULL) {
14840 SWIG_null_ref("wxEvent");
14841 }
14842 if (SWIG_arg_fail(1)) SWIG_fail;
14843 }
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14847
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14852 return resultobj;
14853 fail:
14854 return NULL;
14855 }
14856
14857
14858 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj;
14860 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14861 PyObject * obj0 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "self", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14868 if (SWIG_arg_fail(1)) SWIG_fail;
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 delete arg1;
14872
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 Py_INCREF(Py_None); resultobj = Py_None;
14877 return resultobj;
14878 fail:
14879 return NULL;
14880 }
14881
14882
14883 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14884 PyObject *obj;
14885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14886 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14887 Py_INCREF(obj);
14888 return Py_BuildValue((char *)"");
14889 }
14890 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj;
14892 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14893 int arg2 = (int) 0 ;
14894 wxCommandEvent *result;
14895 PyObject * obj0 = 0 ;
14896 PyObject * obj1 = 0 ;
14897 char *kwnames[] = {
14898 (char *) "commandType",(char *) "winid", NULL
14899 };
14900
14901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14902 if (obj0) {
14903 {
14904 arg1 = (wxEventType)(SWIG_As_int(obj0));
14905 if (SWIG_arg_fail(1)) SWIG_fail;
14906 }
14907 }
14908 if (obj1) {
14909 {
14910 arg2 = (int)(SWIG_As_int(obj1));
14911 if (SWIG_arg_fail(2)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14929 PyObject *resultobj;
14930 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14931 int result;
14932 PyObject * obj0 = 0 ;
14933 char *kwnames[] = {
14934 (char *) "self", NULL
14935 };
14936
14937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14939 if (SWIG_arg_fail(1)) SWIG_fail;
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 {
14948 resultobj = SWIG_From_int((int)(result));
14949 }
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14959 wxString *arg2 = 0 ;
14960 bool temp2 = false ;
14961 PyObject * obj0 = 0 ;
14962 PyObject * obj1 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "self",(char *) "s", NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14969 if (SWIG_arg_fail(1)) SWIG_fail;
14970 {
14971 arg2 = wxString_in_helper(obj1);
14972 if (arg2 == NULL) SWIG_fail;
14973 temp2 = true;
14974 }
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 (arg1)->SetString((wxString const &)*arg2);
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 Py_INCREF(Py_None); resultobj = Py_None;
14983 {
14984 if (temp2)
14985 delete arg2;
14986 }
14987 return resultobj;
14988 fail:
14989 {
14990 if (temp2)
14991 delete arg2;
14992 }
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15000 wxString result;
15001 PyObject * obj0 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self", NULL
15004 };
15005
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 PyThreadState* __tstate = wxPyBeginAllowThreads();
15011 result = ((wxCommandEvent const *)arg1)->GetString();
15012
15013 wxPyEndAllowThreads(__tstate);
15014 if (PyErr_Occurred()) SWIG_fail;
15015 }
15016 {
15017 #if wxUSE_UNICODE
15018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15019 #else
15020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15021 #endif
15022 }
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15030 PyObject *resultobj;
15031 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15032 bool result;
15033 PyObject * obj0 = 0 ;
15034 char *kwnames[] = {
15035 (char *) "self", NULL
15036 };
15037
15038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15040 if (SWIG_arg_fail(1)) SWIG_fail;
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 {
15049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15050 }
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15058 PyObject *resultobj;
15059 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15060 bool result;
15061 PyObject * obj0 = 0 ;
15062 char *kwnames[] = {
15063 (char *) "self", NULL
15064 };
15065
15066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15068 if (SWIG_arg_fail(1)) SWIG_fail;
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15072
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 {
15077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15078 }
15079 return resultobj;
15080 fail:
15081 return NULL;
15082 }
15083
15084
15085 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15086 PyObject *resultobj;
15087 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15088 long arg2 ;
15089 PyObject * obj0 = 0 ;
15090 PyObject * obj1 = 0 ;
15091 char *kwnames[] = {
15092 (char *) "self",(char *) "extraLong", NULL
15093 };
15094
15095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15097 if (SWIG_arg_fail(1)) SWIG_fail;
15098 {
15099 arg2 = (long)(SWIG_As_long(obj1));
15100 if (SWIG_arg_fail(2)) SWIG_fail;
15101 }
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 (arg1)->SetExtraLong(arg2);
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 Py_INCREF(Py_None); resultobj = Py_None;
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15119 long result;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 {
15136 resultobj = SWIG_From_long((long)(result));
15137 }
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15147 int arg2 ;
15148 PyObject * obj0 = 0 ;
15149 PyObject * obj1 = 0 ;
15150 char *kwnames[] = {
15151 (char *) "self",(char *) "i", NULL
15152 };
15153
15154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(1)) SWIG_fail;
15157 {
15158 arg2 = (int)(SWIG_As_int(obj1));
15159 if (SWIG_arg_fail(2)) SWIG_fail;
15160 }
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 (arg1)->SetInt(arg2);
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 Py_INCREF(Py_None); resultobj = Py_None;
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj;
15177 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15178 long result;
15179 PyObject * obj0 = 0 ;
15180 char *kwnames[] = {
15181 (char *) "self", NULL
15182 };
15183
15184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15186 if (SWIG_arg_fail(1)) SWIG_fail;
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 {
15195 resultobj = SWIG_From_long((long)(result));
15196 }
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15206 wxEvent *result;
15207 PyObject * obj0 = 0 ;
15208 char *kwnames[] = {
15209 (char *) "self", NULL
15210 };
15211
15212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15230 PyObject *obj;
15231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15232 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15233 Py_INCREF(obj);
15234 return Py_BuildValue((char *)"");
15235 }
15236 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15239 int arg2 = (int) 0 ;
15240 wxNotifyEvent *result;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 char *kwnames[] = {
15244 (char *) "commandType",(char *) "winid", NULL
15245 };
15246
15247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15248 if (obj0) {
15249 {
15250 arg1 = (wxEventType)(SWIG_As_int(obj0));
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 }
15253 }
15254 if (obj1) {
15255 {
15256 arg2 = (int)(SWIG_As_int(obj1));
15257 if (SWIG_arg_fail(2)) SWIG_fail;
15258 }
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15277 PyObject * obj0 = 0 ;
15278 char *kwnames[] = {
15279 (char *) "self", NULL
15280 };
15281
15282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15284 if (SWIG_arg_fail(1)) SWIG_fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 (arg1)->Veto();
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 Py_INCREF(Py_None); resultobj = Py_None;
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj;
15301 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15302 PyObject * obj0 = 0 ;
15303 char *kwnames[] = {
15304 (char *) "self", NULL
15305 };
15306
15307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15309 if (SWIG_arg_fail(1)) SWIG_fail;
15310 {
15311 PyThreadState* __tstate = wxPyBeginAllowThreads();
15312 (arg1)->Allow();
15313
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 Py_INCREF(Py_None); resultobj = Py_None;
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15325 PyObject *resultobj;
15326 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15327 bool result;
15328 PyObject * obj0 = 0 ;
15329 char *kwnames[] = {
15330 (char *) "self", NULL
15331 };
15332
15333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15335 if (SWIG_arg_fail(1)) SWIG_fail;
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 result = (bool)(arg1)->IsAllowed();
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 {
15344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15345 }
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15353 PyObject *obj;
15354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15355 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15356 Py_INCREF(obj);
15357 return Py_BuildValue((char *)"");
15358 }
15359 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj;
15361 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15362 int arg2 = (int) 0 ;
15363 int arg3 = (int) 0 ;
15364 int arg4 = (int) 0 ;
15365 wxScrollEvent *result;
15366 PyObject * obj0 = 0 ;
15367 PyObject * obj1 = 0 ;
15368 PyObject * obj2 = 0 ;
15369 PyObject * obj3 = 0 ;
15370 char *kwnames[] = {
15371 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15372 };
15373
15374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15375 if (obj0) {
15376 {
15377 arg1 = (wxEventType)(SWIG_As_int(obj0));
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 }
15380 }
15381 if (obj1) {
15382 {
15383 arg2 = (int)(SWIG_As_int(obj1));
15384 if (SWIG_arg_fail(2)) SWIG_fail;
15385 }
15386 }
15387 if (obj2) {
15388 {
15389 arg3 = (int)(SWIG_As_int(obj2));
15390 if (SWIG_arg_fail(3)) SWIG_fail;
15391 }
15392 }
15393 if (obj3) {
15394 {
15395 arg4 = (int)(SWIG_As_int(obj3));
15396 if (SWIG_arg_fail(4)) SWIG_fail;
15397 }
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15416 int result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = SWIG_From_int((int)(result));
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj;
15443 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15444 int result;
15445 PyObject * obj0 = 0 ;
15446 char *kwnames[] = {
15447 (char *) "self", NULL
15448 };
15449
15450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15452 if (SWIG_arg_fail(1)) SWIG_fail;
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15456
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 {
15461 resultobj = SWIG_From_int((int)(result));
15462 }
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj;
15471 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15472 int arg2 ;
15473 PyObject * obj0 = 0 ;
15474 PyObject * obj1 = 0 ;
15475 char *kwnames[] = {
15476 (char *) "self",(char *) "orient", NULL
15477 };
15478
15479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 {
15483 arg2 = (int)(SWIG_As_int(obj1));
15484 if (SWIG_arg_fail(2)) SWIG_fail;
15485 }
15486 {
15487 PyThreadState* __tstate = wxPyBeginAllowThreads();
15488 (arg1)->SetOrientation(arg2);
15489
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 Py_INCREF(Py_None); resultobj = Py_None;
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15501 PyObject *resultobj;
15502 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15503 int arg2 ;
15504 PyObject * obj0 = 0 ;
15505 PyObject * obj1 = 0 ;
15506 char *kwnames[] = {
15507 (char *) "self",(char *) "pos", NULL
15508 };
15509
15510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15512 if (SWIG_arg_fail(1)) SWIG_fail;
15513 {
15514 arg2 = (int)(SWIG_As_int(obj1));
15515 if (SWIG_arg_fail(2)) SWIG_fail;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 (arg1)->SetPosition(arg2);
15520
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 Py_INCREF(Py_None); resultobj = Py_None;
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15532 PyObject *obj;
15533 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15534 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15535 Py_INCREF(obj);
15536 return Py_BuildValue((char *)"");
15537 }
15538 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj;
15540 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15541 int arg2 = (int) 0 ;
15542 int arg3 = (int) 0 ;
15543 wxScrollWinEvent *result;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 PyObject * obj2 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15552 if (obj0) {
15553 {
15554 arg1 = (wxEventType)(SWIG_As_int(obj0));
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 }
15557 }
15558 if (obj1) {
15559 {
15560 arg2 = (int)(SWIG_As_int(obj1));
15561 if (SWIG_arg_fail(2)) SWIG_fail;
15562 }
15563 }
15564 if (obj2) {
15565 {
15566 arg3 = (int)(SWIG_As_int(obj2));
15567 if (SWIG_arg_fail(3)) SWIG_fail;
15568 }
15569 }
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15585 PyObject *resultobj;
15586 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15587 int result;
15588 PyObject * obj0 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "self", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15595 if (SWIG_arg_fail(1)) SWIG_fail;
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 {
15604 resultobj = SWIG_From_int((int)(result));
15605 }
15606 return resultobj;
15607 fail:
15608 return NULL;
15609 }
15610
15611
15612 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj;
15614 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15615 int result;
15616 PyObject * obj0 = 0 ;
15617 char *kwnames[] = {
15618 (char *) "self", NULL
15619 };
15620
15621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15623 if (SWIG_arg_fail(1)) SWIG_fail;
15624 {
15625 PyThreadState* __tstate = wxPyBeginAllowThreads();
15626 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15627
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 {
15632 resultobj = SWIG_From_int((int)(result));
15633 }
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15641 PyObject *resultobj;
15642 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15643 int arg2 ;
15644 PyObject * obj0 = 0 ;
15645 PyObject * obj1 = 0 ;
15646 char *kwnames[] = {
15647 (char *) "self",(char *) "orient", NULL
15648 };
15649
15650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15652 if (SWIG_arg_fail(1)) SWIG_fail;
15653 {
15654 arg2 = (int)(SWIG_As_int(obj1));
15655 if (SWIG_arg_fail(2)) SWIG_fail;
15656 }
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 (arg1)->SetOrientation(arg2);
15660
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 Py_INCREF(Py_None); resultobj = Py_None;
15665 return resultobj;
15666 fail:
15667 return NULL;
15668 }
15669
15670
15671 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15672 PyObject *resultobj;
15673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15674 int arg2 ;
15675 PyObject * obj0 = 0 ;
15676 PyObject * obj1 = 0 ;
15677 char *kwnames[] = {
15678 (char *) "self",(char *) "pos", NULL
15679 };
15680
15681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15683 if (SWIG_arg_fail(1)) SWIG_fail;
15684 {
15685 arg2 = (int)(SWIG_As_int(obj1));
15686 if (SWIG_arg_fail(2)) SWIG_fail;
15687 }
15688 {
15689 PyThreadState* __tstate = wxPyBeginAllowThreads();
15690 (arg1)->SetPosition(arg2);
15691
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 Py_INCREF(Py_None); resultobj = Py_None;
15696 return resultobj;
15697 fail:
15698 return NULL;
15699 }
15700
15701
15702 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15703 PyObject *obj;
15704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15705 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15706 Py_INCREF(obj);
15707 return Py_BuildValue((char *)"");
15708 }
15709 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15710 PyObject *resultobj;
15711 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15712 wxMouseEvent *result;
15713 PyObject * obj0 = 0 ;
15714 char *kwnames[] = {
15715 (char *) "mouseType", NULL
15716 };
15717
15718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15719 if (obj0) {
15720 {
15721 arg1 = (wxEventType)(SWIG_As_int(obj0));
15722 if (SWIG_arg_fail(1)) SWIG_fail;
15723 }
15724 }
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15728
15729 wxPyEndAllowThreads(__tstate);
15730 if (PyErr_Occurred()) SWIG_fail;
15731 }
15732 {
15733 resultobj = wxPyMake_wxObject(result, 1);
15734 }
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15742 PyObject *resultobj;
15743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15744 bool result;
15745 PyObject * obj0 = 0 ;
15746 char *kwnames[] = {
15747 (char *) "self", NULL
15748 };
15749
15750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15752 if (SWIG_arg_fail(1)) SWIG_fail;
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15756
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 {
15761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15762 }
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15770 PyObject *resultobj;
15771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15772 int arg2 = (int) wxMOUSE_BTN_ANY ;
15773 bool result;
15774 PyObject * obj0 = 0 ;
15775 PyObject * obj1 = 0 ;
15776 char *kwnames[] = {
15777 (char *) "self",(char *) "but", NULL
15778 };
15779
15780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15782 if (SWIG_arg_fail(1)) SWIG_fail;
15783 if (obj1) {
15784 {
15785 arg2 = (int)(SWIG_As_int(obj1));
15786 if (SWIG_arg_fail(2)) SWIG_fail;
15787 }
15788 }
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15792
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj;
15807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15808 int arg2 = (int) wxMOUSE_BTN_ANY ;
15809 bool result;
15810 PyObject * obj0 = 0 ;
15811 PyObject * obj1 = 0 ;
15812 char *kwnames[] = {
15813 (char *) "self",(char *) "but", NULL
15814 };
15815
15816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15818 if (SWIG_arg_fail(1)) SWIG_fail;
15819 if (obj1) {
15820 {
15821 arg2 = (int)(SWIG_As_int(obj1));
15822 if (SWIG_arg_fail(2)) SWIG_fail;
15823 }
15824 }
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15828
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 {
15833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15844 int arg2 = (int) wxMOUSE_BTN_ANY ;
15845 bool result;
15846 PyObject * obj0 = 0 ;
15847 PyObject * obj1 = 0 ;
15848 char *kwnames[] = {
15849 (char *) "self",(char *) "but", NULL
15850 };
15851
15852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15854 if (SWIG_arg_fail(1)) SWIG_fail;
15855 if (obj1) {
15856 {
15857 arg2 = (int)(SWIG_As_int(obj1));
15858 if (SWIG_arg_fail(2)) SWIG_fail;
15859 }
15860 }
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15864
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 {
15869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15870 }
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15878 PyObject *resultobj;
15879 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15880 int arg2 ;
15881 bool result;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self",(char *) "but", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 arg2 = (int)(SWIG_As_int(obj1));
15893 if (SWIG_arg_fail(2)) SWIG_fail;
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 {
15903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15904 }
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj;
15913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15914 int arg2 ;
15915 bool result;
15916 PyObject * obj0 = 0 ;
15917 PyObject * obj1 = 0 ;
15918 char *kwnames[] = {
15919 (char *) "self",(char *) "but", NULL
15920 };
15921
15922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15924 if (SWIG_arg_fail(1)) SWIG_fail;
15925 {
15926 arg2 = (int)(SWIG_As_int(obj1));
15927 if (SWIG_arg_fail(2)) SWIG_fail;
15928 }
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15932
15933 wxPyEndAllowThreads(__tstate);
15934 if (PyErr_Occurred()) SWIG_fail;
15935 }
15936 {
15937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15938 }
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj;
15947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15948 int result;
15949 PyObject * obj0 = 0 ;
15950 char *kwnames[] = {
15951 (char *) "self", NULL
15952 };
15953
15954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15960
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 {
15965 resultobj = SWIG_From_int((int)(result));
15966 }
15967 return resultobj;
15968 fail:
15969 return NULL;
15970 }
15971
15972
15973 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15974 PyObject *resultobj;
15975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15976 bool result;
15977 PyObject * obj0 = 0 ;
15978 char *kwnames[] = {
15979 (char *) "self", NULL
15980 };
15981
15982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15984 if (SWIG_arg_fail(1)) SWIG_fail;
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15988
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 {
15993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15994 }
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16004 bool result;
16005 PyObject * obj0 = 0 ;
16006 char *kwnames[] = {
16007 (char *) "self", NULL
16008 };
16009
16010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16012 if (SWIG_arg_fail(1)) SWIG_fail;
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16016
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 {
16021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16022 }
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16032 bool result;
16033 PyObject * obj0 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16058 PyObject *resultobj;
16059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16060 bool result;
16061 PyObject * obj0 = 0 ;
16062 char *kwnames[] = {
16063 (char *) "self", NULL
16064 };
16065
16066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16068 if (SWIG_arg_fail(1)) SWIG_fail;
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 {
16077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16078 }
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj;
16087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16088 bool result;
16089 PyObject * obj0 = 0 ;
16090 char *kwnames[] = {
16091 (char *) "self", NULL
16092 };
16093
16094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16096 if (SWIG_arg_fail(1)) SWIG_fail;
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16100
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 {
16105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16106 }
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16116 bool result;
16117 PyObject * obj0 = 0 ;
16118 char *kwnames[] = {
16119 (char *) "self", NULL
16120 };
16121
16122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16124 if (SWIG_arg_fail(1)) SWIG_fail;
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 {
16133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16134 }
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj;
16143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16144 bool result;
16145 PyObject * obj0 = 0 ;
16146 char *kwnames[] = {
16147 (char *) "self", NULL
16148 };
16149
16150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16152 if (SWIG_arg_fail(1)) SWIG_fail;
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16156
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj;
16171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16172 bool result;
16173 PyObject * obj0 = 0 ;
16174 char *kwnames[] = {
16175 (char *) "self", NULL
16176 };
16177
16178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16180 if (SWIG_arg_fail(1)) SWIG_fail;
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16184
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 {
16189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16190 }
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj;
16199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16200 bool result;
16201 PyObject * obj0 = 0 ;
16202 char *kwnames[] = {
16203 (char *) "self", NULL
16204 };
16205
16206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16208 if (SWIG_arg_fail(1)) SWIG_fail;
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 {
16217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16218 }
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16228 bool result;
16229 PyObject * obj0 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16240
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16256 bool result;
16257 PyObject * obj0 = 0 ;
16258 char *kwnames[] = {
16259 (char *) "self", NULL
16260 };
16261
16262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16264 if (SWIG_arg_fail(1)) SWIG_fail;
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16268
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj;
16283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16284 bool result;
16285 PyObject * obj0 = 0 ;
16286 char *kwnames[] = {
16287 (char *) "self", NULL
16288 };
16289
16290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16292 if (SWIG_arg_fail(1)) SWIG_fail;
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16296
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 {
16301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16302 }
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj;
16311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16312 bool result;
16313 PyObject * obj0 = 0 ;
16314 char *kwnames[] = {
16315 (char *) "self", NULL
16316 };
16317
16318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16320 if (SWIG_arg_fail(1)) SWIG_fail;
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16324
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 {
16329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16330 }
16331 return resultobj;
16332 fail:
16333 return NULL;
16334 }
16335
16336
16337 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16338 PyObject *resultobj;
16339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16340 bool result;
16341 PyObject * obj0 = 0 ;
16342 char *kwnames[] = {
16343 (char *) "self", NULL
16344 };
16345
16346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16348 if (SWIG_arg_fail(1)) SWIG_fail;
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 {
16357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16358 }
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16368 bool result;
16369 PyObject * obj0 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 result = (bool)(arg1)->LeftIsDown();
16380
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 {
16385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16386 }
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj;
16395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16396 bool result;
16397 PyObject * obj0 = 0 ;
16398 char *kwnames[] = {
16399 (char *) "self", NULL
16400 };
16401
16402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16404 if (SWIG_arg_fail(1)) SWIG_fail;
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 result = (bool)(arg1)->MiddleIsDown();
16408
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16424 bool result;
16425 PyObject * obj0 = 0 ;
16426 char *kwnames[] = {
16427 (char *) "self", NULL
16428 };
16429
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (bool)(arg1)->RightIsDown();
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 {
16441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16442 }
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj;
16451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16452 bool result;
16453 PyObject * obj0 = 0 ;
16454 char *kwnames[] = {
16455 (char *) "self", NULL
16456 };
16457
16458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16464
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16480 bool result;
16481 PyObject * obj0 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16498 }
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16508 bool result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16536 bool result;
16537 PyObject * obj0 = 0 ;
16538 char *kwnames[] = {
16539 (char *) "self", NULL
16540 };
16541
16542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16544 if (SWIG_arg_fail(1)) SWIG_fail;
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16548
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 {
16553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16554 }
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj;
16563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16564 wxPoint result;
16565 PyObject * obj0 = 0 ;
16566 char *kwnames[] = {
16567 (char *) "self", NULL
16568 };
16569
16570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16572 if (SWIG_arg_fail(1)) SWIG_fail;
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 result = (arg1)->GetPosition();
16576
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 wxPoint * resultptr;
16582 resultptr = new wxPoint((wxPoint &)(result));
16583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16584 }
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16594 long *arg2 = (long *) 0 ;
16595 long *arg3 = (long *) 0 ;
16596 long temp2 ;
16597 int res2 = 0 ;
16598 long temp3 ;
16599 int res3 = 0 ;
16600 PyObject * obj0 = 0 ;
16601 char *kwnames[] = {
16602 (char *) "self", NULL
16603 };
16604
16605 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16606 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16609 if (SWIG_arg_fail(1)) SWIG_fail;
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 (arg1)->GetPosition(arg2,arg3);
16613
16614 wxPyEndAllowThreads(__tstate);
16615 if (PyErr_Occurred()) SWIG_fail;
16616 }
16617 Py_INCREF(Py_None); resultobj = Py_None;
16618 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16619 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16620 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16621 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj;
16630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16631 wxDC *arg2 = 0 ;
16632 wxPoint result;
16633 PyObject * obj0 = 0 ;
16634 PyObject * obj1 = 0 ;
16635 char *kwnames[] = {
16636 (char *) "self",(char *) "dc", NULL
16637 };
16638
16639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16641 if (SWIG_arg_fail(1)) SWIG_fail;
16642 {
16643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(2)) SWIG_fail;
16645 if (arg2 == NULL) {
16646 SWIG_null_ref("wxDC");
16647 }
16648 if (SWIG_arg_fail(2)) SWIG_fail;
16649 }
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16653
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 {
16658 wxPoint * resultptr;
16659 resultptr = new wxPoint((wxPoint &)(result));
16660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16661 }
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16671 int result;
16672 PyObject * obj0 = 0 ;
16673 char *kwnames[] = {
16674 (char *) "self", NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16679 if (SWIG_arg_fail(1)) SWIG_fail;
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxMouseEvent const *)arg1)->GetX();
16683
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 {
16688 resultobj = SWIG_From_int((int)(result));
16689 }
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj;
16698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16699 int result;
16700 PyObject * obj0 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "self", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxMouseEvent const *)arg1)->GetY();
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 {
16716 resultobj = SWIG_From_int((int)(result));
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16727 int result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = SWIG_From_int((int)(result));
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16755 int result;
16756 PyObject * obj0 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16763 if (SWIG_arg_fail(1)) SWIG_fail;
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 resultobj = SWIG_From_int((int)(result));
16773 }
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj;
16782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16783 int result;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 {
16800 resultobj = SWIG_From_int((int)(result));
16801 }
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj;
16810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16811 bool result;
16812 PyObject * obj0 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self", NULL
16815 };
16816
16817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16823
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16839 int arg2 ;
16840 PyObject * obj0 = 0 ;
16841 PyObject * obj1 = 0 ;
16842 char *kwnames[] = {
16843 (char *) "self",(char *) "m_x", NULL
16844 };
16845
16846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16848 if (SWIG_arg_fail(1)) SWIG_fail;
16849 {
16850 arg2 = (int)(SWIG_As_int(obj1));
16851 if (SWIG_arg_fail(2)) SWIG_fail;
16852 }
16853 if (arg1) (arg1)->m_x = arg2;
16854
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16865 int result;
16866 PyObject * obj0 = 0 ;
16867 char *kwnames[] = {
16868 (char *) "self", NULL
16869 };
16870
16871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16873 if (SWIG_arg_fail(1)) SWIG_fail;
16874 result = (int) ((arg1)->m_x);
16875
16876 {
16877 resultobj = SWIG_From_int((int)(result));
16878 }
16879 return resultobj;
16880 fail:
16881 return NULL;
16882 }
16883
16884
16885 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16886 PyObject *resultobj;
16887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16888 int arg2 ;
16889 PyObject * obj0 = 0 ;
16890 PyObject * obj1 = 0 ;
16891 char *kwnames[] = {
16892 (char *) "self",(char *) "m_y", NULL
16893 };
16894
16895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16897 if (SWIG_arg_fail(1)) SWIG_fail;
16898 {
16899 arg2 = (int)(SWIG_As_int(obj1));
16900 if (SWIG_arg_fail(2)) SWIG_fail;
16901 }
16902 if (arg1) (arg1)->m_y = arg2;
16903
16904 Py_INCREF(Py_None); resultobj = Py_None;
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj;
16913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16914 int result;
16915 PyObject * obj0 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 result = (int) ((arg1)->m_y);
16924
16925 {
16926 resultobj = SWIG_From_int((int)(result));
16927 }
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj;
16936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16937 bool arg2 ;
16938 PyObject * obj0 = 0 ;
16939 PyObject * obj1 = 0 ;
16940 char *kwnames[] = {
16941 (char *) "self",(char *) "m_leftDown", NULL
16942 };
16943
16944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16946 if (SWIG_arg_fail(1)) SWIG_fail;
16947 {
16948 arg2 = (bool)(SWIG_As_bool(obj1));
16949 if (SWIG_arg_fail(2)) SWIG_fail;
16950 }
16951 if (arg1) (arg1)->m_leftDown = arg2;
16952
16953 Py_INCREF(Py_None); resultobj = Py_None;
16954 return resultobj;
16955 fail:
16956 return NULL;
16957 }
16958
16959
16960 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj;
16962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16963 bool result;
16964 PyObject * obj0 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 result = (bool) ((arg1)->m_leftDown);
16973
16974 {
16975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16976 }
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16986 bool arg2 ;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 char *kwnames[] = {
16990 (char *) "self",(char *) "m_middleDown", NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16995 if (SWIG_arg_fail(1)) SWIG_fail;
16996 {
16997 arg2 = (bool)(SWIG_As_bool(obj1));
16998 if (SWIG_arg_fail(2)) SWIG_fail;
16999 }
17000 if (arg1) (arg1)->m_middleDown = arg2;
17001
17002 Py_INCREF(Py_None); resultobj = Py_None;
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj;
17011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17012 bool result;
17013 PyObject * obj0 = 0 ;
17014 char *kwnames[] = {
17015 (char *) "self", NULL
17016 };
17017
17018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17020 if (SWIG_arg_fail(1)) SWIG_fail;
17021 result = (bool) ((arg1)->m_middleDown);
17022
17023 {
17024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17025 }
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17035 bool arg2 ;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self",(char *) "m_rightDown", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 {
17046 arg2 = (bool)(SWIG_As_bool(obj1));
17047 if (SWIG_arg_fail(2)) SWIG_fail;
17048 }
17049 if (arg1) (arg1)->m_rightDown = arg2;
17050
17051 Py_INCREF(Py_None); resultobj = Py_None;
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj;
17060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17061 bool result;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 result = (bool) ((arg1)->m_rightDown);
17071
17072 {
17073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 bool arg2 ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self",(char *) "m_controlDown", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 arg2 = (bool)(SWIG_As_bool(obj1));
17096 if (SWIG_arg_fail(2)) SWIG_fail;
17097 }
17098 if (arg1) (arg1)->m_controlDown = arg2;
17099
17100 Py_INCREF(Py_None); resultobj = Py_None;
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17110 bool result;
17111 PyObject * obj0 = 0 ;
17112 char *kwnames[] = {
17113 (char *) "self", NULL
17114 };
17115
17116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(1)) SWIG_fail;
17119 result = (bool) ((arg1)->m_controlDown);
17120
17121 {
17122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17123 }
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj;
17132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17133 bool arg2 ;
17134 PyObject * obj0 = 0 ;
17135 PyObject * obj1 = 0 ;
17136 char *kwnames[] = {
17137 (char *) "self",(char *) "m_shiftDown", NULL
17138 };
17139
17140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17142 if (SWIG_arg_fail(1)) SWIG_fail;
17143 {
17144 arg2 = (bool)(SWIG_As_bool(obj1));
17145 if (SWIG_arg_fail(2)) SWIG_fail;
17146 }
17147 if (arg1) (arg1)->m_shiftDown = arg2;
17148
17149 Py_INCREF(Py_None); resultobj = Py_None;
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17159 bool result;
17160 PyObject * obj0 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 result = (bool) ((arg1)->m_shiftDown);
17169
17170 {
17171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17172 }
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17182 bool arg2 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "m_altDown", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 arg2 = (bool)(SWIG_As_bool(obj1));
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 }
17196 if (arg1) (arg1)->m_altDown = arg2;
17197
17198 Py_INCREF(Py_None); resultobj = Py_None;
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17208 bool result;
17209 PyObject * obj0 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 result = (bool) ((arg1)->m_altDown);
17218
17219 {
17220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17221 }
17222 return resultobj;
17223 fail:
17224 return NULL;
17225 }
17226
17227
17228 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17229 PyObject *resultobj;
17230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17231 bool arg2 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 char *kwnames[] = {
17235 (char *) "self",(char *) "m_metaDown", NULL
17236 };
17237
17238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17240 if (SWIG_arg_fail(1)) SWIG_fail;
17241 {
17242 arg2 = (bool)(SWIG_As_bool(obj1));
17243 if (SWIG_arg_fail(2)) SWIG_fail;
17244 }
17245 if (arg1) (arg1)->m_metaDown = arg2;
17246
17247 Py_INCREF(Py_None); resultobj = Py_None;
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 bool result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 result = (bool) ((arg1)->m_metaDown);
17267
17268 {
17269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17270 }
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17280 int arg2 ;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "self",(char *) "m_wheelRotation", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 {
17291 arg2 = (int)(SWIG_As_int(obj1));
17292 if (SWIG_arg_fail(2)) SWIG_fail;
17293 }
17294 if (arg1) (arg1)->m_wheelRotation = arg2;
17295
17296 Py_INCREF(Py_None); resultobj = Py_None;
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17304 PyObject *resultobj;
17305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17306 int result;
17307 PyObject * obj0 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 result = (int) ((arg1)->m_wheelRotation);
17316
17317 {
17318 resultobj = SWIG_From_int((int)(result));
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj;
17328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17329 int arg2 ;
17330 PyObject * obj0 = 0 ;
17331 PyObject * obj1 = 0 ;
17332 char *kwnames[] = {
17333 (char *) "self",(char *) "m_wheelDelta", NULL
17334 };
17335
17336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17338 if (SWIG_arg_fail(1)) SWIG_fail;
17339 {
17340 arg2 = (int)(SWIG_As_int(obj1));
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 }
17343 if (arg1) (arg1)->m_wheelDelta = arg2;
17344
17345 Py_INCREF(Py_None); resultobj = Py_None;
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj;
17354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17355 int result;
17356 PyObject * obj0 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 result = (int) ((arg1)->m_wheelDelta);
17365
17366 {
17367 resultobj = SWIG_From_int((int)(result));
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17378 int arg2 ;
17379 PyObject * obj0 = 0 ;
17380 PyObject * obj1 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self",(char *) "m_linesPerAction", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = (int)(SWIG_As_int(obj1));
17390 if (SWIG_arg_fail(2)) SWIG_fail;
17391 }
17392 if (arg1) (arg1)->m_linesPerAction = arg2;
17393
17394 Py_INCREF(Py_None); resultobj = Py_None;
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 result = (int) ((arg1)->m_linesPerAction);
17414
17415 {
17416 resultobj = SWIG_From_int((int)(result));
17417 }
17418 return resultobj;
17419 fail:
17420 return NULL;
17421 }
17422
17423
17424 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17425 PyObject *obj;
17426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17427 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17428 Py_INCREF(obj);
17429 return Py_BuildValue((char *)"");
17430 }
17431 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 int arg1 = (int) 0 ;
17434 int arg2 = (int) 0 ;
17435 wxSetCursorEvent *result;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 char *kwnames[] = {
17439 (char *) "x",(char *) "y", NULL
17440 };
17441
17442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17443 if (obj0) {
17444 {
17445 arg1 = (int)(SWIG_As_int(obj0));
17446 if (SWIG_arg_fail(1)) SWIG_fail;
17447 }
17448 }
17449 if (obj1) {
17450 {
17451 arg2 = (int)(SWIG_As_int(obj1));
17452 if (SWIG_arg_fail(2)) SWIG_fail;
17453 }
17454 }
17455 {
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17458
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17470 PyObject *resultobj;
17471 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17472 int result;
17473 PyObject * obj0 = 0 ;
17474 char *kwnames[] = {
17475 (char *) "self", NULL
17476 };
17477
17478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17480 if (SWIG_arg_fail(1)) SWIG_fail;
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17484
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 {
17489 resultobj = SWIG_From_int((int)(result));
17490 }
17491 return resultobj;
17492 fail:
17493 return NULL;
17494 }
17495
17496
17497 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj;
17499 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17500 int result;
17501 PyObject * obj0 = 0 ;
17502 char *kwnames[] = {
17503 (char *) "self", NULL
17504 };
17505
17506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17508 if (SWIG_arg_fail(1)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17512
17513 wxPyEndAllowThreads(__tstate);
17514 if (PyErr_Occurred()) SWIG_fail;
17515 }
17516 {
17517 resultobj = SWIG_From_int((int)(result));
17518 }
17519 return resultobj;
17520 fail:
17521 return NULL;
17522 }
17523
17524
17525 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17526 PyObject *resultobj;
17527 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17528 wxCursor *arg2 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self",(char *) "cursor", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(2)) SWIG_fail;
17541 if (arg2 == NULL) {
17542 SWIG_null_ref("wxCursor");
17543 }
17544 if (SWIG_arg_fail(2)) SWIG_fail;
17545 }
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 (arg1)->SetCursor((wxCursor const &)*arg2);
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 Py_INCREF(Py_None); resultobj = Py_None;
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj;
17562 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17563 wxCursor *result;
17564 PyObject * obj0 = 0 ;
17565 char *kwnames[] = {
17566 (char *) "self", NULL
17567 };
17568
17569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17571 if (SWIG_arg_fail(1)) SWIG_fail;
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 {
17575 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17576 result = (wxCursor *) &_result_ref;
17577 }
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 wxCursor* resultptr = new wxCursor(*result);
17584 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17595 bool result;
17596 PyObject * obj0 = 0 ;
17597 char *kwnames[] = {
17598 (char *) "self", NULL
17599 };
17600
17601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17603 if (SWIG_arg_fail(1)) SWIG_fail;
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17607
17608 wxPyEndAllowThreads(__tstate);
17609 if (PyErr_Occurred()) SWIG_fail;
17610 }
17611 {
17612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17621 PyObject *obj;
17622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17623 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17624 Py_INCREF(obj);
17625 return Py_BuildValue((char *)"");
17626 }
17627 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17630 wxKeyEvent *result;
17631 PyObject * obj0 = 0 ;
17632 char *kwnames[] = {
17633 (char *) "keyType", NULL
17634 };
17635
17636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17637 if (obj0) {
17638 {
17639 arg1 = (wxEventType)(SWIG_As_int(obj0));
17640 if (SWIG_arg_fail(1)) SWIG_fail;
17641 }
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17646
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17651 return resultobj;
17652 fail:
17653 return NULL;
17654 }
17655
17656
17657 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17658 PyObject *resultobj;
17659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17660 bool result;
17661 PyObject * obj0 = 0 ;
17662 char *kwnames[] = {
17663 (char *) "self", NULL
17664 };
17665
17666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17668 if (SWIG_arg_fail(1)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17672
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 {
17677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17678 }
17679 return resultobj;
17680 fail:
17681 return NULL;
17682 }
17683
17684
17685 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17688 bool result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 PyThreadState* __tstate = wxPyBeginAllowThreads();
17699 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17700
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 {
17705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17706 }
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17714 PyObject *resultobj;
17715 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17716 bool result;
17717 PyObject * obj0 = 0 ;
17718 char *kwnames[] = {
17719 (char *) "self", NULL
17720 };
17721
17722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17724 if (SWIG_arg_fail(1)) SWIG_fail;
17725 {
17726 PyThreadState* __tstate = wxPyBeginAllowThreads();
17727 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17728
17729 wxPyEndAllowThreads(__tstate);
17730 if (PyErr_Occurred()) SWIG_fail;
17731 }
17732 {
17733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17734 }
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj;
17743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17744 bool result;
17745 PyObject * obj0 = 0 ;
17746 char *kwnames[] = {
17747 (char *) "self", NULL
17748 };
17749
17750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17752 if (SWIG_arg_fail(1)) SWIG_fail;
17753 {
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17756
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17772 bool result;
17773 PyObject * obj0 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17784
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 {
17789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj;
17799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17800 bool result;
17801 PyObject * obj0 = 0 ;
17802 char *kwnames[] = {
17803 (char *) "self", NULL
17804 };
17805
17806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(1)) SWIG_fail;
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17812
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17818 }
17819 return resultobj;
17820 fail:
17821 return NULL;
17822 }
17823
17824
17825 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17826 PyObject *resultobj;
17827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17828 int result;
17829 PyObject * obj0 = 0 ;
17830 char *kwnames[] = {
17831 (char *) "self", NULL
17832 };
17833
17834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17836 if (SWIG_arg_fail(1)) SWIG_fail;
17837 {
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17840
17841 wxPyEndAllowThreads(__tstate);
17842 if (PyErr_Occurred()) SWIG_fail;
17843 }
17844 {
17845 resultobj = SWIG_From_int((int)(result));
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj;
17855 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17856 int result;
17857 PyObject * obj0 = 0 ;
17858 char *kwnames[] = {
17859 (char *) "self", NULL
17860 };
17861
17862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17864 if (SWIG_arg_fail(1)) SWIG_fail;
17865 {
17866 PyThreadState* __tstate = wxPyBeginAllowThreads();
17867 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17868
17869 wxPyEndAllowThreads(__tstate);
17870 if (PyErr_Occurred()) SWIG_fail;
17871 }
17872 {
17873 resultobj = SWIG_From_int((int)(result));
17874 }
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17884 unsigned int result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "self", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17892 if (SWIG_arg_fail(1)) SWIG_fail;
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17896
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17902 }
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj;
17911 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17912 unsigned int result;
17913 PyObject * obj0 = 0 ;
17914 char *kwnames[] = {
17915 (char *) "self", NULL
17916 };
17917
17918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17940 wxPoint result;
17941 PyObject * obj0 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "self", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17948 if (SWIG_arg_fail(1)) SWIG_fail;
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (arg1)->GetPosition();
17952
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 wxPoint * resultptr;
17958 resultptr = new wxPoint((wxPoint &)(result));
17959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17968 PyObject *resultobj;
17969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17970 long *arg2 = (long *) 0 ;
17971 long *arg3 = (long *) 0 ;
17972 long temp2 ;
17973 int res2 = 0 ;
17974 long temp3 ;
17975 int res3 = 0 ;
17976 PyObject * obj0 = 0 ;
17977 char *kwnames[] = {
17978 (char *) "self", NULL
17979 };
17980
17981 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17982 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 (arg1)->GetPosition(arg2,arg3);
17989
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 Py_INCREF(Py_None); resultobj = Py_None;
17994 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17995 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17996 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17997 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj;
18006 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18007 int result;
18008 PyObject * obj0 = 0 ;
18009 char *kwnames[] = {
18010 (char *) "self", NULL
18011 };
18012
18013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18015 if (SWIG_arg_fail(1)) SWIG_fail;
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (int)((wxKeyEvent const *)arg1)->GetX();
18019
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = SWIG_From_int((int)(result));
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj;
18034 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18035 int result;
18036 PyObject * obj0 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 result = (int)((wxKeyEvent const *)arg1)->GetY();
18047
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = SWIG_From_int((int)(result));
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj;
18062 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18063 int arg2 ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 char *kwnames[] = {
18067 (char *) "self",(char *) "m_x", NULL
18068 };
18069
18070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18072 if (SWIG_arg_fail(1)) SWIG_fail;
18073 {
18074 arg2 = (int)(SWIG_As_int(obj1));
18075 if (SWIG_arg_fail(2)) SWIG_fail;
18076 }
18077 if (arg1) (arg1)->m_x = arg2;
18078
18079 Py_INCREF(Py_None); resultobj = Py_None;
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj;
18088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18089 int result;
18090 PyObject * obj0 = 0 ;
18091 char *kwnames[] = {
18092 (char *) "self", NULL
18093 };
18094
18095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18097 if (SWIG_arg_fail(1)) SWIG_fail;
18098 result = (int) ((arg1)->m_x);
18099
18100 {
18101 resultobj = SWIG_From_int((int)(result));
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj;
18111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18112 int arg2 ;
18113 PyObject * obj0 = 0 ;
18114 PyObject * obj1 = 0 ;
18115 char *kwnames[] = {
18116 (char *) "self",(char *) "m_y", NULL
18117 };
18118
18119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18121 if (SWIG_arg_fail(1)) SWIG_fail;
18122 {
18123 arg2 = (int)(SWIG_As_int(obj1));
18124 if (SWIG_arg_fail(2)) SWIG_fail;
18125 }
18126 if (arg1) (arg1)->m_y = arg2;
18127
18128 Py_INCREF(Py_None); resultobj = Py_None;
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj;
18137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18138 int result;
18139 PyObject * obj0 = 0 ;
18140 char *kwnames[] = {
18141 (char *) "self", NULL
18142 };
18143
18144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(1)) SWIG_fail;
18147 result = (int) ((arg1)->m_y);
18148
18149 {
18150 resultobj = SWIG_From_int((int)(result));
18151 }
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj;
18160 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18161 long arg2 ;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self",(char *) "m_keyCode", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 {
18172 arg2 = (long)(SWIG_As_long(obj1));
18173 if (SWIG_arg_fail(2)) SWIG_fail;
18174 }
18175 if (arg1) (arg1)->m_keyCode = arg2;
18176
18177 Py_INCREF(Py_None); resultobj = Py_None;
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj;
18186 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18187 long result;
18188 PyObject * obj0 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 result = (long) ((arg1)->m_keyCode);
18197
18198 {
18199 resultobj = SWIG_From_long((long)(result));
18200 }
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18210 bool arg2 ;
18211 PyObject * obj0 = 0 ;
18212 PyObject * obj1 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "self",(char *) "m_controlDown", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 {
18221 arg2 = (bool)(SWIG_As_bool(obj1));
18222 if (SWIG_arg_fail(2)) SWIG_fail;
18223 }
18224 if (arg1) (arg1)->m_controlDown = arg2;
18225
18226 Py_INCREF(Py_None); resultobj = Py_None;
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18236 bool result;
18237 PyObject * obj0 = 0 ;
18238 char *kwnames[] = {
18239 (char *) "self", NULL
18240 };
18241
18242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 result = (bool) ((arg1)->m_controlDown);
18246
18247 {
18248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18249 }
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18259 bool arg2 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char *kwnames[] = {
18263 (char *) "self",(char *) "m_shiftDown", NULL
18264 };
18265
18266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18268 if (SWIG_arg_fail(1)) SWIG_fail;
18269 {
18270 arg2 = (bool)(SWIG_As_bool(obj1));
18271 if (SWIG_arg_fail(2)) SWIG_fail;
18272 }
18273 if (arg1) (arg1)->m_shiftDown = arg2;
18274
18275 Py_INCREF(Py_None); resultobj = Py_None;
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18285 bool result;
18286 PyObject * obj0 = 0 ;
18287 char *kwnames[] = {
18288 (char *) "self", NULL
18289 };
18290
18291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18293 if (SWIG_arg_fail(1)) SWIG_fail;
18294 result = (bool) ((arg1)->m_shiftDown);
18295
18296 {
18297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18308 bool arg2 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "m_altDown", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 arg2 = (bool)(SWIG_As_bool(obj1));
18320 if (SWIG_arg_fail(2)) SWIG_fail;
18321 }
18322 if (arg1) (arg1)->m_altDown = arg2;
18323
18324 Py_INCREF(Py_None); resultobj = Py_None;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18334 bool result;
18335 PyObject * obj0 = 0 ;
18336 char *kwnames[] = {
18337 (char *) "self", NULL
18338 };
18339
18340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18342 if (SWIG_arg_fail(1)) SWIG_fail;
18343 result = (bool) ((arg1)->m_altDown);
18344
18345 {
18346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj;
18356 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18357 bool arg2 ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self",(char *) "m_metaDown", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 arg2 = (bool)(SWIG_As_bool(obj1));
18369 if (SWIG_arg_fail(2)) SWIG_fail;
18370 }
18371 if (arg1) (arg1)->m_metaDown = arg2;
18372
18373 Py_INCREF(Py_None); resultobj = Py_None;
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18383 bool result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 result = (bool) ((arg1)->m_metaDown);
18393
18394 {
18395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18396 }
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18406 bool arg2 ;
18407 PyObject * obj0 = 0 ;
18408 PyObject * obj1 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "self",(char *) "m_scanCode", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18415 if (SWIG_arg_fail(1)) SWIG_fail;
18416 {
18417 arg2 = (bool)(SWIG_As_bool(obj1));
18418 if (SWIG_arg_fail(2)) SWIG_fail;
18419 }
18420 if (arg1) (arg1)->m_scanCode = arg2;
18421
18422 Py_INCREF(Py_None); resultobj = Py_None;
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 result = (bool) ((arg1)->m_scanCode);
18442
18443 {
18444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18445 }
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj;
18454 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18455 unsigned int arg2 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self",(char *) "m_rawCode", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18467 if (SWIG_arg_fail(2)) SWIG_fail;
18468 }
18469 if (arg1) (arg1)->m_rawCode = arg2;
18470
18471 Py_INCREF(Py_None); resultobj = Py_None;
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18481 unsigned int result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 result = (unsigned int) ((arg1)->m_rawCode);
18491
18492 {
18493 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18504 unsigned int arg2 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self",(char *) "m_rawFlags", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18516 if (SWIG_arg_fail(2)) SWIG_fail;
18517 }
18518 if (arg1) (arg1)->m_rawFlags = arg2;
18519
18520 Py_INCREF(Py_None); resultobj = Py_None;
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18530 unsigned int result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 result = (unsigned int) ((arg1)->m_rawFlags);
18540
18541 {
18542 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18543 }
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18551 PyObject *obj;
18552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18553 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18554 Py_INCREF(obj);
18555 return Py_BuildValue((char *)"");
18556 }
18557 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj;
18559 wxSize const &arg1_defvalue = wxDefaultSize ;
18560 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18561 int arg2 = (int) 0 ;
18562 wxSizeEvent *result;
18563 wxSize temp1 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "sz",(char *) "winid", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18571 if (obj0) {
18572 {
18573 arg1 = &temp1;
18574 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18575 }
18576 }
18577 if (obj1) {
18578 {
18579 arg2 = (int)(SWIG_As_int(obj1));
18580 if (SWIG_arg_fail(2)) SWIG_fail;
18581 }
18582 }
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18586
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18600 wxSize result;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = ((wxSizeEvent const *)arg1)->GetSize();
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 {
18617 wxSize * resultptr;
18618 resultptr = new wxSize((wxSize &)(result));
18619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18620 }
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18628 PyObject *resultobj;
18629 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18630 wxRect result;
18631 PyObject * obj0 = 0 ;
18632 char *kwnames[] = {
18633 (char *) "self", NULL
18634 };
18635
18636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18638 if (SWIG_arg_fail(1)) SWIG_fail;
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = ((wxSizeEvent const *)arg1)->GetRect();
18642
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 {
18647 wxRect * resultptr;
18648 resultptr = new wxRect((wxRect &)(result));
18649 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18650 }
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18660 wxRect arg2 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "rect", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 wxRect * argp;
18672 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18673 if (SWIG_arg_fail(2)) SWIG_fail;
18674 if (argp == NULL) {
18675 SWIG_null_ref("wxRect");
18676 }
18677 if (SWIG_arg_fail(2)) SWIG_fail;
18678 arg2 = *argp;
18679 }
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 (arg1)->SetRect(arg2);
18683
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 Py_INCREF(Py_None); resultobj = Py_None;
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj;
18696 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18697 wxSize arg2 ;
18698 PyObject * obj0 = 0 ;
18699 PyObject * obj1 = 0 ;
18700 char *kwnames[] = {
18701 (char *) "self",(char *) "size", NULL
18702 };
18703
18704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18706 if (SWIG_arg_fail(1)) SWIG_fail;
18707 {
18708 wxSize * argp;
18709 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18710 if (SWIG_arg_fail(2)) SWIG_fail;
18711 if (argp == NULL) {
18712 SWIG_null_ref("wxSize");
18713 }
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 arg2 = *argp;
18716 }
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 wxSizeEvent_SetSize(arg1,arg2);
18720
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 Py_INCREF(Py_None); resultobj = Py_None;
18725 return resultobj;
18726 fail:
18727 return NULL;
18728 }
18729
18730
18731 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj;
18733 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18734 wxSize *arg2 = (wxSize *) 0 ;
18735 PyObject * obj0 = 0 ;
18736 PyObject * obj1 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "self",(char *) "m_size", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(2)) SWIG_fail;
18746 if (arg1) (arg1)->m_size = *arg2;
18747
18748 Py_INCREF(Py_None); resultobj = Py_None;
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18758 wxSize *result;
18759 PyObject * obj0 = 0 ;
18760 char *kwnames[] = {
18761 (char *) "self", NULL
18762 };
18763
18764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18766 if (SWIG_arg_fail(1)) SWIG_fail;
18767 result = (wxSize *)& ((arg1)->m_size);
18768
18769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj;
18778 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18779 wxRect *arg2 = (wxRect *) 0 ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 char *kwnames[] = {
18783 (char *) "self",(char *) "m_rect", NULL
18784 };
18785
18786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18788 if (SWIG_arg_fail(1)) SWIG_fail;
18789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(2)) SWIG_fail;
18791 if (arg1) (arg1)->m_rect = *arg2;
18792
18793 Py_INCREF(Py_None); resultobj = Py_None;
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj;
18802 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18803 wxRect *result;
18804 PyObject * obj0 = 0 ;
18805 char *kwnames[] = {
18806 (char *) "self", NULL
18807 };
18808
18809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18811 if (SWIG_arg_fail(1)) SWIG_fail;
18812 result = (wxRect *)& ((arg1)->m_rect);
18813
18814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18822 PyObject *obj;
18823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18824 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18825 Py_INCREF(obj);
18826 return Py_BuildValue((char *)"");
18827 }
18828 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18831 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18832 int arg2 = (int) 0 ;
18833 wxMoveEvent *result;
18834 wxPoint temp1 ;
18835 PyObject * obj0 = 0 ;
18836 PyObject * obj1 = 0 ;
18837 char *kwnames[] = {
18838 (char *) "pos",(char *) "winid", NULL
18839 };
18840
18841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18842 if (obj0) {
18843 {
18844 arg1 = &temp1;
18845 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18846 }
18847 }
18848 if (obj1) {
18849 {
18850 arg2 = (int)(SWIG_As_int(obj1));
18851 if (SWIG_arg_fail(2)) SWIG_fail;
18852 }
18853 }
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18857
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj;
18870 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18871 wxPoint result;
18872 PyObject * obj0 = 0 ;
18873 char *kwnames[] = {
18874 (char *) "self", NULL
18875 };
18876
18877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18879 if (SWIG_arg_fail(1)) SWIG_fail;
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 result = ((wxMoveEvent const *)arg1)->GetPosition();
18883
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 {
18888 wxPoint * resultptr;
18889 resultptr = new wxPoint((wxPoint &)(result));
18890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18891 }
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj;
18900 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18901 wxRect result;
18902 PyObject * obj0 = 0 ;
18903 char *kwnames[] = {
18904 (char *) "self", NULL
18905 };
18906
18907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18909 if (SWIG_arg_fail(1)) SWIG_fail;
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = ((wxMoveEvent const *)arg1)->GetRect();
18913
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 {
18918 wxRect * resultptr;
18919 resultptr = new wxRect((wxRect &)(result));
18920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18921 }
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj;
18930 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18931 wxRect arg2 ;
18932 PyObject * obj0 = 0 ;
18933 PyObject * obj1 = 0 ;
18934 char *kwnames[] = {
18935 (char *) "self",(char *) "rect", NULL
18936 };
18937
18938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18940 if (SWIG_arg_fail(1)) SWIG_fail;
18941 {
18942 wxRect * argp;
18943 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18944 if (SWIG_arg_fail(2)) SWIG_fail;
18945 if (argp == NULL) {
18946 SWIG_null_ref("wxRect");
18947 }
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 arg2 = *argp;
18950 }
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 (arg1)->SetRect(arg2);
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 Py_INCREF(Py_None); resultobj = Py_None;
18959 return resultobj;
18960 fail:
18961 return NULL;
18962 }
18963
18964
18965 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18966 PyObject *resultobj;
18967 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18968 wxPoint arg2 ;
18969 PyObject * obj0 = 0 ;
18970 PyObject * obj1 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self",(char *) "pos", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 wxPoint * argp;
18980 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
18981 if (SWIG_arg_fail(2)) SWIG_fail;
18982 if (argp == NULL) {
18983 SWIG_null_ref("wxPoint");
18984 }
18985 if (SWIG_arg_fail(2)) SWIG_fail;
18986 arg2 = *argp;
18987 }
18988 {
18989 PyThreadState* __tstate = wxPyBeginAllowThreads();
18990 wxMoveEvent_SetPosition(arg1,arg2);
18991
18992 wxPyEndAllowThreads(__tstate);
18993 if (PyErr_Occurred()) SWIG_fail;
18994 }
18995 Py_INCREF(Py_None); resultobj = Py_None;
18996 return resultobj;
18997 fail:
18998 return NULL;
18999 }
19000
19001
19002 static PyObject *_wrap_MoveEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
19003 PyObject *resultobj;
19004 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19005 wxPoint *arg2 = (wxPoint *) 0 ;
19006 PyObject * obj0 = 0 ;
19007 PyObject * obj1 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "self",(char *) "m_pos", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
19013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19014 if (SWIG_arg_fail(1)) SWIG_fail;
19015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
19016 if (SWIG_arg_fail(2)) SWIG_fail;
19017 if (arg1) (arg1)->m_pos = *arg2;
19018
19019 Py_INCREF(Py_None); resultobj = Py_None;
19020 return resultobj;
19021 fail:
19022 return NULL;
19023 }
19024
19025
19026 static PyObject *_wrap_MoveEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj;
19028 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19029 wxPoint *result;
19030 PyObject * obj0 = 0 ;
19031 char *kwnames[] = {
19032 (char *) "self", NULL
19033 };
19034
19035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_pos_get",kwnames,&obj0)) goto fail;
19036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19037 if (SWIG_arg_fail(1)) SWIG_fail;
19038 result = (wxPoint *)& ((arg1)->m_pos);
19039
19040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
19041 return resultobj;
19042 fail:
19043 return NULL;
19044 }
19045
19046
19047 static PyObject *_wrap_MoveEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19048 PyObject *resultobj;
19049 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19050 wxRect *arg2 = (wxRect *) 0 ;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 char *kwnames[] = {
19054 (char *) "self",(char *) "m_rect", NULL
19055 };
19056
19057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19059 if (SWIG_arg_fail(1)) SWIG_fail;
19060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(2)) SWIG_fail;
19062 if (arg1) (arg1)->m_rect = *arg2;
19063
19064 Py_INCREF(Py_None); resultobj = Py_None;
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_MoveEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19074 wxRect *result;
19075 PyObject * obj0 = 0 ;
19076 char *kwnames[] = {
19077 (char *) "self", NULL
19078 };
19079
19080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_rect_get",kwnames,&obj0)) goto fail;
19081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 result = (wxRect *)& ((arg1)->m_rect);
19084
19085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19086 return resultobj;
19087 fail:
19088 return NULL;
19089 }
19090
19091
19092 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19093 PyObject *obj;
19094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19095 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19096 Py_INCREF(obj);
19097 return Py_BuildValue((char *)"");
19098 }
19099 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19100 PyObject *resultobj;
19101 int arg1 = (int) 0 ;
19102 wxPaintEvent *result;
19103 PyObject * obj0 = 0 ;
19104 char *kwnames[] = {
19105 (char *) "Id", NULL
19106 };
19107
19108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19109 if (obj0) {
19110 {
19111 arg1 = (int)(SWIG_As_int(obj0));
19112 if (SWIG_arg_fail(1)) SWIG_fail;
19113 }
19114 }
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19118
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19130 PyObject *obj;
19131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19132 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19133 Py_INCREF(obj);
19134 return Py_BuildValue((char *)"");
19135 }
19136 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 int arg1 = (int) 0 ;
19139 wxNcPaintEvent *result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "winid", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19146 if (obj0) {
19147 {
19148 arg1 = (int)(SWIG_As_int(obj0));
19149 if (SWIG_arg_fail(1)) SWIG_fail;
19150 }
19151 }
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19167 PyObject *obj;
19168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19169 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19170 Py_INCREF(obj);
19171 return Py_BuildValue((char *)"");
19172 }
19173 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj;
19175 int arg1 = (int) 0 ;
19176 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19177 wxEraseEvent *result;
19178 PyObject * obj0 = 0 ;
19179 PyObject * obj1 = 0 ;
19180 char *kwnames[] = {
19181 (char *) "Id",(char *) "dc", NULL
19182 };
19183
19184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19185 if (obj0) {
19186 {
19187 arg1 = (int)(SWIG_As_int(obj0));
19188 if (SWIG_arg_fail(1)) SWIG_fail;
19189 }
19190 }
19191 if (obj1) {
19192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(2)) SWIG_fail;
19194 }
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19212 wxDC *result;
19213 PyObject * obj0 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "self", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 {
19222 PyThreadState* __tstate = wxPyBeginAllowThreads();
19223 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19224
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 {
19229 resultobj = wxPyMake_wxObject(result, 0);
19230 }
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19238 PyObject *obj;
19239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19240 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19241 Py_INCREF(obj);
19242 return Py_BuildValue((char *)"");
19243 }
19244 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj;
19246 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19247 int arg2 = (int) 0 ;
19248 wxFocusEvent *result;
19249 PyObject * obj0 = 0 ;
19250 PyObject * obj1 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "type",(char *) "winid", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19256 if (obj0) {
19257 {
19258 arg1 = (wxEventType)(SWIG_As_int(obj0));
19259 if (SWIG_arg_fail(1)) SWIG_fail;
19260 }
19261 }
19262 if (obj1) {
19263 {
19264 arg2 = (int)(SWIG_As_int(obj1));
19265 if (SWIG_arg_fail(2)) SWIG_fail;
19266 }
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19283 PyObject *resultobj;
19284 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19285 wxWindow *result;
19286 PyObject * obj0 = 0 ;
19287 char *kwnames[] = {
19288 (char *) "self", NULL
19289 };
19290
19291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19293 if (SWIG_arg_fail(1)) SWIG_fail;
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19297
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = wxPyMake_wxObject(result, 0);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj;
19312 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19313 wxWindow *arg2 = (wxWindow *) 0 ;
19314 PyObject * obj0 = 0 ;
19315 PyObject * obj1 = 0 ;
19316 char *kwnames[] = {
19317 (char *) "self",(char *) "win", NULL
19318 };
19319
19320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19322 if (SWIG_arg_fail(1)) SWIG_fail;
19323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19324 if (SWIG_arg_fail(2)) SWIG_fail;
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 (arg1)->SetWindow(arg2);
19328
19329 wxPyEndAllowThreads(__tstate);
19330 if (PyErr_Occurred()) SWIG_fail;
19331 }
19332 Py_INCREF(Py_None); resultobj = Py_None;
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19340 PyObject *obj;
19341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19342 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19343 Py_INCREF(obj);
19344 return Py_BuildValue((char *)"");
19345 }
19346 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19347 PyObject *resultobj;
19348 wxWindow *arg1 = (wxWindow *) NULL ;
19349 wxChildFocusEvent *result;
19350 PyObject * obj0 = 0 ;
19351 char *kwnames[] = {
19352 (char *) "win", NULL
19353 };
19354
19355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19356 if (obj0) {
19357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(1)) SWIG_fail;
19359 }
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19363
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj;
19376 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19377 wxWindow *result;
19378 PyObject * obj0 = 0 ;
19379 char *kwnames[] = {
19380 (char *) "self", NULL
19381 };
19382
19383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19385 if (SWIG_arg_fail(1)) SWIG_fail;
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 {
19394 resultobj = wxPyMake_wxObject(result, 0);
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19403 PyObject *obj;
19404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19405 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19406 Py_INCREF(obj);
19407 return Py_BuildValue((char *)"");
19408 }
19409 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj;
19411 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19412 bool arg2 = (bool) true ;
19413 int arg3 = (int) 0 ;
19414 wxActivateEvent *result;
19415 PyObject * obj0 = 0 ;
19416 PyObject * obj1 = 0 ;
19417 PyObject * obj2 = 0 ;
19418 char *kwnames[] = {
19419 (char *) "type",(char *) "active",(char *) "Id", NULL
19420 };
19421
19422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19423 if (obj0) {
19424 {
19425 arg1 = (wxEventType)(SWIG_As_int(obj0));
19426 if (SWIG_arg_fail(1)) SWIG_fail;
19427 }
19428 }
19429 if (obj1) {
19430 {
19431 arg2 = (bool)(SWIG_As_bool(obj1));
19432 if (SWIG_arg_fail(2)) SWIG_fail;
19433 }
19434 }
19435 if (obj2) {
19436 {
19437 arg3 = (int)(SWIG_As_int(obj2));
19438 if (SWIG_arg_fail(3)) SWIG_fail;
19439 }
19440 }
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19444
19445 wxPyEndAllowThreads(__tstate);
19446 if (PyErr_Occurred()) SWIG_fail;
19447 }
19448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19456 PyObject *resultobj;
19457 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19458 bool result;
19459 PyObject * obj0 = 0 ;
19460 char *kwnames[] = {
19461 (char *) "self", NULL
19462 };
19463
19464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19466 if (SWIG_arg_fail(1)) SWIG_fail;
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19470
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 {
19475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19476 }
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19484 PyObject *obj;
19485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19486 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19487 Py_INCREF(obj);
19488 return Py_BuildValue((char *)"");
19489 }
19490 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19491 PyObject *resultobj;
19492 int arg1 = (int) 0 ;
19493 wxInitDialogEvent *result;
19494 PyObject * obj0 = 0 ;
19495 char *kwnames[] = {
19496 (char *) "Id", NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19500 if (obj0) {
19501 {
19502 arg1 = (int)(SWIG_As_int(obj0));
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 }
19505 }
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19509
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19521 PyObject *obj;
19522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19523 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19524 Py_INCREF(obj);
19525 return Py_BuildValue((char *)"");
19526 }
19527 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj;
19529 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19530 int arg2 = (int) 0 ;
19531 wxMenu *arg3 = (wxMenu *) NULL ;
19532 wxMenuEvent *result;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "type",(char *) "winid",(char *) "menu", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19541 if (obj0) {
19542 {
19543 arg1 = (wxEventType)(SWIG_As_int(obj0));
19544 if (SWIG_arg_fail(1)) SWIG_fail;
19545 }
19546 }
19547 if (obj1) {
19548 {
19549 arg2 = (int)(SWIG_As_int(obj1));
19550 if (SWIG_arg_fail(2)) SWIG_fail;
19551 }
19552 }
19553 if (obj2) {
19554 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19555 if (SWIG_arg_fail(3)) SWIG_fail;
19556 }
19557 {
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19560
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj;
19573 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19574 int result;
19575 PyObject * obj0 = 0 ;
19576 char *kwnames[] = {
19577 (char *) "self", NULL
19578 };
19579
19580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19582 if (SWIG_arg_fail(1)) SWIG_fail;
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19586
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 {
19591 resultobj = SWIG_From_int((int)(result));
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19602 bool result;
19603 PyObject * obj0 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 {
19619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj;
19629 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19630 wxMenu *result;
19631 PyObject * obj0 = 0 ;
19632 char *kwnames[] = {
19633 (char *) "self", NULL
19634 };
19635
19636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19638 if (SWIG_arg_fail(1)) SWIG_fail;
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19642
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 {
19647 resultobj = wxPyMake_wxObject(result, 0);
19648 }
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19656 PyObject *obj;
19657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19658 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19659 Py_INCREF(obj);
19660 return Py_BuildValue((char *)"");
19661 }
19662 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19665 int arg2 = (int) 0 ;
19666 wxCloseEvent *result;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "type",(char *) "winid", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19674 if (obj0) {
19675 {
19676 arg1 = (wxEventType)(SWIG_As_int(obj0));
19677 if (SWIG_arg_fail(1)) SWIG_fail;
19678 }
19679 }
19680 if (obj1) {
19681 {
19682 arg2 = (int)(SWIG_As_int(obj1));
19683 if (SWIG_arg_fail(2)) SWIG_fail;
19684 }
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19703 bool arg2 ;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 char *kwnames[] = {
19707 (char *) "self",(char *) "logOff", NULL
19708 };
19709
19710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19712 if (SWIG_arg_fail(1)) SWIG_fail;
19713 {
19714 arg2 = (bool)(SWIG_As_bool(obj1));
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 }
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 (arg1)->SetLoggingOff(arg2);
19720
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 Py_INCREF(Py_None); resultobj = Py_None;
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj;
19733 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19734 bool result;
19735 PyObject * obj0 = 0 ;
19736 char *kwnames[] = {
19737 (char *) "self", NULL
19738 };
19739
19740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19742 if (SWIG_arg_fail(1)) SWIG_fail;
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19746
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 {
19751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19752 }
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj;
19761 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19762 bool arg2 = (bool) true ;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self",(char *) "veto", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 if (obj1) {
19773 {
19774 arg2 = (bool)(SWIG_As_bool(obj1));
19775 if (SWIG_arg_fail(2)) SWIG_fail;
19776 }
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 (arg1)->Veto(arg2);
19781
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 Py_INCREF(Py_None); resultobj = Py_None;
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19793 PyObject *resultobj;
19794 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19795 bool arg2 ;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 char *kwnames[] = {
19799 (char *) "self",(char *) "canVeto", NULL
19800 };
19801
19802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19804 if (SWIG_arg_fail(1)) SWIG_fail;
19805 {
19806 arg2 = (bool)(SWIG_As_bool(obj1));
19807 if (SWIG_arg_fail(2)) SWIG_fail;
19808 }
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetCanVeto(arg2);
19812
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 Py_INCREF(Py_None); resultobj = Py_None;
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj;
19825 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19826 bool result;
19827 PyObject * obj0 = 0 ;
19828 char *kwnames[] = {
19829 (char *) "self", NULL
19830 };
19831
19832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19834 if (SWIG_arg_fail(1)) SWIG_fail;
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19838
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj;
19853 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19854 bool result;
19855 PyObject * obj0 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "self", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19862 if (SWIG_arg_fail(1)) SWIG_fail;
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19866
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 {
19871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19872 }
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19880 PyObject *obj;
19881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19882 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19883 Py_INCREF(obj);
19884 return Py_BuildValue((char *)"");
19885 }
19886 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19887 PyObject *resultobj;
19888 int arg1 = (int) 0 ;
19889 bool arg2 = (bool) false ;
19890 wxShowEvent *result;
19891 PyObject * obj0 = 0 ;
19892 PyObject * obj1 = 0 ;
19893 char *kwnames[] = {
19894 (char *) "winid",(char *) "show", NULL
19895 };
19896
19897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19898 if (obj0) {
19899 {
19900 arg1 = (int)(SWIG_As_int(obj0));
19901 if (SWIG_arg_fail(1)) SWIG_fail;
19902 }
19903 }
19904 if (obj1) {
19905 {
19906 arg2 = (bool)(SWIG_As_bool(obj1));
19907 if (SWIG_arg_fail(2)) SWIG_fail;
19908 }
19909 }
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19913
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj;
19926 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19927 bool arg2 ;
19928 PyObject * obj0 = 0 ;
19929 PyObject * obj1 = 0 ;
19930 char *kwnames[] = {
19931 (char *) "self",(char *) "show", NULL
19932 };
19933
19934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19936 if (SWIG_arg_fail(1)) SWIG_fail;
19937 {
19938 arg2 = (bool)(SWIG_As_bool(obj1));
19939 if (SWIG_arg_fail(2)) SWIG_fail;
19940 }
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 (arg1)->SetShow(arg2);
19944
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 Py_INCREF(Py_None); resultobj = Py_None;
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj;
19957 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19958 bool result;
19959 PyObject * obj0 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19970
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 {
19975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19976 }
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19984 PyObject *obj;
19985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19986 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19987 Py_INCREF(obj);
19988 return Py_BuildValue((char *)"");
19989 }
19990 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19991 PyObject *resultobj;
19992 int arg1 = (int) 0 ;
19993 bool arg2 = (bool) true ;
19994 wxIconizeEvent *result;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 char *kwnames[] = {
19998 (char *) "id",(char *) "iconized", NULL
19999 };
20000
20001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20002 if (obj0) {
20003 {
20004 arg1 = (int)(SWIG_As_int(obj0));
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 }
20007 }
20008 if (obj1) {
20009 {
20010 arg2 = (bool)(SWIG_As_bool(obj1));
20011 if (SWIG_arg_fail(2)) SWIG_fail;
20012 }
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20031 bool result;
20032 PyObject * obj0 = 0 ;
20033 char *kwnames[] = {
20034 (char *) "self", NULL
20035 };
20036
20037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20039 if (SWIG_arg_fail(1)) SWIG_fail;
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (bool)(arg1)->Iconized();
20043
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20049 }
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20057 PyObject *obj;
20058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20059 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20060 Py_INCREF(obj);
20061 return Py_BuildValue((char *)"");
20062 }
20063 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj;
20065 int arg1 = (int) 0 ;
20066 wxMaximizeEvent *result;
20067 PyObject * obj0 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "id", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20073 if (obj0) {
20074 {
20075 arg1 = (int)(SWIG_As_int(obj0));
20076 if (SWIG_arg_fail(1)) SWIG_fail;
20077 }
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20094 PyObject *obj;
20095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20096 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20097 Py_INCREF(obj);
20098 return Py_BuildValue((char *)"");
20099 }
20100 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj;
20102 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20103 wxPoint result;
20104 PyObject * obj0 = 0 ;
20105 char *kwnames[] = {
20106 (char *) "self", NULL
20107 };
20108
20109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20111 if (SWIG_arg_fail(1)) SWIG_fail;
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (arg1)->GetPosition();
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 {
20120 wxPoint * resultptr;
20121 resultptr = new wxPoint((wxPoint &)(result));
20122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20123 }
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj;
20132 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20133 int result;
20134 PyObject * obj0 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "self", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20141 if (SWIG_arg_fail(1)) SWIG_fail;
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (int)(arg1)->GetNumberOfFiles();
20145
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 {
20150 resultobj = SWIG_From_int((int)(result));
20151 }
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20159 PyObject *resultobj;
20160 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20161 PyObject *result;
20162 PyObject * obj0 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 PyThreadState* __tstate = wxPyBeginAllowThreads();
20172 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20173
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = result;
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20185 PyObject *obj;
20186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20187 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20188 Py_INCREF(obj);
20189 return Py_BuildValue((char *)"");
20190 }
20191 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 int arg1 = (int) 0 ;
20194 wxUpdateUIEvent *result;
20195 PyObject * obj0 = 0 ;
20196 char *kwnames[] = {
20197 (char *) "commandId", NULL
20198 };
20199
20200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20201 if (obj0) {
20202 {
20203 arg1 = (int)(SWIG_As_int(obj0));
20204 if (SWIG_arg_fail(1)) SWIG_fail;
20205 }
20206 }
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj;
20223 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20224 bool result;
20225 PyObject * obj0 = 0 ;
20226 char *kwnames[] = {
20227 (char *) "self", NULL
20228 };
20229
20230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20232 if (SWIG_arg_fail(1)) SWIG_fail;
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 {
20241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20242 }
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj;
20251 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20252 bool result;
20253 PyObject * obj0 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20270 }
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20278 PyObject *resultobj;
20279 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20280 wxString result;
20281 PyObject * obj0 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 PyThreadState* __tstate = wxPyBeginAllowThreads();
20291 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20292
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 {
20297 #if wxUSE_UNICODE
20298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20299 #else
20300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20301 #endif
20302 }
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20312 bool result;
20313 PyObject * obj0 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "self", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20320 if (SWIG_arg_fail(1)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20330 }
20331 return resultobj;
20332 fail:
20333 return NULL;
20334 }
20335
20336
20337 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20338 PyObject *resultobj;
20339 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20340 bool result;
20341 PyObject * obj0 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20358 }
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20368 bool result;
20369 PyObject * obj0 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20380
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20386 }
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj;
20395 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20396 bool arg2 ;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 char *kwnames[] = {
20400 (char *) "self",(char *) "check", NULL
20401 };
20402
20403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20405 if (SWIG_arg_fail(1)) SWIG_fail;
20406 {
20407 arg2 = (bool)(SWIG_As_bool(obj1));
20408 if (SWIG_arg_fail(2)) SWIG_fail;
20409 }
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 (arg1)->Check(arg2);
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 Py_INCREF(Py_None); resultobj = Py_None;
20418 return resultobj;
20419 fail:
20420 return NULL;
20421 }
20422
20423
20424 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj;
20426 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20427 bool arg2 ;
20428 PyObject * obj0 = 0 ;
20429 PyObject * obj1 = 0 ;
20430 char *kwnames[] = {
20431 (char *) "self",(char *) "enable", NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(1)) SWIG_fail;
20437 {
20438 arg2 = (bool)(SWIG_As_bool(obj1));
20439 if (SWIG_arg_fail(2)) SWIG_fail;
20440 }
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 (arg1)->Enable(arg2);
20444
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 Py_INCREF(Py_None); resultobj = Py_None;
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj;
20457 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20458 wxString *arg2 = 0 ;
20459 bool temp2 = false ;
20460 PyObject * obj0 = 0 ;
20461 PyObject * obj1 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "self",(char *) "text", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 {
20470 arg2 = wxString_in_helper(obj1);
20471 if (arg2 == NULL) SWIG_fail;
20472 temp2 = true;
20473 }
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 (arg1)->SetText((wxString const &)*arg2);
20477
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 Py_INCREF(Py_None); resultobj = Py_None;
20482 {
20483 if (temp2)
20484 delete arg2;
20485 }
20486 return resultobj;
20487 fail:
20488 {
20489 if (temp2)
20490 delete arg2;
20491 }
20492 return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj;
20498 long arg1 ;
20499 PyObject * obj0 = 0 ;
20500 char *kwnames[] = {
20501 (char *) "updateInterval", NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20505 {
20506 arg1 = (long)(SWIG_As_long(obj0));
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 }
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 wxUpdateUIEvent::SetUpdateInterval(arg1);
20512
20513 wxPyEndAllowThreads(__tstate);
20514 if (PyErr_Occurred()) SWIG_fail;
20515 }
20516 Py_INCREF(Py_None); resultobj = Py_None;
20517 return resultobj;
20518 fail:
20519 return NULL;
20520 }
20521
20522
20523 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20524 PyObject *resultobj;
20525 long result;
20526 char *kwnames[] = {
20527 NULL
20528 };
20529
20530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = SWIG_From_long((long)(result));
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxWindow *arg1 = (wxWindow *) 0 ;
20550 bool result;
20551 PyObject * obj0 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "win", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20576 PyObject *resultobj;
20577 char *kwnames[] = {
20578 NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 wxUpdateUIEvent::ResetUpdateTime();
20585
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 Py_INCREF(Py_None); resultobj = Py_None;
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj;
20598 wxUpdateUIMode arg1 ;
20599 PyObject * obj0 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "mode", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20605 {
20606 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20607 if (SWIG_arg_fail(1)) SWIG_fail;
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 Py_INCREF(Py_None); resultobj = Py_None;
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20624 PyObject *resultobj;
20625 wxUpdateUIMode result;
20626 char *kwnames[] = {
20627 NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20634
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 resultobj = SWIG_From_int((result));
20639 return resultobj;
20640 fail:
20641 return NULL;
20642 }
20643
20644
20645 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20646 PyObject *obj;
20647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20648 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20649 Py_INCREF(obj);
20650 return Py_BuildValue((char *)"");
20651 }
20652 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj;
20654 wxSysColourChangedEvent *result;
20655 char *kwnames[] = {
20656 NULL
20657 };
20658
20659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20663
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20675 PyObject *obj;
20676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20677 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20678 Py_INCREF(obj);
20679 return Py_BuildValue((char *)"");
20680 }
20681 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20682 PyObject *resultobj;
20683 int arg1 = (int) 0 ;
20684 wxWindow *arg2 = (wxWindow *) NULL ;
20685 wxMouseCaptureChangedEvent *result;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "winid",(char *) "gainedCapture", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20693 if (obj0) {
20694 {
20695 arg1 = (int)(SWIG_As_int(obj0));
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 }
20698 }
20699 if (obj1) {
20700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20701 if (SWIG_arg_fail(2)) SWIG_fail;
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20706
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20718 PyObject *resultobj;
20719 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20720 wxWindow *result;
20721 PyObject * obj0 = 0 ;
20722 char *kwnames[] = {
20723 (char *) "self", NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(1)) SWIG_fail;
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = wxPyMake_wxObject(result, 0);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20746 PyObject *obj;
20747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20748 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20749 Py_INCREF(obj);
20750 return Py_BuildValue((char *)"");
20751 }
20752 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20753 PyObject *resultobj;
20754 wxDisplayChangedEvent *result;
20755 char *kwnames[] = {
20756 NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20763
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20775 PyObject *obj;
20776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20777 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20778 Py_INCREF(obj);
20779 return Py_BuildValue((char *)"");
20780 }
20781 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20782 PyObject *resultobj;
20783 int arg1 = (int) 0 ;
20784 wxPaletteChangedEvent *result;
20785 PyObject * obj0 = 0 ;
20786 char *kwnames[] = {
20787 (char *) "id", NULL
20788 };
20789
20790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20791 if (obj0) {
20792 {
20793 arg1 = (int)(SWIG_As_int(obj0));
20794 if (SWIG_arg_fail(1)) SWIG_fail;
20795 }
20796 }
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20800
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20812 PyObject *resultobj;
20813 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20814 wxWindow *arg2 = (wxWindow *) 0 ;
20815 PyObject * obj0 = 0 ;
20816 PyObject * obj1 = 0 ;
20817 char *kwnames[] = {
20818 (char *) "self",(char *) "win", NULL
20819 };
20820
20821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20823 if (SWIG_arg_fail(1)) SWIG_fail;
20824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(2)) SWIG_fail;
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 (arg1)->SetChangedWindow(arg2);
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 Py_INCREF(Py_None); resultobj = Py_None;
20834 return resultobj;
20835 fail:
20836 return NULL;
20837 }
20838
20839
20840 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20841 PyObject *resultobj;
20842 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20843 wxWindow *result;
20844 PyObject * obj0 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "self", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20851 if (SWIG_arg_fail(1)) SWIG_fail;
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (wxWindow *)(arg1)->GetChangedWindow();
20855
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 resultobj = wxPyMake_wxObject(result, 0);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20869 PyObject *obj;
20870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20871 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20872 Py_INCREF(obj);
20873 return Py_BuildValue((char *)"");
20874 }
20875 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 int arg1 = (int) 0 ;
20878 wxQueryNewPaletteEvent *result;
20879 PyObject * obj0 = 0 ;
20880 char *kwnames[] = {
20881 (char *) "winid", NULL
20882 };
20883
20884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20885 if (obj0) {
20886 {
20887 arg1 = (int)(SWIG_As_int(obj0));
20888 if (SWIG_arg_fail(1)) SWIG_fail;
20889 }
20890 }
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20894
20895 wxPyEndAllowThreads(__tstate);
20896 if (PyErr_Occurred()) SWIG_fail;
20897 }
20898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj;
20907 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20908 bool arg2 ;
20909 PyObject * obj0 = 0 ;
20910 PyObject * obj1 = 0 ;
20911 char *kwnames[] = {
20912 (char *) "self",(char *) "realized", NULL
20913 };
20914
20915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20917 if (SWIG_arg_fail(1)) SWIG_fail;
20918 {
20919 arg2 = (bool)(SWIG_As_bool(obj1));
20920 if (SWIG_arg_fail(2)) SWIG_fail;
20921 }
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 (arg1)->SetPaletteRealized(arg2);
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 Py_INCREF(Py_None); resultobj = Py_None;
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20937 PyObject *resultobj;
20938 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20939 bool result;
20940 PyObject * obj0 = 0 ;
20941 char *kwnames[] = {
20942 (char *) "self", NULL
20943 };
20944
20945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20947 if (SWIG_arg_fail(1)) SWIG_fail;
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20951
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20965 PyObject *obj;
20966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20967 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20968 Py_INCREF(obj);
20969 return Py_BuildValue((char *)"");
20970 }
20971 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20972 PyObject *resultobj;
20973 wxNavigationKeyEvent *result;
20974 char *kwnames[] = {
20975 NULL
20976 };
20977
20978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20982
20983 wxPyEndAllowThreads(__tstate);
20984 if (PyErr_Occurred()) SWIG_fail;
20985 }
20986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj;
20995 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20996 bool result;
20997 PyObject * obj0 = 0 ;
20998 char *kwnames[] = {
20999 (char *) "self", NULL
21000 };
21001
21002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21004 if (SWIG_arg_fail(1)) SWIG_fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21008
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 {
21013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21014 }
21015 return resultobj;
21016 fail:
21017 return NULL;
21018 }
21019
21020
21021 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21022 PyObject *resultobj;
21023 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21024 bool arg2 ;
21025 PyObject * obj0 = 0 ;
21026 PyObject * obj1 = 0 ;
21027 char *kwnames[] = {
21028 (char *) "self",(char *) "forward", NULL
21029 };
21030
21031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21033 if (SWIG_arg_fail(1)) SWIG_fail;
21034 {
21035 arg2 = (bool)(SWIG_As_bool(obj1));
21036 if (SWIG_arg_fail(2)) SWIG_fail;
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 (arg1)->SetDirection(arg2);
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 Py_INCREF(Py_None); resultobj = Py_None;
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj;
21054 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21055 bool result;
21056 PyObject * obj0 = 0 ;
21057 char *kwnames[] = {
21058 (char *) "self", NULL
21059 };
21060
21061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21063 if (SWIG_arg_fail(1)) SWIG_fail;
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21067
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 {
21072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21073 }
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj;
21082 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21083 bool arg2 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 char *kwnames[] = {
21087 (char *) "self",(char *) "ischange", NULL
21088 };
21089
21090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21092 if (SWIG_arg_fail(1)) SWIG_fail;
21093 {
21094 arg2 = (bool)(SWIG_As_bool(obj1));
21095 if (SWIG_arg_fail(2)) SWIG_fail;
21096 }
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 (arg1)->SetWindowChange(arg2);
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 Py_INCREF(Py_None); resultobj = Py_None;
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21114 long arg2 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char *kwnames[] = {
21118 (char *) "self",(char *) "flags", NULL
21119 };
21120
21121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21123 if (SWIG_arg_fail(1)) SWIG_fail;
21124 {
21125 arg2 = (long)(SWIG_As_long(obj1));
21126 if (SWIG_arg_fail(2)) SWIG_fail;
21127 }
21128 {
21129 PyThreadState* __tstate = wxPyBeginAllowThreads();
21130 (arg1)->SetFlags(arg2);
21131
21132 wxPyEndAllowThreads(__tstate);
21133 if (PyErr_Occurred()) SWIG_fail;
21134 }
21135 Py_INCREF(Py_None); resultobj = Py_None;
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21145 wxWindow *result;
21146 PyObject * obj0 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21157
21158 wxPyEndAllowThreads(__tstate);
21159 if (PyErr_Occurred()) SWIG_fail;
21160 }
21161 {
21162 resultobj = wxPyMake_wxObject(result, 0);
21163 }
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21173 wxWindow *arg2 = (wxWindow *) 0 ;
21174 PyObject * obj0 = 0 ;
21175 PyObject * obj1 = 0 ;
21176 char *kwnames[] = {
21177 (char *) "self",(char *) "win", NULL
21178 };
21179
21180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21182 if (SWIG_arg_fail(1)) SWIG_fail;
21183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21184 if (SWIG_arg_fail(2)) SWIG_fail;
21185 {
21186 PyThreadState* __tstate = wxPyBeginAllowThreads();
21187 (arg1)->SetCurrentFocus(arg2);
21188
21189 wxPyEndAllowThreads(__tstate);
21190 if (PyErr_Occurred()) SWIG_fail;
21191 }
21192 Py_INCREF(Py_None); resultobj = Py_None;
21193 return resultobj;
21194 fail:
21195 return NULL;
21196 }
21197
21198
21199 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21200 PyObject *obj;
21201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21202 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21203 Py_INCREF(obj);
21204 return Py_BuildValue((char *)"");
21205 }
21206 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxWindow *arg1 = (wxWindow *) NULL ;
21209 wxWindowCreateEvent *result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "win", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21216 if (obj0) {
21217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21218 if (SWIG_arg_fail(1)) SWIG_fail;
21219 }
21220 {
21221 PyThreadState* __tstate = wxPyBeginAllowThreads();
21222 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21223
21224 wxPyEndAllowThreads(__tstate);
21225 if (PyErr_Occurred()) SWIG_fail;
21226 }
21227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21237 wxWindow *result;
21238 PyObject * obj0 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = wxPyMake_wxObject(result, 0);
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21263 PyObject *obj;
21264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21265 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21266 Py_INCREF(obj);
21267 return Py_BuildValue((char *)"");
21268 }
21269 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 wxWindow *arg1 = (wxWindow *) NULL ;
21272 wxWindowDestroyEvent *result;
21273 PyObject * obj0 = 0 ;
21274 char *kwnames[] = {
21275 (char *) "win", NULL
21276 };
21277
21278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21279 if (obj0) {
21280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21281 if (SWIG_arg_fail(1)) SWIG_fail;
21282 }
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21286
21287 wxPyEndAllowThreads(__tstate);
21288 if (PyErr_Occurred()) SWIG_fail;
21289 }
21290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj;
21299 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21300 wxWindow *result;
21301 PyObject * obj0 = 0 ;
21302 char *kwnames[] = {
21303 (char *) "self", NULL
21304 };
21305
21306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21308 if (SWIG_arg_fail(1)) SWIG_fail;
21309 {
21310 PyThreadState* __tstate = wxPyBeginAllowThreads();
21311 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21312
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = wxPyMake_wxObject(result, 0);
21318 }
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21326 PyObject *obj;
21327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21328 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21329 Py_INCREF(obj);
21330 return Py_BuildValue((char *)"");
21331 }
21332 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj;
21334 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21335 int arg2 = (int) 0 ;
21336 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21337 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21338 wxContextMenuEvent *result;
21339 wxPoint temp3 ;
21340 PyObject * obj0 = 0 ;
21341 PyObject * obj1 = 0 ;
21342 PyObject * obj2 = 0 ;
21343 char *kwnames[] = {
21344 (char *) "type",(char *) "winid",(char *) "pt", NULL
21345 };
21346
21347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21348 if (obj0) {
21349 {
21350 arg1 = (wxEventType)(SWIG_As_int(obj0));
21351 if (SWIG_arg_fail(1)) SWIG_fail;
21352 }
21353 }
21354 if (obj1) {
21355 {
21356 arg2 = (int)(SWIG_As_int(obj1));
21357 if (SWIG_arg_fail(2)) SWIG_fail;
21358 }
21359 }
21360 if (obj2) {
21361 {
21362 arg3 = &temp3;
21363 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21369
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21374 return resultobj;
21375 fail:
21376 return NULL;
21377 }
21378
21379
21380 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj;
21382 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21383 wxPoint *result;
21384 PyObject * obj0 = 0 ;
21385 char *kwnames[] = {
21386 (char *) "self", NULL
21387 };
21388
21389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21391 if (SWIG_arg_fail(1)) SWIG_fail;
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 {
21395 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21396 result = (wxPoint *) &_result_ref;
21397 }
21398
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj;
21411 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21412 wxPoint *arg2 = 0 ;
21413 wxPoint temp2 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self",(char *) "pos", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 arg2 = &temp2;
21425 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21426 }
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 (arg1)->SetPosition((wxPoint const &)*arg2);
21430
21431 wxPyEndAllowThreads(__tstate);
21432 if (PyErr_Occurred()) SWIG_fail;
21433 }
21434 Py_INCREF(Py_None); resultobj = Py_None;
21435 return resultobj;
21436 fail:
21437 return NULL;
21438 }
21439
21440
21441 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21442 PyObject *obj;
21443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21444 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21445 Py_INCREF(obj);
21446 return Py_BuildValue((char *)"");
21447 }
21448 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj;
21450 wxIdleEvent *result;
21451 char *kwnames[] = {
21452 NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21456 {
21457 PyThreadState* __tstate = wxPyBeginAllowThreads();
21458 result = (wxIdleEvent *)new wxIdleEvent();
21459
21460 wxPyEndAllowThreads(__tstate);
21461 if (PyErr_Occurred()) SWIG_fail;
21462 }
21463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj;
21472 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21473 bool arg2 = (bool) true ;
21474 PyObject * obj0 = 0 ;
21475 PyObject * obj1 = 0 ;
21476 char *kwnames[] = {
21477 (char *) "self",(char *) "needMore", NULL
21478 };
21479
21480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21482 if (SWIG_arg_fail(1)) SWIG_fail;
21483 if (obj1) {
21484 {
21485 arg2 = (bool)(SWIG_As_bool(obj1));
21486 if (SWIG_arg_fail(2)) SWIG_fail;
21487 }
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 (arg1)->RequestMore(arg2);
21492
21493 wxPyEndAllowThreads(__tstate);
21494 if (PyErr_Occurred()) SWIG_fail;
21495 }
21496 Py_INCREF(Py_None); resultobj = Py_None;
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21504 PyObject *resultobj;
21505 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21506 bool result;
21507 PyObject * obj0 = 0 ;
21508 char *kwnames[] = {
21509 (char *) "self", NULL
21510 };
21511
21512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21514 if (SWIG_arg_fail(1)) SWIG_fail;
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21518
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 {
21523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21524 }
21525 return resultobj;
21526 fail:
21527 return NULL;
21528 }
21529
21530
21531 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21532 PyObject *resultobj;
21533 wxIdleMode arg1 ;
21534 PyObject * obj0 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "mode", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21540 {
21541 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21542 if (SWIG_arg_fail(1)) SWIG_fail;
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 wxIdleEvent::SetMode((wxIdleMode )arg1);
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 Py_INCREF(Py_None); resultobj = Py_None;
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj;
21560 wxIdleMode result;
21561 char *kwnames[] = {
21562 NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 result = (wxIdleMode)wxIdleEvent::GetMode();
21569
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 resultobj = SWIG_From_int((result));
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21581 PyObject *resultobj;
21582 wxWindow *arg1 = (wxWindow *) 0 ;
21583 bool result;
21584 PyObject * obj0 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "win", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (bool)wxIdleEvent::CanSend(arg1);
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 {
21600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21601 }
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21609 PyObject *obj;
21610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21611 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21612 Py_INCREF(obj);
21613 return Py_BuildValue((char *)"");
21614 }
21615 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21616 PyObject *resultobj;
21617 int arg1 = (int) 0 ;
21618 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21619 wxPyEvent *result;
21620 PyObject * obj0 = 0 ;
21621 PyObject * obj1 = 0 ;
21622 char *kwnames[] = {
21623 (char *) "winid",(char *) "commandType", NULL
21624 };
21625
21626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21627 if (obj0) {
21628 {
21629 arg1 = (int)(SWIG_As_int(obj0));
21630 if (SWIG_arg_fail(1)) SWIG_fail;
21631 }
21632 }
21633 if (obj1) {
21634 {
21635 arg2 = (wxEventType)(SWIG_As_int(obj1));
21636 if (SWIG_arg_fail(2)) SWIG_fail;
21637 }
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21654 PyObject *resultobj;
21655 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21656 PyObject * obj0 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "self", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21663 if (SWIG_arg_fail(1)) SWIG_fail;
21664 {
21665 PyThreadState* __tstate = wxPyBeginAllowThreads();
21666 delete arg1;
21667
21668 wxPyEndAllowThreads(__tstate);
21669 if (PyErr_Occurred()) SWIG_fail;
21670 }
21671 Py_INCREF(Py_None); resultobj = Py_None;
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj;
21680 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21681 PyObject *arg2 = (PyObject *) 0 ;
21682 PyObject * obj0 = 0 ;
21683 PyObject * obj1 = 0 ;
21684 char *kwnames[] = {
21685 (char *) "self",(char *) "self", NULL
21686 };
21687
21688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21690 if (SWIG_arg_fail(1)) SWIG_fail;
21691 arg2 = obj1;
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 (arg1)->SetSelf(arg2);
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 Py_INCREF(Py_None); resultobj = Py_None;
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21709 PyObject *result;
21710 PyObject * obj0 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (PyObject *)(arg1)->GetSelf();
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 resultobj = result;
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21733 PyObject *obj;
21734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21735 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21736 Py_INCREF(obj);
21737 return Py_BuildValue((char *)"");
21738 }
21739 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj;
21741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21742 int arg2 = (int) 0 ;
21743 wxPyCommandEvent *result;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "commandType",(char *) "id", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21751 if (obj0) {
21752 {
21753 arg1 = (wxEventType)(SWIG_As_int(obj0));
21754 if (SWIG_arg_fail(1)) SWIG_fail;
21755 }
21756 }
21757 if (obj1) {
21758 {
21759 arg2 = (int)(SWIG_As_int(obj1));
21760 if (SWIG_arg_fail(2)) SWIG_fail;
21761 }
21762 }
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21780 PyObject * obj0 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 delete arg1;
21791
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 Py_INCREF(Py_None); resultobj = Py_None;
21796 return resultobj;
21797 fail:
21798 return NULL;
21799 }
21800
21801
21802 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21803 PyObject *resultobj;
21804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21805 PyObject *arg2 = (PyObject *) 0 ;
21806 PyObject * obj0 = 0 ;
21807 PyObject * obj1 = 0 ;
21808 char *kwnames[] = {
21809 (char *) "self",(char *) "self", NULL
21810 };
21811
21812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21814 if (SWIG_arg_fail(1)) SWIG_fail;
21815 arg2 = obj1;
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 (arg1)->SetSelf(arg2);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 Py_INCREF(Py_None); resultobj = Py_None;
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21833 PyObject *result;
21834 PyObject * obj0 = 0 ;
21835 char *kwnames[] = {
21836 (char *) "self", NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21841 if (SWIG_arg_fail(1)) SWIG_fail;
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 result = (PyObject *)(arg1)->GetSelf();
21845
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 resultobj = result;
21850 return resultobj;
21851 fail:
21852 return NULL;
21853 }
21854
21855
21856 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21857 PyObject *obj;
21858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21859 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21860 Py_INCREF(obj);
21861 return Py_BuildValue((char *)"");
21862 }
21863 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj;
21865 wxPyApp *result;
21866 char *kwnames[] = {
21867 NULL
21868 };
21869
21870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxPyApp *)new_wxPyApp();
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxPyApp *arg1 = (wxPyApp *) 0 ;
21888 PyObject * obj0 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 delete arg1;
21899
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 Py_INCREF(Py_None); resultobj = Py_None;
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21911 PyObject *resultobj;
21912 wxPyApp *arg1 = (wxPyApp *) 0 ;
21913 PyObject *arg2 = (PyObject *) 0 ;
21914 PyObject *arg3 = (PyObject *) 0 ;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 PyObject * obj2 = 0 ;
21918 char *kwnames[] = {
21919 (char *) "self",(char *) "self",(char *) "_class", NULL
21920 };
21921
21922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21924 if (SWIG_arg_fail(1)) SWIG_fail;
21925 arg2 = obj1;
21926 arg3 = obj2;
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 (arg1)->_setCallbackInfo(arg2,arg3);
21930
21931 wxPyEndAllowThreads(__tstate);
21932 if (PyErr_Occurred()) SWIG_fail;
21933 }
21934 Py_INCREF(Py_None); resultobj = Py_None;
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21942 PyObject *resultobj;
21943 wxPyApp *arg1 = (wxPyApp *) 0 ;
21944 wxString result;
21945 PyObject * obj0 = 0 ;
21946 char *kwnames[] = {
21947 (char *) "self", NULL
21948 };
21949
21950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21952 if (SWIG_arg_fail(1)) SWIG_fail;
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = ((wxPyApp const *)arg1)->GetAppName();
21956
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 #if wxUSE_UNICODE
21962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21963 #else
21964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21965 #endif
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxPyApp *arg1 = (wxPyApp *) 0 ;
21976 wxString *arg2 = 0 ;
21977 bool temp2 = false ;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "name", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 {
21988 arg2 = wxString_in_helper(obj1);
21989 if (arg2 == NULL) SWIG_fail;
21990 temp2 = true;
21991 }
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 (arg1)->SetAppName((wxString const &)*arg2);
21995
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 Py_INCREF(Py_None); resultobj = Py_None;
22000 {
22001 if (temp2)
22002 delete arg2;
22003 }
22004 return resultobj;
22005 fail:
22006 {
22007 if (temp2)
22008 delete arg2;
22009 }
22010 return NULL;
22011 }
22012
22013
22014 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22015 PyObject *resultobj;
22016 wxPyApp *arg1 = (wxPyApp *) 0 ;
22017 wxString result;
22018 PyObject * obj0 = 0 ;
22019 char *kwnames[] = {
22020 (char *) "self", NULL
22021 };
22022
22023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(1)) SWIG_fail;
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = ((wxPyApp const *)arg1)->GetClassName();
22029
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 #if wxUSE_UNICODE
22035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22036 #else
22037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22038 #endif
22039 }
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxPyApp *arg1 = (wxPyApp *) 0 ;
22049 wxString *arg2 = 0 ;
22050 bool temp2 = false ;
22051 PyObject * obj0 = 0 ;
22052 PyObject * obj1 = 0 ;
22053 char *kwnames[] = {
22054 (char *) "self",(char *) "name", NULL
22055 };
22056
22057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22059 if (SWIG_arg_fail(1)) SWIG_fail;
22060 {
22061 arg2 = wxString_in_helper(obj1);
22062 if (arg2 == NULL) SWIG_fail;
22063 temp2 = true;
22064 }
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 (arg1)->SetClassName((wxString const &)*arg2);
22068
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 Py_INCREF(Py_None); resultobj = Py_None;
22073 {
22074 if (temp2)
22075 delete arg2;
22076 }
22077 return resultobj;
22078 fail:
22079 {
22080 if (temp2)
22081 delete arg2;
22082 }
22083 return NULL;
22084 }
22085
22086
22087 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22088 PyObject *resultobj;
22089 wxPyApp *arg1 = (wxPyApp *) 0 ;
22090 wxString *result;
22091 PyObject * obj0 = 0 ;
22092 char *kwnames[] = {
22093 (char *) "self", NULL
22094 };
22095
22096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22098 if (SWIG_arg_fail(1)) SWIG_fail;
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 {
22102 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22103 result = (wxString *) &_result_ref;
22104 }
22105
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 #if wxUSE_UNICODE
22111 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22112 #else
22113 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22114 #endif
22115 }
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj;
22124 wxPyApp *arg1 = (wxPyApp *) 0 ;
22125 wxString *arg2 = 0 ;
22126 bool temp2 = false ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 char *kwnames[] = {
22130 (char *) "self",(char *) "name", NULL
22131 };
22132
22133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22135 if (SWIG_arg_fail(1)) SWIG_fail;
22136 {
22137 arg2 = wxString_in_helper(obj1);
22138 if (arg2 == NULL) SWIG_fail;
22139 temp2 = true;
22140 }
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 (arg1)->SetVendorName((wxString const &)*arg2);
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 Py_INCREF(Py_None); resultobj = Py_None;
22149 {
22150 if (temp2)
22151 delete arg2;
22152 }
22153 return resultobj;
22154 fail:
22155 {
22156 if (temp2)
22157 delete arg2;
22158 }
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj;
22165 wxPyApp *arg1 = (wxPyApp *) 0 ;
22166 wxAppTraits *result;
22167 PyObject * obj0 = 0 ;
22168 char *kwnames[] = {
22169 (char *) "self", NULL
22170 };
22171
22172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22174 if (SWIG_arg_fail(1)) SWIG_fail;
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 result = (wxAppTraits *)(arg1)->GetTraits();
22178
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxPyApp *arg1 = (wxPyApp *) 0 ;
22192 PyObject * obj0 = 0 ;
22193 char *kwnames[] = {
22194 (char *) "self", NULL
22195 };
22196
22197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22199 if (SWIG_arg_fail(1)) SWIG_fail;
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 (arg1)->ProcessPendingEvents();
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 Py_INCREF(Py_None); resultobj = Py_None;
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj;
22216 wxPyApp *arg1 = (wxPyApp *) 0 ;
22217 bool arg2 = (bool) false ;
22218 bool result;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "self",(char *) "onlyIfNeeded", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 if (obj1) {
22229 {
22230 arg2 = (bool)(SWIG_As_bool(obj1));
22231 if (SWIG_arg_fail(2)) SWIG_fail;
22232 }
22233 }
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (bool)(arg1)->Yield(arg2);
22237
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 {
22242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22243 }
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22251 PyObject *resultobj;
22252 wxPyApp *arg1 = (wxPyApp *) 0 ;
22253 PyObject * obj0 = 0 ;
22254 char *kwnames[] = {
22255 (char *) "self", NULL
22256 };
22257
22258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22260 if (SWIG_arg_fail(1)) SWIG_fail;
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 (arg1)->WakeUpIdle();
22264
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 Py_INCREF(Py_None); resultobj = Py_None;
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj;
22277 bool result;
22278 char *kwnames[] = {
22279 NULL
22280 };
22281
22282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (bool)wxPyApp::IsMainLoopRunning();
22286
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxPyApp *arg1 = (wxPyApp *) 0 ;
22302 int result;
22303 PyObject * obj0 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (int)(arg1)->MainLoop();
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = SWIG_From_int((int)(result));
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj;
22329 wxPyApp *arg1 = (wxPyApp *) 0 ;
22330 PyObject * obj0 = 0 ;
22331 char *kwnames[] = {
22332 (char *) "self", NULL
22333 };
22334
22335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22337 if (SWIG_arg_fail(1)) SWIG_fail;
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 (arg1)->Exit();
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 Py_INCREF(Py_None); resultobj = Py_None;
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxPyApp *arg1 = (wxPyApp *) 0 ;
22355 PyObject * obj0 = 0 ;
22356 char *kwnames[] = {
22357 (char *) "self", NULL
22358 };
22359
22360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22362 if (SWIG_arg_fail(1)) SWIG_fail;
22363 {
22364 PyThreadState* __tstate = wxPyBeginAllowThreads();
22365 (arg1)->ExitMainLoop();
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 Py_INCREF(Py_None); resultobj = Py_None;
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22378 PyObject *resultobj;
22379 wxPyApp *arg1 = (wxPyApp *) 0 ;
22380 bool result;
22381 PyObject * obj0 = 0 ;
22382 char *kwnames[] = {
22383 (char *) "self", NULL
22384 };
22385
22386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22388 if (SWIG_arg_fail(1)) SWIG_fail;
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)(arg1)->Pending();
22392
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 {
22397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22398 }
22399 return resultobj;
22400 fail:
22401 return NULL;
22402 }
22403
22404
22405 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22406 PyObject *resultobj;
22407 wxPyApp *arg1 = (wxPyApp *) 0 ;
22408 bool result;
22409 PyObject * obj0 = 0 ;
22410 char *kwnames[] = {
22411 (char *) "self", NULL
22412 };
22413
22414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22416 if (SWIG_arg_fail(1)) SWIG_fail;
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = (bool)(arg1)->Dispatch();
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 {
22425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22426 }
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22434 PyObject *resultobj;
22435 wxPyApp *arg1 = (wxPyApp *) 0 ;
22436 bool result;
22437 PyObject * obj0 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 result = (bool)(arg1)->ProcessIdle();
22448
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 {
22453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22454 }
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxPyApp *arg1 = (wxPyApp *) 0 ;
22464 wxWindow *arg2 = (wxWindow *) 0 ;
22465 wxIdleEvent *arg3 = 0 ;
22466 bool result;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 PyObject * obj2 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self",(char *) "win",(char *) "event", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(2)) SWIG_fail;
22479 {
22480 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22481 if (SWIG_arg_fail(3)) SWIG_fail;
22482 if (arg3 == NULL) {
22483 SWIG_null_ref("wxIdleEvent");
22484 }
22485 if (SWIG_arg_fail(3)) SWIG_fail;
22486 }
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22490
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 {
22495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22496 }
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxPyApp *arg1 = (wxPyApp *) 0 ;
22506 bool result;
22507 PyObject * obj0 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "self", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 result = (bool)((wxPyApp const *)arg1)->IsActive();
22518
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 {
22523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22524 }
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22532 PyObject *resultobj;
22533 wxPyApp *arg1 = (wxPyApp *) 0 ;
22534 wxWindow *arg2 = (wxWindow *) 0 ;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 char *kwnames[] = {
22538 (char *) "self",(char *) "win", NULL
22539 };
22540
22541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(1)) SWIG_fail;
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 (arg1)->SetTopWindow(arg2);
22549
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 Py_INCREF(Py_None); resultobj = Py_None;
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 wxWindow *result;
22564 PyObject * obj0 = 0 ;
22565 char *kwnames[] = {
22566 (char *) "self", NULL
22567 };
22568
22569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22571 if (SWIG_arg_fail(1)) SWIG_fail;
22572 {
22573 PyThreadState* __tstate = wxPyBeginAllowThreads();
22574 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 {
22580 resultobj = wxPyMake_wxObject(result, 0);
22581 }
22582 return resultobj;
22583 fail:
22584 return NULL;
22585 }
22586
22587
22588 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22589 PyObject *resultobj;
22590 wxPyApp *arg1 = (wxPyApp *) 0 ;
22591 bool arg2 ;
22592 PyObject * obj0 = 0 ;
22593 PyObject * obj1 = 0 ;
22594 char *kwnames[] = {
22595 (char *) "self",(char *) "flag", NULL
22596 };
22597
22598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(1)) SWIG_fail;
22601 {
22602 arg2 = (bool)(SWIG_As_bool(obj1));
22603 if (SWIG_arg_fail(2)) SWIG_fail;
22604 }
22605 {
22606 PyThreadState* __tstate = wxPyBeginAllowThreads();
22607 (arg1)->SetExitOnFrameDelete(arg2);
22608
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 Py_INCREF(Py_None); resultobj = Py_None;
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22620 PyObject *resultobj;
22621 wxPyApp *arg1 = (wxPyApp *) 0 ;
22622 bool result;
22623 PyObject * obj0 = 0 ;
22624 char *kwnames[] = {
22625 (char *) "self", NULL
22626 };
22627
22628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22630 if (SWIG_arg_fail(1)) SWIG_fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 {
22639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22640 }
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22648 PyObject *resultobj;
22649 wxPyApp *arg1 = (wxPyApp *) 0 ;
22650 bool arg2 ;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653 char *kwnames[] = {
22654 (char *) "self",(char *) "flag", NULL
22655 };
22656
22657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 arg2 = (bool)(SWIG_As_bool(obj1));
22662 if (SWIG_arg_fail(2)) SWIG_fail;
22663 }
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 (arg1)->SetUseBestVisual(arg2);
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 Py_INCREF(Py_None); resultobj = Py_None;
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22679 PyObject *resultobj;
22680 wxPyApp *arg1 = (wxPyApp *) 0 ;
22681 bool result;
22682 PyObject * obj0 = 0 ;
22683 char *kwnames[] = {
22684 (char *) "self", NULL
22685 };
22686
22687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22689 if (SWIG_arg_fail(1)) SWIG_fail;
22690 {
22691 PyThreadState* __tstate = wxPyBeginAllowThreads();
22692 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22693
22694 wxPyEndAllowThreads(__tstate);
22695 if (PyErr_Occurred()) SWIG_fail;
22696 }
22697 {
22698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22699 }
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22707 PyObject *resultobj;
22708 wxPyApp *arg1 = (wxPyApp *) 0 ;
22709 int arg2 ;
22710 PyObject * obj0 = 0 ;
22711 PyObject * obj1 = 0 ;
22712 char *kwnames[] = {
22713 (char *) "self",(char *) "mode", NULL
22714 };
22715
22716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22718 if (SWIG_arg_fail(1)) SWIG_fail;
22719 {
22720 arg2 = (int)(SWIG_As_int(obj1));
22721 if (SWIG_arg_fail(2)) SWIG_fail;
22722 }
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 (arg1)->SetPrintMode(arg2);
22726
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 Py_INCREF(Py_None); resultobj = Py_None;
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22738 PyObject *resultobj;
22739 wxPyApp *arg1 = (wxPyApp *) 0 ;
22740 int result;
22741 PyObject * obj0 = 0 ;
22742 char *kwnames[] = {
22743 (char *) "self", NULL
22744 };
22745
22746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22748 if (SWIG_arg_fail(1)) SWIG_fail;
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22752
22753 wxPyEndAllowThreads(__tstate);
22754 if (PyErr_Occurred()) SWIG_fail;
22755 }
22756 {
22757 resultobj = SWIG_From_int((int)(result));
22758 }
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22766 PyObject *resultobj;
22767 wxPyApp *arg1 = (wxPyApp *) 0 ;
22768 int arg2 ;
22769 PyObject * obj0 = 0 ;
22770 PyObject * obj1 = 0 ;
22771 char *kwnames[] = {
22772 (char *) "self",(char *) "mode", NULL
22773 };
22774
22775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22777 if (SWIG_arg_fail(1)) SWIG_fail;
22778 {
22779 arg2 = (int)(SWIG_As_int(obj1));
22780 if (SWIG_arg_fail(2)) SWIG_fail;
22781 }
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 (arg1)->SetAssertMode(arg2);
22785
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 Py_INCREF(Py_None); resultobj = Py_None;
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj;
22798 wxPyApp *arg1 = (wxPyApp *) 0 ;
22799 int result;
22800 PyObject * obj0 = 0 ;
22801 char *kwnames[] = {
22802 (char *) "self", NULL
22803 };
22804
22805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(1)) SWIG_fail;
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (int)(arg1)->GetAssertMode();
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 {
22816 resultobj = SWIG_From_int((int)(result));
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj;
22826 bool result;
22827 char *kwnames[] = {
22828 NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22835
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 {
22840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22841 }
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj;
22850 long result;
22851 char *kwnames[] = {
22852 NULL
22853 };
22854
22855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (long)wxPyApp::GetMacAboutMenuItemId();
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 {
22864 resultobj = SWIG_From_long((long)(result));
22865 }
22866 return resultobj;
22867 fail:
22868 return NULL;
22869 }
22870
22871
22872 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj;
22874 long result;
22875 char *kwnames[] = {
22876 NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = SWIG_From_long((long)(result));
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj;
22898 long result;
22899 char *kwnames[] = {
22900 NULL
22901 };
22902
22903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 result = (long)wxPyApp::GetMacExitMenuItemId();
22907
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 {
22912 resultobj = SWIG_From_long((long)(result));
22913 }
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj;
22922 wxString result;
22923 char *kwnames[] = {
22924 NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22928 {
22929 PyThreadState* __tstate = wxPyBeginAllowThreads();
22930 result = wxPyApp::GetMacHelpMenuTitleName();
22931
22932 wxPyEndAllowThreads(__tstate);
22933 if (PyErr_Occurred()) SWIG_fail;
22934 }
22935 {
22936 #if wxUSE_UNICODE
22937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22938 #else
22939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22940 #endif
22941 }
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj;
22950 bool arg1 ;
22951 PyObject * obj0 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "val", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22957 {
22958 arg1 = (bool)(SWIG_As_bool(obj0));
22959 if (SWIG_arg_fail(1)) SWIG_fail;
22960 }
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22964
22965 wxPyEndAllowThreads(__tstate);
22966 if (PyErr_Occurred()) SWIG_fail;
22967 }
22968 Py_INCREF(Py_None); resultobj = Py_None;
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22976 PyObject *resultobj;
22977 long arg1 ;
22978 PyObject * obj0 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "val", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22984 {
22985 arg1 = (long)(SWIG_As_long(obj0));
22986 if (SWIG_arg_fail(1)) SWIG_fail;
22987 }
22988 {
22989 PyThreadState* __tstate = wxPyBeginAllowThreads();
22990 wxPyApp::SetMacAboutMenuItemId(arg1);
22991
22992 wxPyEndAllowThreads(__tstate);
22993 if (PyErr_Occurred()) SWIG_fail;
22994 }
22995 Py_INCREF(Py_None); resultobj = Py_None;
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23003 PyObject *resultobj;
23004 long arg1 ;
23005 PyObject * obj0 = 0 ;
23006 char *kwnames[] = {
23007 (char *) "val", NULL
23008 };
23009
23010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23011 {
23012 arg1 = (long)(SWIG_As_long(obj0));
23013 if (SWIG_arg_fail(1)) SWIG_fail;
23014 }
23015 {
23016 PyThreadState* __tstate = wxPyBeginAllowThreads();
23017 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23018
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 Py_INCREF(Py_None); resultobj = Py_None;
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj;
23031 long arg1 ;
23032 PyObject * obj0 = 0 ;
23033 char *kwnames[] = {
23034 (char *) "val", NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23038 {
23039 arg1 = (long)(SWIG_As_long(obj0));
23040 if (SWIG_arg_fail(1)) SWIG_fail;
23041 }
23042 {
23043 PyThreadState* __tstate = wxPyBeginAllowThreads();
23044 wxPyApp::SetMacExitMenuItemId(arg1);
23045
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 Py_INCREF(Py_None); resultobj = Py_None;
23050 return resultobj;
23051 fail:
23052 return NULL;
23053 }
23054
23055
23056 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23057 PyObject *resultobj;
23058 wxString *arg1 = 0 ;
23059 bool temp1 = false ;
23060 PyObject * obj0 = 0 ;
23061 char *kwnames[] = {
23062 (char *) "val", NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23066 {
23067 arg1 = wxString_in_helper(obj0);
23068 if (arg1 == NULL) SWIG_fail;
23069 temp1 = true;
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23074
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 Py_INCREF(Py_None); resultobj = Py_None;
23079 {
23080 if (temp1)
23081 delete arg1;
23082 }
23083 return resultobj;
23084 fail:
23085 {
23086 if (temp1)
23087 delete arg1;
23088 }
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxPyApp *arg1 = (wxPyApp *) 0 ;
23096 PyObject * obj0 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 (arg1)->_BootstrapApp();
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 Py_INCREF(Py_None); resultobj = Py_None;
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23119 PyObject *resultobj;
23120 int result;
23121 char *kwnames[] = {
23122 NULL
23123 };
23124
23125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (int)PyApp_GetComCtl32Version();
23129
23130 wxPyEndAllowThreads(__tstate);
23131 if (PyErr_Occurred()) SWIG_fail;
23132 }
23133 {
23134 resultobj = SWIG_From_int((int)(result));
23135 }
23136 return resultobj;
23137 fail:
23138 return NULL;
23139 }
23140
23141
23142 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23143 PyObject *obj;
23144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23145 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23146 Py_INCREF(obj);
23147 return Py_BuildValue((char *)"");
23148 }
23149 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23150 PyObject *resultobj;
23151 char *kwnames[] = {
23152 NULL
23153 };
23154
23155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 wxExit();
23159
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 Py_INCREF(Py_None); resultobj = Py_None;
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj;
23172 bool result;
23173 char *kwnames[] = {
23174 NULL
23175 };
23176
23177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 result = (bool)wxYield();
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 {
23186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23187 }
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj;
23196 bool result;
23197 char *kwnames[] = {
23198 NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)wxYieldIfNeeded();
23205
23206 wxPyEndAllowThreads(__tstate);
23207 if (PyErr_Occurred()) SWIG_fail;
23208 }
23209 {
23210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23211 }
23212 return resultobj;
23213 fail:
23214 return NULL;
23215 }
23216
23217
23218 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23219 PyObject *resultobj;
23220 wxWindow *arg1 = (wxWindow *) NULL ;
23221 bool arg2 = (bool) false ;
23222 bool result;
23223 PyObject * obj0 = 0 ;
23224 PyObject * obj1 = 0 ;
23225 char *kwnames[] = {
23226 (char *) "win",(char *) "onlyIfNeeded", NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23230 if (obj0) {
23231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23232 if (SWIG_arg_fail(1)) SWIG_fail;
23233 }
23234 if (obj1) {
23235 {
23236 arg2 = (bool)(SWIG_As_bool(obj1));
23237 if (SWIG_arg_fail(2)) SWIG_fail;
23238 }
23239 }
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = (bool)wxSafeYield(arg1,arg2);
23243
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 {
23248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23249 }
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj;
23258 char *kwnames[] = {
23259 NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 wxWakeUpIdle();
23266
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 Py_INCREF(Py_None); resultobj = Py_None;
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23278 PyObject *resultobj;
23279 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23280 wxEvent *arg2 = 0 ;
23281 PyObject * obj0 = 0 ;
23282 PyObject * obj1 = 0 ;
23283 char *kwnames[] = {
23284 (char *) "dest",(char *) "event", NULL
23285 };
23286
23287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(1)) SWIG_fail;
23290 {
23291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23292 if (SWIG_arg_fail(2)) SWIG_fail;
23293 if (arg2 == NULL) {
23294 SWIG_null_ref("wxEvent");
23295 }
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 }
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 wxPostEvent(arg1,*arg2);
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 Py_INCREF(Py_None); resultobj = Py_None;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 char *kwnames[] = {
23315 NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 wxApp_CleanUp();
23322
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 Py_INCREF(Py_None); resultobj = Py_None;
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj;
23335 wxPyApp *result;
23336 char *kwnames[] = {
23337 NULL
23338 };
23339
23340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = (wxPyApp *)wxPyGetApp();
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 {
23349 resultobj = wxPyMake_wxObject(result, 0);
23350 }
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23358 PyObject *resultobj;
23359 char *arg1 = (char *) 0 ;
23360 PyObject * obj0 = 0 ;
23361 char *kwnames[] = {
23362 (char *) "encoding", NULL
23363 };
23364
23365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23366 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23367 SWIG_arg_fail(1);SWIG_fail;
23368 }
23369 {
23370 PyThreadState* __tstate = wxPyBeginAllowThreads();
23371 wxSetDefaultPyEncoding((char const *)arg1);
23372
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 Py_INCREF(Py_None); resultobj = Py_None;
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 char *result;
23386 char *kwnames[] = {
23387 NULL
23388 };
23389
23390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (char *)wxGetDefaultPyEncoding();
23394
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 resultobj = SWIG_FromCharPtr(result);
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj;
23407 wxEventLoop *result;
23408 char *kwnames[] = {
23409 NULL
23410 };
23411
23412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 result = (wxEventLoop *)new wxEventLoop();
23416
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23428 PyObject *resultobj;
23429 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23430 PyObject * obj0 = 0 ;
23431 char *kwnames[] = {
23432 (char *) "self", NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23437 if (SWIG_arg_fail(1)) SWIG_fail;
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 delete arg1;
23441
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 Py_INCREF(Py_None); resultobj = Py_None;
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23453 PyObject *resultobj;
23454 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23455 int result;
23456 PyObject * obj0 = 0 ;
23457 char *kwnames[] = {
23458 (char *) "self", NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(1)) SWIG_fail;
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (int)(arg1)->Run();
23467
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 {
23472 resultobj = SWIG_From_int((int)(result));
23473 }
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23483 int arg2 = (int) 0 ;
23484 PyObject * obj0 = 0 ;
23485 PyObject * obj1 = 0 ;
23486 char *kwnames[] = {
23487 (char *) "self",(char *) "rc", NULL
23488 };
23489
23490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23492 if (SWIG_arg_fail(1)) SWIG_fail;
23493 if (obj1) {
23494 {
23495 arg2 = (int)(SWIG_As_int(obj1));
23496 if (SWIG_arg_fail(2)) SWIG_fail;
23497 }
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 (arg1)->Exit(arg2);
23502
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 Py_INCREF(Py_None); resultobj = Py_None;
23507 return resultobj;
23508 fail:
23509 return NULL;
23510 }
23511
23512
23513 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23514 PyObject *resultobj;
23515 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23516 bool result;
23517 PyObject * obj0 = 0 ;
23518 char *kwnames[] = {
23519 (char *) "self", NULL
23520 };
23521
23522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23524 if (SWIG_arg_fail(1)) SWIG_fail;
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (bool)((wxEventLoop const *)arg1)->Pending();
23528
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23542 PyObject *resultobj;
23543 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23544 bool result;
23545 PyObject * obj0 = 0 ;
23546 char *kwnames[] = {
23547 (char *) "self", NULL
23548 };
23549
23550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23552 if (SWIG_arg_fail(1)) SWIG_fail;
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = (bool)(arg1)->Dispatch();
23556
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 {
23561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23562 }
23563 return resultobj;
23564 fail:
23565 return NULL;
23566 }
23567
23568
23569 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23570 PyObject *resultobj;
23571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23572 bool result;
23573 PyObject * obj0 = 0 ;
23574 char *kwnames[] = {
23575 (char *) "self", NULL
23576 };
23577
23578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23580 if (SWIG_arg_fail(1)) SWIG_fail;
23581 {
23582 PyThreadState* __tstate = wxPyBeginAllowThreads();
23583 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23584
23585 wxPyEndAllowThreads(__tstate);
23586 if (PyErr_Occurred()) SWIG_fail;
23587 }
23588 {
23589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23590 }
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj;
23599 wxEventLoop *result;
23600 char *kwnames[] = {
23601 NULL
23602 };
23603
23604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = (wxEventLoop *)wxEventLoop::GetActive();
23608
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj;
23621 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23622 PyObject * obj0 = 0 ;
23623 char *kwnames[] = {
23624 (char *) "loop", NULL
23625 };
23626
23627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23629 if (SWIG_arg_fail(1)) SWIG_fail;
23630 {
23631 PyThreadState* __tstate = wxPyBeginAllowThreads();
23632 wxEventLoop::SetActive(arg1);
23633
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 Py_INCREF(Py_None); resultobj = Py_None;
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23645 PyObject *obj;
23646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23647 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23648 Py_INCREF(obj);
23649 return Py_BuildValue((char *)"");
23650 }
23651 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 int arg1 = (int) 0 ;
23654 int arg2 = (int) 0 ;
23655 int arg3 = (int) 0 ;
23656 wxAcceleratorEntry *result;
23657 PyObject * obj0 = 0 ;
23658 PyObject * obj1 = 0 ;
23659 PyObject * obj2 = 0 ;
23660 char *kwnames[] = {
23661 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23662 };
23663
23664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23665 if (obj0) {
23666 {
23667 arg1 = (int)(SWIG_As_int(obj0));
23668 if (SWIG_arg_fail(1)) SWIG_fail;
23669 }
23670 }
23671 if (obj1) {
23672 {
23673 arg2 = (int)(SWIG_As_int(obj1));
23674 if (SWIG_arg_fail(2)) SWIG_fail;
23675 }
23676 }
23677 if (obj2) {
23678 {
23679 arg3 = (int)(SWIG_As_int(obj2));
23680 if (SWIG_arg_fail(3)) SWIG_fail;
23681 }
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj;
23699 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23700 PyObject * obj0 = 0 ;
23701 char *kwnames[] = {
23702 (char *) "self", NULL
23703 };
23704
23705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23707 if (SWIG_arg_fail(1)) SWIG_fail;
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 delete arg1;
23711
23712 wxPyEndAllowThreads(__tstate);
23713 if (PyErr_Occurred()) SWIG_fail;
23714 }
23715 Py_INCREF(Py_None); resultobj = Py_None;
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23725 int arg2 ;
23726 int arg3 ;
23727 int arg4 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 PyObject * obj2 = 0 ;
23731 PyObject * obj3 = 0 ;
23732 char *kwnames[] = {
23733 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23734 };
23735
23736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23738 if (SWIG_arg_fail(1)) SWIG_fail;
23739 {
23740 arg2 = (int)(SWIG_As_int(obj1));
23741 if (SWIG_arg_fail(2)) SWIG_fail;
23742 }
23743 {
23744 arg3 = (int)(SWIG_As_int(obj2));
23745 if (SWIG_arg_fail(3)) SWIG_fail;
23746 }
23747 {
23748 arg4 = (int)(SWIG_As_int(obj3));
23749 if (SWIG_arg_fail(4)) SWIG_fail;
23750 }
23751 {
23752 PyThreadState* __tstate = wxPyBeginAllowThreads();
23753 (arg1)->Set(arg2,arg3,arg4);
23754
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 Py_INCREF(Py_None); resultobj = Py_None;
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23766 PyObject *resultobj;
23767 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23768 int result;
23769 PyObject * obj0 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "self", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23776 if (SWIG_arg_fail(1)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = (int)(arg1)->GetFlags();
23780
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 {
23785 resultobj = SWIG_From_int((int)(result));
23786 }
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23794 PyObject *resultobj;
23795 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23796 int result;
23797 PyObject * obj0 = 0 ;
23798 char *kwnames[] = {
23799 (char *) "self", NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 result = (int)(arg1)->GetKeyCode();
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 {
23813 resultobj = SWIG_From_int((int)(result));
23814 }
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23824 int result;
23825 PyObject * obj0 = 0 ;
23826 char *kwnames[] = {
23827 (char *) "self", NULL
23828 };
23829
23830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 result = (int)(arg1)->GetCommand();
23836
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 {
23841 resultobj = SWIG_From_int((int)(result));
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23850 PyObject *obj;
23851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23852 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23853 Py_INCREF(obj);
23854 return Py_BuildValue((char *)"");
23855 }
23856 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 int arg1 ;
23859 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23860 wxAcceleratorTable *result;
23861 PyObject * obj0 = 0 ;
23862 char *kwnames[] = {
23863 (char *) "n", NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23867 {
23868 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23869 if (arg2) arg1 = PyList_Size(obj0);
23870 else arg1 = 0;
23871 }
23872 {
23873 PyThreadState* __tstate = wxPyBeginAllowThreads();
23874 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23875
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23880 {
23881 delete [] arg2;
23882 }
23883 return resultobj;
23884 fail:
23885 {
23886 delete [] arg2;
23887 }
23888 return NULL;
23889 }
23890
23891
23892 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj;
23894 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23895 PyObject * obj0 = 0 ;
23896 char *kwnames[] = {
23897 (char *) "self", NULL
23898 };
23899
23900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23902 if (SWIG_arg_fail(1)) SWIG_fail;
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 delete arg1;
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 Py_INCREF(Py_None); resultobj = Py_None;
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23918 PyObject *resultobj;
23919 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23920 bool result;
23921 PyObject * obj0 = 0 ;
23922 char *kwnames[] = {
23923 (char *) "self", NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23928 if (SWIG_arg_fail(1)) SWIG_fail;
23929 {
23930 PyThreadState* __tstate = wxPyBeginAllowThreads();
23931 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23932
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23946 PyObject *obj;
23947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23948 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23949 Py_INCREF(obj);
23950 return Py_BuildValue((char *)"");
23951 }
23952 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23953 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23954 return 1;
23955 }
23956
23957
23958 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23959 PyObject *pyobj;
23960
23961 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23962 return pyobj;
23963 }
23964
23965
23966 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj;
23968 wxString *arg1 = 0 ;
23969 wxAcceleratorEntry *result;
23970 bool temp1 = false ;
23971 PyObject * obj0 = 0 ;
23972 char *kwnames[] = {
23973 (char *) "label", NULL
23974 };
23975
23976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23977 {
23978 arg1 = wxString_in_helper(obj0);
23979 if (arg1 == NULL) SWIG_fail;
23980 temp1 = true;
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23985
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23990 {
23991 if (temp1)
23992 delete arg1;
23993 }
23994 return resultobj;
23995 fail:
23996 {
23997 if (temp1)
23998 delete arg1;
23999 }
24000 return NULL;
24001 }
24002
24003
24004 static int _wrap_PanelNameStr_set(PyObject *) {
24005 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24006 return 1;
24007 }
24008
24009
24010 static PyObject *_wrap_PanelNameStr_get(void) {
24011 PyObject *pyobj;
24012
24013 {
24014 #if wxUSE_UNICODE
24015 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24016 #else
24017 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24018 #endif
24019 }
24020 return pyobj;
24021 }
24022
24023
24024 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj;
24026 wxVisualAttributes *result;
24027 char *kwnames[] = {
24028 NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 result = (wxVisualAttributes *)new_wxVisualAttributes();
24035
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24047 PyObject *resultobj;
24048 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24049 PyObject * obj0 = 0 ;
24050 char *kwnames[] = {
24051 (char *) "self", NULL
24052 };
24053
24054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24056 if (SWIG_arg_fail(1)) SWIG_fail;
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 delete_wxVisualAttributes(arg1);
24060
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 Py_INCREF(Py_None); resultobj = Py_None;
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj;
24073 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24074 wxFont *arg2 = (wxFont *) 0 ;
24075 PyObject * obj0 = 0 ;
24076 PyObject * obj1 = 0 ;
24077 char *kwnames[] = {
24078 (char *) "self",(char *) "font", NULL
24079 };
24080
24081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24083 if (SWIG_arg_fail(1)) SWIG_fail;
24084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(2)) SWIG_fail;
24086 if (arg1) (arg1)->font = *arg2;
24087
24088 Py_INCREF(Py_None); resultobj = Py_None;
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24098 wxFont *result;
24099 PyObject * obj0 = 0 ;
24100 char *kwnames[] = {
24101 (char *) "self", NULL
24102 };
24103
24104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24106 if (SWIG_arg_fail(1)) SWIG_fail;
24107 result = (wxFont *)& ((arg1)->font);
24108
24109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24119 wxColour *arg2 = (wxColour *) 0 ;
24120 PyObject * obj0 = 0 ;
24121 PyObject * obj1 = 0 ;
24122 char *kwnames[] = {
24123 (char *) "self",(char *) "colFg", NULL
24124 };
24125
24126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(1)) SWIG_fail;
24129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(2)) SWIG_fail;
24131 if (arg1) (arg1)->colFg = *arg2;
24132
24133 Py_INCREF(Py_None); resultobj = Py_None;
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24143 wxColour *result;
24144 PyObject * obj0 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "self", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 result = (wxColour *)& ((arg1)->colFg);
24153
24154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24155 return resultobj;
24156 fail:
24157 return NULL;
24158 }
24159
24160
24161 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24162 PyObject *resultobj;
24163 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24164 wxColour *arg2 = (wxColour *) 0 ;
24165 PyObject * obj0 = 0 ;
24166 PyObject * obj1 = 0 ;
24167 char *kwnames[] = {
24168 (char *) "self",(char *) "colBg", NULL
24169 };
24170
24171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24173 if (SWIG_arg_fail(1)) SWIG_fail;
24174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(2)) SWIG_fail;
24176 if (arg1) (arg1)->colBg = *arg2;
24177
24178 Py_INCREF(Py_None); resultobj = Py_None;
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj;
24187 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24188 wxColour *result;
24189 PyObject * obj0 = 0 ;
24190 char *kwnames[] = {
24191 (char *) "self", NULL
24192 };
24193
24194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24196 if (SWIG_arg_fail(1)) SWIG_fail;
24197 result = (wxColour *)& ((arg1)->colBg);
24198
24199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24207 PyObject *obj;
24208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24209 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24210 Py_INCREF(obj);
24211 return Py_BuildValue((char *)"");
24212 }
24213 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj;
24215 wxWindow *arg1 = (wxWindow *) 0 ;
24216 int arg2 = (int) (int)-1 ;
24217 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24218 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24219 wxSize const &arg4_defvalue = wxDefaultSize ;
24220 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24221 long arg5 = (long) 0 ;
24222 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24223 wxString *arg6 = (wxString *) &arg6_defvalue ;
24224 wxWindow *result;
24225 wxPoint temp3 ;
24226 wxSize temp4 ;
24227 bool temp6 = false ;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230 PyObject * obj2 = 0 ;
24231 PyObject * obj3 = 0 ;
24232 PyObject * obj4 = 0 ;
24233 PyObject * obj5 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24240 if (SWIG_arg_fail(1)) SWIG_fail;
24241 if (obj1) {
24242 {
24243 arg2 = (int const)(SWIG_As_int(obj1));
24244 if (SWIG_arg_fail(2)) SWIG_fail;
24245 }
24246 }
24247 if (obj2) {
24248 {
24249 arg3 = &temp3;
24250 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24251 }
24252 }
24253 if (obj3) {
24254 {
24255 arg4 = &temp4;
24256 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24257 }
24258 }
24259 if (obj4) {
24260 {
24261 arg5 = (long)(SWIG_As_long(obj4));
24262 if (SWIG_arg_fail(5)) SWIG_fail;
24263 }
24264 }
24265 if (obj5) {
24266 {
24267 arg6 = wxString_in_helper(obj5);
24268 if (arg6 == NULL) SWIG_fail;
24269 temp6 = true;
24270 }
24271 }
24272 {
24273 if (!wxPyCheckForApp()) SWIG_fail;
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24281 {
24282 if (temp6)
24283 delete arg6;
24284 }
24285 return resultobj;
24286 fail:
24287 {
24288 if (temp6)
24289 delete arg6;
24290 }
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxWindow *result;
24298 char *kwnames[] = {
24299 NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24303 {
24304 if (!wxPyCheckForApp()) SWIG_fail;
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 result = (wxWindow *)new wxWindow();
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj;
24320 wxWindow *arg1 = (wxWindow *) 0 ;
24321 wxWindow *arg2 = (wxWindow *) 0 ;
24322 int arg3 = (int) (int)-1 ;
24323 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24324 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24325 wxSize const &arg5_defvalue = wxDefaultSize ;
24326 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24327 long arg6 = (long) 0 ;
24328 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24329 wxString *arg7 = (wxString *) &arg7_defvalue ;
24330 bool result;
24331 wxPoint temp4 ;
24332 wxSize temp5 ;
24333 bool temp7 = false ;
24334 PyObject * obj0 = 0 ;
24335 PyObject * obj1 = 0 ;
24336 PyObject * obj2 = 0 ;
24337 PyObject * obj3 = 0 ;
24338 PyObject * obj4 = 0 ;
24339 PyObject * obj5 = 0 ;
24340 PyObject * obj6 = 0 ;
24341 char *kwnames[] = {
24342 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24343 };
24344
24345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24347 if (SWIG_arg_fail(1)) SWIG_fail;
24348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24349 if (SWIG_arg_fail(2)) SWIG_fail;
24350 if (obj2) {
24351 {
24352 arg3 = (int const)(SWIG_As_int(obj2));
24353 if (SWIG_arg_fail(3)) SWIG_fail;
24354 }
24355 }
24356 if (obj3) {
24357 {
24358 arg4 = &temp4;
24359 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24360 }
24361 }
24362 if (obj4) {
24363 {
24364 arg5 = &temp5;
24365 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24366 }
24367 }
24368 if (obj5) {
24369 {
24370 arg6 = (long)(SWIG_As_long(obj5));
24371 if (SWIG_arg_fail(6)) SWIG_fail;
24372 }
24373 }
24374 if (obj6) {
24375 {
24376 arg7 = wxString_in_helper(obj6);
24377 if (arg7 == NULL) SWIG_fail;
24378 temp7 = true;
24379 }
24380 }
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24384
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 {
24389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24390 }
24391 {
24392 if (temp7)
24393 delete arg7;
24394 }
24395 return resultobj;
24396 fail:
24397 {
24398 if (temp7)
24399 delete arg7;
24400 }
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxWindow *arg1 = (wxWindow *) 0 ;
24408 bool arg2 = (bool) false ;
24409 bool result;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self",(char *) "force", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 if (obj1) {
24420 {
24421 arg2 = (bool)(SWIG_As_bool(obj1));
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (bool)(arg1)->Close(arg2);
24428
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 {
24433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24434 }
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24442 PyObject *resultobj;
24443 wxWindow *arg1 = (wxWindow *) 0 ;
24444 bool result;
24445 PyObject * obj0 = 0 ;
24446 char *kwnames[] = {
24447 (char *) "self", NULL
24448 };
24449
24450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24452 if (SWIG_arg_fail(1)) SWIG_fail;
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 result = (bool)(arg1)->Destroy();
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 {
24461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24462 }
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj;
24471 wxWindow *arg1 = (wxWindow *) 0 ;
24472 bool result;
24473 PyObject * obj0 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 result = (bool)(arg1)->DestroyChildren();
24484
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 {
24489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24490 }
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24498 PyObject *resultobj;
24499 wxWindow *arg1 = (wxWindow *) 0 ;
24500 bool result;
24501 PyObject * obj0 = 0 ;
24502 char *kwnames[] = {
24503 (char *) "self", NULL
24504 };
24505
24506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(1)) SWIG_fail;
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24512
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 {
24517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24518 }
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24526 PyObject *resultobj;
24527 wxWindow *arg1 = (wxWindow *) 0 ;
24528 wxString *arg2 = 0 ;
24529 bool temp2 = false ;
24530 PyObject * obj0 = 0 ;
24531 PyObject * obj1 = 0 ;
24532 char *kwnames[] = {
24533 (char *) "self",(char *) "title", NULL
24534 };
24535
24536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24538 if (SWIG_arg_fail(1)) SWIG_fail;
24539 {
24540 arg2 = wxString_in_helper(obj1);
24541 if (arg2 == NULL) SWIG_fail;
24542 temp2 = true;
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 (arg1)->SetTitle((wxString const &)*arg2);
24547
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 Py_INCREF(Py_None); resultobj = Py_None;
24552 {
24553 if (temp2)
24554 delete arg2;
24555 }
24556 return resultobj;
24557 fail:
24558 {
24559 if (temp2)
24560 delete arg2;
24561 }
24562 return NULL;
24563 }
24564
24565
24566 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj;
24568 wxWindow *arg1 = (wxWindow *) 0 ;
24569 wxString result;
24570 PyObject * obj0 = 0 ;
24571 char *kwnames[] = {
24572 (char *) "self", NULL
24573 };
24574
24575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24577 if (SWIG_arg_fail(1)) SWIG_fail;
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 result = ((wxWindow const *)arg1)->GetTitle();
24581
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 {
24586 #if wxUSE_UNICODE
24587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24588 #else
24589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24590 #endif
24591 }
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24599 PyObject *resultobj;
24600 wxWindow *arg1 = (wxWindow *) 0 ;
24601 wxString *arg2 = 0 ;
24602 bool temp2 = false ;
24603 PyObject * obj0 = 0 ;
24604 PyObject * obj1 = 0 ;
24605 char *kwnames[] = {
24606 (char *) "self",(char *) "label", NULL
24607 };
24608
24609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24611 if (SWIG_arg_fail(1)) SWIG_fail;
24612 {
24613 arg2 = wxString_in_helper(obj1);
24614 if (arg2 == NULL) SWIG_fail;
24615 temp2 = true;
24616 }
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 (arg1)->SetLabel((wxString const &)*arg2);
24620
24621 wxPyEndAllowThreads(__tstate);
24622 if (PyErr_Occurred()) SWIG_fail;
24623 }
24624 Py_INCREF(Py_None); resultobj = Py_None;
24625 {
24626 if (temp2)
24627 delete arg2;
24628 }
24629 return resultobj;
24630 fail:
24631 {
24632 if (temp2)
24633 delete arg2;
24634 }
24635 return NULL;
24636 }
24637
24638
24639 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 wxWindow *arg1 = (wxWindow *) 0 ;
24642 wxString result;
24643 PyObject * obj0 = 0 ;
24644 char *kwnames[] = {
24645 (char *) "self", NULL
24646 };
24647
24648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24650 if (SWIG_arg_fail(1)) SWIG_fail;
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 result = ((wxWindow const *)arg1)->GetLabel();
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 {
24659 #if wxUSE_UNICODE
24660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24661 #else
24662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24663 #endif
24664 }
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj;
24673 wxWindow *arg1 = (wxWindow *) 0 ;
24674 wxString *arg2 = 0 ;
24675 bool temp2 = false ;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "self",(char *) "name", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(1)) SWIG_fail;
24685 {
24686 arg2 = wxString_in_helper(obj1);
24687 if (arg2 == NULL) SWIG_fail;
24688 temp2 = true;
24689 }
24690 {
24691 PyThreadState* __tstate = wxPyBeginAllowThreads();
24692 (arg1)->SetName((wxString const &)*arg2);
24693
24694 wxPyEndAllowThreads(__tstate);
24695 if (PyErr_Occurred()) SWIG_fail;
24696 }
24697 Py_INCREF(Py_None); resultobj = Py_None;
24698 {
24699 if (temp2)
24700 delete arg2;
24701 }
24702 return resultobj;
24703 fail:
24704 {
24705 if (temp2)
24706 delete arg2;
24707 }
24708 return NULL;
24709 }
24710
24711
24712 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24713 PyObject *resultobj;
24714 wxWindow *arg1 = (wxWindow *) 0 ;
24715 wxString result;
24716 PyObject * obj0 = 0 ;
24717 char *kwnames[] = {
24718 (char *) "self", NULL
24719 };
24720
24721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24723 if (SWIG_arg_fail(1)) SWIG_fail;
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = ((wxWindow const *)arg1)->GetName();
24727
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 #if wxUSE_UNICODE
24733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24734 #else
24735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24736 #endif
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj;
24746 wxWindow *arg1 = (wxWindow *) 0 ;
24747 wxWindowVariant arg2 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char *kwnames[] = {
24751 (char *) "self",(char *) "variant", NULL
24752 };
24753
24754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24756 if (SWIG_arg_fail(1)) SWIG_fail;
24757 {
24758 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24759 if (SWIG_arg_fail(2)) SWIG_fail;
24760 }
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24764
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 Py_INCREF(Py_None); resultobj = Py_None;
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxWindow *arg1 = (wxWindow *) 0 ;
24778 wxWindowVariant result;
24779 PyObject * obj0 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 resultobj = SWIG_From_int((result));
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj;
24803 wxWindow *arg1 = (wxWindow *) 0 ;
24804 int arg2 ;
24805 PyObject * obj0 = 0 ;
24806 PyObject * obj1 = 0 ;
24807 char *kwnames[] = {
24808 (char *) "self",(char *) "winid", NULL
24809 };
24810
24811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24813 if (SWIG_arg_fail(1)) SWIG_fail;
24814 {
24815 arg2 = (int)(SWIG_As_int(obj1));
24816 if (SWIG_arg_fail(2)) SWIG_fail;
24817 }
24818 {
24819 PyThreadState* __tstate = wxPyBeginAllowThreads();
24820 (arg1)->SetId(arg2);
24821
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 Py_INCREF(Py_None); resultobj = Py_None;
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj;
24834 wxWindow *arg1 = (wxWindow *) 0 ;
24835 int result;
24836 PyObject * obj0 = 0 ;
24837 char *kwnames[] = {
24838 (char *) "self", NULL
24839 };
24840
24841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24843 if (SWIG_arg_fail(1)) SWIG_fail;
24844 {
24845 PyThreadState* __tstate = wxPyBeginAllowThreads();
24846 result = (int)((wxWindow const *)arg1)->GetId();
24847
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 {
24852 resultobj = SWIG_From_int((int)(result));
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24861 PyObject *resultobj;
24862 int result;
24863 char *kwnames[] = {
24864 NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = (int)wxWindow::NewControlId();
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 resultobj = SWIG_From_int((int)(result));
24877 }
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24885 PyObject *resultobj;
24886 int arg1 ;
24887 int result;
24888 PyObject * obj0 = 0 ;
24889 char *kwnames[] = {
24890 (char *) "winid", NULL
24891 };
24892
24893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24894 {
24895 arg1 = (int)(SWIG_As_int(obj0));
24896 if (SWIG_arg_fail(1)) SWIG_fail;
24897 }
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = (int)wxWindow::NextControlId(arg1);
24901
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 {
24906 resultobj = SWIG_From_int((int)(result));
24907 }
24908 return resultobj;
24909 fail:
24910 return NULL;
24911 }
24912
24913
24914 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj;
24916 int arg1 ;
24917 int result;
24918 PyObject * obj0 = 0 ;
24919 char *kwnames[] = {
24920 (char *) "winid", NULL
24921 };
24922
24923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24924 {
24925 arg1 = (int)(SWIG_As_int(obj0));
24926 if (SWIG_arg_fail(1)) SWIG_fail;
24927 }
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (int)wxWindow::PrevControlId(arg1);
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = SWIG_From_int((int)(result));
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxWindow *arg1 = (wxWindow *) 0 ;
24947 wxSize *arg2 = 0 ;
24948 wxSize temp2 ;
24949 PyObject * obj0 = 0 ;
24950 PyObject * obj1 = 0 ;
24951 char *kwnames[] = {
24952 (char *) "self",(char *) "size", NULL
24953 };
24954
24955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24957 if (SWIG_arg_fail(1)) SWIG_fail;
24958 {
24959 arg2 = &temp2;
24960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24961 }
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 (arg1)->SetSize((wxSize const &)*arg2);
24965
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 Py_INCREF(Py_None); resultobj = Py_None;
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj;
24978 wxWindow *arg1 = (wxWindow *) 0 ;
24979 int arg2 ;
24980 int arg3 ;
24981 int arg4 ;
24982 int arg5 ;
24983 int arg6 = (int) wxSIZE_AUTO ;
24984 PyObject * obj0 = 0 ;
24985 PyObject * obj1 = 0 ;
24986 PyObject * obj2 = 0 ;
24987 PyObject * obj3 = 0 ;
24988 PyObject * obj4 = 0 ;
24989 PyObject * obj5 = 0 ;
24990 char *kwnames[] = {
24991 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24992 };
24993
24994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24996 if (SWIG_arg_fail(1)) SWIG_fail;
24997 {
24998 arg2 = (int)(SWIG_As_int(obj1));
24999 if (SWIG_arg_fail(2)) SWIG_fail;
25000 }
25001 {
25002 arg3 = (int)(SWIG_As_int(obj2));
25003 if (SWIG_arg_fail(3)) SWIG_fail;
25004 }
25005 {
25006 arg4 = (int)(SWIG_As_int(obj3));
25007 if (SWIG_arg_fail(4)) SWIG_fail;
25008 }
25009 {
25010 arg5 = (int)(SWIG_As_int(obj4));
25011 if (SWIG_arg_fail(5)) SWIG_fail;
25012 }
25013 if (obj5) {
25014 {
25015 arg6 = (int)(SWIG_As_int(obj5));
25016 if (SWIG_arg_fail(6)) SWIG_fail;
25017 }
25018 }
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25022
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 Py_INCREF(Py_None); resultobj = Py_None;
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25034 PyObject *resultobj;
25035 wxWindow *arg1 = (wxWindow *) 0 ;
25036 wxRect *arg2 = 0 ;
25037 int arg3 = (int) wxSIZE_AUTO ;
25038 wxRect temp2 ;
25039 PyObject * obj0 = 0 ;
25040 PyObject * obj1 = 0 ;
25041 PyObject * obj2 = 0 ;
25042 char *kwnames[] = {
25043 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25044 };
25045
25046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25048 if (SWIG_arg_fail(1)) SWIG_fail;
25049 {
25050 arg2 = &temp2;
25051 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25052 }
25053 if (obj2) {
25054 {
25055 arg3 = (int)(SWIG_As_int(obj2));
25056 if (SWIG_arg_fail(3)) SWIG_fail;
25057 }
25058 }
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 Py_INCREF(Py_None); resultobj = Py_None;
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj;
25075 wxWindow *arg1 = (wxWindow *) 0 ;
25076 int arg2 ;
25077 int arg3 ;
25078 PyObject * obj0 = 0 ;
25079 PyObject * obj1 = 0 ;
25080 PyObject * obj2 = 0 ;
25081 char *kwnames[] = {
25082 (char *) "self",(char *) "width",(char *) "height", NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25087 if (SWIG_arg_fail(1)) SWIG_fail;
25088 {
25089 arg2 = (int)(SWIG_As_int(obj1));
25090 if (SWIG_arg_fail(2)) SWIG_fail;
25091 }
25092 {
25093 arg3 = (int)(SWIG_As_int(obj2));
25094 if (SWIG_arg_fail(3)) SWIG_fail;
25095 }
25096 {
25097 PyThreadState* __tstate = wxPyBeginAllowThreads();
25098 (arg1)->SetSize(arg2,arg3);
25099
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 Py_INCREF(Py_None); resultobj = Py_None;
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj;
25112 wxWindow *arg1 = (wxWindow *) 0 ;
25113 wxPoint *arg2 = 0 ;
25114 int arg3 = (int) wxSIZE_USE_EXISTING ;
25115 wxPoint temp2 ;
25116 PyObject * obj0 = 0 ;
25117 PyObject * obj1 = 0 ;
25118 PyObject * obj2 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self",(char *) "pt",(char *) "flags", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 arg2 = &temp2;
25128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25129 }
25130 if (obj2) {
25131 {
25132 arg3 = (int)(SWIG_As_int(obj2));
25133 if (SWIG_arg_fail(3)) SWIG_fail;
25134 }
25135 }
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 (arg1)->Move((wxPoint const &)*arg2,arg3);
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 Py_INCREF(Py_None); resultobj = Py_None;
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj;
25152 wxWindow *arg1 = (wxWindow *) 0 ;
25153 int arg2 ;
25154 int arg3 ;
25155 int arg4 = (int) wxSIZE_USE_EXISTING ;
25156 PyObject * obj0 = 0 ;
25157 PyObject * obj1 = 0 ;
25158 PyObject * obj2 = 0 ;
25159 PyObject * obj3 = 0 ;
25160 char *kwnames[] = {
25161 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25162 };
25163
25164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25166 if (SWIG_arg_fail(1)) SWIG_fail;
25167 {
25168 arg2 = (int)(SWIG_As_int(obj1));
25169 if (SWIG_arg_fail(2)) SWIG_fail;
25170 }
25171 {
25172 arg3 = (int)(SWIG_As_int(obj2));
25173 if (SWIG_arg_fail(3)) SWIG_fail;
25174 }
25175 if (obj3) {
25176 {
25177 arg4 = (int)(SWIG_As_int(obj3));
25178 if (SWIG_arg_fail(4)) SWIG_fail;
25179 }
25180 }
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 (arg1)->Move(arg2,arg3,arg4);
25184
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 Py_INCREF(Py_None); resultobj = Py_None;
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxWindow *arg1 = (wxWindow *) 0 ;
25198 wxSize const &arg2_defvalue = wxDefaultSize ;
25199 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25200 wxSize temp2 ;
25201 PyObject * obj0 = 0 ;
25202 PyObject * obj1 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self",(char *) "size", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 if (obj1) {
25211 {
25212 arg2 = &temp2;
25213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25214 }
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 Py_INCREF(Py_None); resultobj = Py_None;
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj;
25232 wxWindow *arg1 = (wxWindow *) 0 ;
25233 PyObject * obj0 = 0 ;
25234 char *kwnames[] = {
25235 (char *) "self", NULL
25236 };
25237
25238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25240 if (SWIG_arg_fail(1)) SWIG_fail;
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 (arg1)->Raise();
25244
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 Py_INCREF(Py_None); resultobj = Py_None;
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj;
25257 wxWindow *arg1 = (wxWindow *) 0 ;
25258 PyObject * obj0 = 0 ;
25259 char *kwnames[] = {
25260 (char *) "self", NULL
25261 };
25262
25263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25265 if (SWIG_arg_fail(1)) SWIG_fail;
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->Lower();
25269
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 Py_INCREF(Py_None); resultobj = Py_None;
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 wxSize *arg2 = 0 ;
25284 wxSize temp2 ;
25285 PyObject * obj0 = 0 ;
25286 PyObject * obj1 = 0 ;
25287 char *kwnames[] = {
25288 (char *) "self",(char *) "size", NULL
25289 };
25290
25291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25293 if (SWIG_arg_fail(1)) SWIG_fail;
25294 {
25295 arg2 = &temp2;
25296 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25297 }
25298 {
25299 PyThreadState* __tstate = wxPyBeginAllowThreads();
25300 (arg1)->SetClientSize((wxSize const &)*arg2);
25301
25302 wxPyEndAllowThreads(__tstate);
25303 if (PyErr_Occurred()) SWIG_fail;
25304 }
25305 Py_INCREF(Py_None); resultobj = Py_None;
25306 return resultobj;
25307 fail:
25308 return NULL;
25309 }
25310
25311
25312 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25313 PyObject *resultobj;
25314 wxWindow *arg1 = (wxWindow *) 0 ;
25315 int arg2 ;
25316 int arg3 ;
25317 PyObject * obj0 = 0 ;
25318 PyObject * obj1 = 0 ;
25319 PyObject * obj2 = 0 ;
25320 char *kwnames[] = {
25321 (char *) "self",(char *) "width",(char *) "height", NULL
25322 };
25323
25324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25326 if (SWIG_arg_fail(1)) SWIG_fail;
25327 {
25328 arg2 = (int)(SWIG_As_int(obj1));
25329 if (SWIG_arg_fail(2)) SWIG_fail;
25330 }
25331 {
25332 arg3 = (int)(SWIG_As_int(obj2));
25333 if (SWIG_arg_fail(3)) SWIG_fail;
25334 }
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 (arg1)->SetClientSize(arg2,arg3);
25338
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 Py_INCREF(Py_None); resultobj = Py_None;
25343 return resultobj;
25344 fail:
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxWindow *arg1 = (wxWindow *) 0 ;
25352 wxRect *arg2 = 0 ;
25353 wxRect temp2 ;
25354 PyObject * obj0 = 0 ;
25355 PyObject * obj1 = 0 ;
25356 char *kwnames[] = {
25357 (char *) "self",(char *) "rect", NULL
25358 };
25359
25360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25362 if (SWIG_arg_fail(1)) SWIG_fail;
25363 {
25364 arg2 = &temp2;
25365 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25366 }
25367 {
25368 PyThreadState* __tstate = wxPyBeginAllowThreads();
25369 (arg1)->SetClientSize((wxRect const &)*arg2);
25370
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 Py_INCREF(Py_None); resultobj = Py_None;
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 wxPoint result;
25385 PyObject * obj0 = 0 ;
25386 char *kwnames[] = {
25387 (char *) "self", NULL
25388 };
25389
25390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25392 if (SWIG_arg_fail(1)) SWIG_fail;
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 result = (arg1)->GetPosition();
25396
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 {
25401 wxPoint * resultptr;
25402 resultptr = new wxPoint((wxPoint &)(result));
25403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25404 }
25405 return resultobj;
25406 fail:
25407 return NULL;
25408 }
25409
25410
25411 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25412 PyObject *resultobj;
25413 wxWindow *arg1 = (wxWindow *) 0 ;
25414 int *arg2 = (int *) 0 ;
25415 int *arg3 = (int *) 0 ;
25416 int temp2 ;
25417 int res2 = 0 ;
25418 int temp3 ;
25419 int res3 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 char *kwnames[] = {
25422 (char *) "self", NULL
25423 };
25424
25425 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25426 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25429 if (SWIG_arg_fail(1)) SWIG_fail;
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 (arg1)->GetPosition(arg2,arg3);
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 Py_INCREF(Py_None); resultobj = Py_None;
25438 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25439 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25440 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25441 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj;
25450 wxWindow *arg1 = (wxWindow *) 0 ;
25451 wxSize result;
25452 PyObject * obj0 = 0 ;
25453 char *kwnames[] = {
25454 (char *) "self", NULL
25455 };
25456
25457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25459 if (SWIG_arg_fail(1)) SWIG_fail;
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = ((wxWindow const *)arg1)->GetSize();
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 {
25468 wxSize * resultptr;
25469 resultptr = new wxSize((wxSize &)(result));
25470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25471 }
25472 return resultobj;
25473 fail:
25474 return NULL;
25475 }
25476
25477
25478 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj;
25480 wxWindow *arg1 = (wxWindow *) 0 ;
25481 int *arg2 = (int *) 0 ;
25482 int *arg3 = (int *) 0 ;
25483 int temp2 ;
25484 int res2 = 0 ;
25485 int temp3 ;
25486 int res3 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 char *kwnames[] = {
25489 (char *) "self", NULL
25490 };
25491
25492 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25493 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25496 if (SWIG_arg_fail(1)) SWIG_fail;
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25500
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 Py_INCREF(Py_None); resultobj = Py_None;
25505 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25506 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25507 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25508 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25509 return resultobj;
25510 fail:
25511 return NULL;
25512 }
25513
25514
25515 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25516 PyObject *resultobj;
25517 wxWindow *arg1 = (wxWindow *) 0 ;
25518 wxRect result;
25519 PyObject * obj0 = 0 ;
25520 char *kwnames[] = {
25521 (char *) "self", NULL
25522 };
25523
25524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25526 if (SWIG_arg_fail(1)) SWIG_fail;
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = ((wxWindow const *)arg1)->GetRect();
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 {
25535 wxRect * resultptr;
25536 resultptr = new wxRect((wxRect &)(result));
25537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25538 }
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxWindow *arg1 = (wxWindow *) 0 ;
25548 wxSize result;
25549 PyObject * obj0 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = ((wxWindow const *)arg1)->GetClientSize();
25560
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 {
25565 wxSize * resultptr;
25566 resultptr = new wxSize((wxSize &)(result));
25567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25568 }
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25576 PyObject *resultobj;
25577 wxWindow *arg1 = (wxWindow *) 0 ;
25578 int *arg2 = (int *) 0 ;
25579 int *arg3 = (int *) 0 ;
25580 int temp2 ;
25581 int res2 = 0 ;
25582 int temp3 ;
25583 int res3 = 0 ;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25590 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25593 if (SWIG_arg_fail(1)) SWIG_fail;
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25597
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 Py_INCREF(Py_None); resultobj = Py_None;
25602 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25603 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25604 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25605 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj;
25614 wxWindow *arg1 = (wxWindow *) 0 ;
25615 wxPoint result;
25616 PyObject * obj0 = 0 ;
25617 char *kwnames[] = {
25618 (char *) "self", NULL
25619 };
25620
25621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25623 if (SWIG_arg_fail(1)) SWIG_fail;
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25627
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 {
25632 wxPoint * resultptr;
25633 resultptr = new wxPoint((wxPoint &)(result));
25634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25635 }
25636 return resultobj;
25637 fail:
25638 return NULL;
25639 }
25640
25641
25642 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25643 PyObject *resultobj;
25644 wxWindow *arg1 = (wxWindow *) 0 ;
25645 wxRect result;
25646 PyObject * obj0 = 0 ;
25647 char *kwnames[] = {
25648 (char *) "self", NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25653 if (SWIG_arg_fail(1)) SWIG_fail;
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 result = ((wxWindow const *)arg1)->GetClientRect();
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 {
25662 wxRect * resultptr;
25663 resultptr = new wxRect((wxRect &)(result));
25664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25665 }
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj;
25674 wxWindow *arg1 = (wxWindow *) 0 ;
25675 wxSize result;
25676 PyObject * obj0 = 0 ;
25677 char *kwnames[] = {
25678 (char *) "self", NULL
25679 };
25680
25681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25683 if (SWIG_arg_fail(1)) SWIG_fail;
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = ((wxWindow const *)arg1)->GetBestSize();
25687
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 {
25692 wxSize * resultptr;
25693 resultptr = new wxSize((wxSize &)(result));
25694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxWindow *arg1 = (wxWindow *) 0 ;
25705 int *arg2 = (int *) 0 ;
25706 int *arg3 = (int *) 0 ;
25707 int temp2 ;
25708 int res2 = 0 ;
25709 int temp3 ;
25710 int res3 = 0 ;
25711 PyObject * obj0 = 0 ;
25712 char *kwnames[] = {
25713 (char *) "self", NULL
25714 };
25715
25716 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25717 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25720 if (SWIG_arg_fail(1)) SWIG_fail;
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25724
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 Py_INCREF(Py_None); resultobj = Py_None;
25729 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25730 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25731 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25732 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj;
25741 wxWindow *arg1 = (wxWindow *) 0 ;
25742 PyObject * obj0 = 0 ;
25743 char *kwnames[] = {
25744 (char *) "self", NULL
25745 };
25746
25747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25749 if (SWIG_arg_fail(1)) SWIG_fail;
25750 {
25751 PyThreadState* __tstate = wxPyBeginAllowThreads();
25752 (arg1)->InvalidateBestSize();
25753
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 Py_INCREF(Py_None); resultobj = Py_None;
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj;
25766 wxWindow *arg1 = (wxWindow *) 0 ;
25767 wxSize result;
25768 PyObject * obj0 = 0 ;
25769 char *kwnames[] = {
25770 (char *) "self", NULL
25771 };
25772
25773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25775 if (SWIG_arg_fail(1)) SWIG_fail;
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25779
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 wxSize * resultptr;
25785 resultptr = new wxSize((wxSize &)(result));
25786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25787 }
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxWindow *arg1 = (wxWindow *) 0 ;
25797 wxSize result;
25798 PyObject * obj0 = 0 ;
25799 char *kwnames[] = {
25800 (char *) "self", NULL
25801 };
25802
25803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25805 if (SWIG_arg_fail(1)) SWIG_fail;
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25809
25810 wxPyEndAllowThreads(__tstate);
25811 if (PyErr_Occurred()) SWIG_fail;
25812 }
25813 {
25814 wxSize * resultptr;
25815 resultptr = new wxSize((wxSize &)(result));
25816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25817 }
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj;
25826 wxWindow *arg1 = (wxWindow *) 0 ;
25827 int arg2 = (int) wxBOTH ;
25828 PyObject * obj0 = 0 ;
25829 PyObject * obj1 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self",(char *) "direction", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 if (obj1) {
25838 {
25839 arg2 = (int)(SWIG_As_int(obj1));
25840 if (SWIG_arg_fail(2)) SWIG_fail;
25841 }
25842 }
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 (arg1)->Center(arg2);
25846
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 Py_INCREF(Py_None); resultobj = Py_None;
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxWindow *arg1 = (wxWindow *) 0 ;
25860 int arg2 = (int) wxBOTH ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 char *kwnames[] = {
25864 (char *) "self",(char *) "dir", NULL
25865 };
25866
25867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25869 if (SWIG_arg_fail(1)) SWIG_fail;
25870 if (obj1) {
25871 {
25872 arg2 = (int)(SWIG_As_int(obj1));
25873 if (SWIG_arg_fail(2)) SWIG_fail;
25874 }
25875 }
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 (arg1)->CenterOnScreen(arg2);
25879
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 Py_INCREF(Py_None); resultobj = Py_None;
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25891 PyObject *resultobj;
25892 wxWindow *arg1 = (wxWindow *) 0 ;
25893 int arg2 = (int) wxBOTH ;
25894 PyObject * obj0 = 0 ;
25895 PyObject * obj1 = 0 ;
25896 char *kwnames[] = {
25897 (char *) "self",(char *) "dir", NULL
25898 };
25899
25900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25902 if (SWIG_arg_fail(1)) SWIG_fail;
25903 if (obj1) {
25904 {
25905 arg2 = (int)(SWIG_As_int(obj1));
25906 if (SWIG_arg_fail(2)) SWIG_fail;
25907 }
25908 }
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 (arg1)->CenterOnParent(arg2);
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 Py_INCREF(Py_None); resultobj = Py_None;
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj;
25925 wxWindow *arg1 = (wxWindow *) 0 ;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 (arg1)->Fit();
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 Py_INCREF(Py_None); resultobj = Py_None;
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxWindow *arg1 = (wxWindow *) 0 ;
25951 PyObject * obj0 = 0 ;
25952 char *kwnames[] = {
25953 (char *) "self", NULL
25954 };
25955
25956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25958 if (SWIG_arg_fail(1)) SWIG_fail;
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 (arg1)->FitInside();
25962
25963 wxPyEndAllowThreads(__tstate);
25964 if (PyErr_Occurred()) SWIG_fail;
25965 }
25966 Py_INCREF(Py_None); resultobj = Py_None;
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 int arg2 ;
25977 int arg3 ;
25978 int arg4 = (int) -1 ;
25979 int arg5 = (int) -1 ;
25980 int arg6 = (int) -1 ;
25981 int arg7 = (int) -1 ;
25982 PyObject * obj0 = 0 ;
25983 PyObject * obj1 = 0 ;
25984 PyObject * obj2 = 0 ;
25985 PyObject * obj3 = 0 ;
25986 PyObject * obj4 = 0 ;
25987 PyObject * obj5 = 0 ;
25988 PyObject * obj6 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 {
25997 arg2 = (int)(SWIG_As_int(obj1));
25998 if (SWIG_arg_fail(2)) SWIG_fail;
25999 }
26000 {
26001 arg3 = (int)(SWIG_As_int(obj2));
26002 if (SWIG_arg_fail(3)) SWIG_fail;
26003 }
26004 if (obj3) {
26005 {
26006 arg4 = (int)(SWIG_As_int(obj3));
26007 if (SWIG_arg_fail(4)) SWIG_fail;
26008 }
26009 }
26010 if (obj4) {
26011 {
26012 arg5 = (int)(SWIG_As_int(obj4));
26013 if (SWIG_arg_fail(5)) SWIG_fail;
26014 }
26015 }
26016 if (obj5) {
26017 {
26018 arg6 = (int)(SWIG_As_int(obj5));
26019 if (SWIG_arg_fail(6)) SWIG_fail;
26020 }
26021 }
26022 if (obj6) {
26023 {
26024 arg7 = (int)(SWIG_As_int(obj6));
26025 if (SWIG_arg_fail(7)) SWIG_fail;
26026 }
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 Py_INCREF(Py_None); resultobj = Py_None;
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26043 PyObject *resultobj;
26044 wxWindow *arg1 = (wxWindow *) 0 ;
26045 wxSize *arg2 = 0 ;
26046 wxSize const &arg3_defvalue = wxDefaultSize ;
26047 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26048 wxSize const &arg4_defvalue = wxDefaultSize ;
26049 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26050 wxSize temp2 ;
26051 wxSize temp3 ;
26052 wxSize temp4 ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 PyObject * obj2 = 0 ;
26056 PyObject * obj3 = 0 ;
26057 char *kwnames[] = {
26058 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26059 };
26060
26061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26063 if (SWIG_arg_fail(1)) SWIG_fail;
26064 {
26065 arg2 = &temp2;
26066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26067 }
26068 if (obj2) {
26069 {
26070 arg3 = &temp3;
26071 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26072 }
26073 }
26074 if (obj3) {
26075 {
26076 arg4 = &temp4;
26077 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26078 }
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26083
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 Py_INCREF(Py_None); resultobj = Py_None;
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj;
26096 wxWindow *arg1 = (wxWindow *) 0 ;
26097 int arg2 ;
26098 int arg3 ;
26099 int arg4 = (int) -1 ;
26100 int arg5 = (int) -1 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 PyObject * obj2 = 0 ;
26104 PyObject * obj3 = 0 ;
26105 PyObject * obj4 = 0 ;
26106 char *kwnames[] = {
26107 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26108 };
26109
26110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26112 if (SWIG_arg_fail(1)) SWIG_fail;
26113 {
26114 arg2 = (int)(SWIG_As_int(obj1));
26115 if (SWIG_arg_fail(2)) SWIG_fail;
26116 }
26117 {
26118 arg3 = (int)(SWIG_As_int(obj2));
26119 if (SWIG_arg_fail(3)) SWIG_fail;
26120 }
26121 if (obj3) {
26122 {
26123 arg4 = (int)(SWIG_As_int(obj3));
26124 if (SWIG_arg_fail(4)) SWIG_fail;
26125 }
26126 }
26127 if (obj4) {
26128 {
26129 arg5 = (int)(SWIG_As_int(obj4));
26130 if (SWIG_arg_fail(5)) SWIG_fail;
26131 }
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 wxSize *arg2 = 0 ;
26151 wxSize const &arg3_defvalue = wxDefaultSize ;
26152 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26153 wxSize temp2 ;
26154 wxSize temp3 ;
26155 PyObject * obj0 = 0 ;
26156 PyObject * obj1 = 0 ;
26157 PyObject * obj2 = 0 ;
26158 char *kwnames[] = {
26159 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26160 };
26161
26162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26164 if (SWIG_arg_fail(1)) SWIG_fail;
26165 {
26166 arg2 = &temp2;
26167 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26168 }
26169 if (obj2) {
26170 {
26171 arg3 = &temp3;
26172 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26173 }
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26178
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 Py_INCREF(Py_None); resultobj = Py_None;
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26190 PyObject *resultobj;
26191 wxWindow *arg1 = (wxWindow *) 0 ;
26192 wxSize result;
26193 PyObject * obj0 = 0 ;
26194 char *kwnames[] = {
26195 (char *) "self", NULL
26196 };
26197
26198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26200 if (SWIG_arg_fail(1)) SWIG_fail;
26201 {
26202 PyThreadState* __tstate = wxPyBeginAllowThreads();
26203 result = ((wxWindow const *)arg1)->GetMaxSize();
26204
26205 wxPyEndAllowThreads(__tstate);
26206 if (PyErr_Occurred()) SWIG_fail;
26207 }
26208 {
26209 wxSize * resultptr;
26210 resultptr = new wxSize((wxSize &)(result));
26211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26212 }
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj;
26221 wxWindow *arg1 = (wxWindow *) 0 ;
26222 wxSize result;
26223 PyObject * obj0 = 0 ;
26224 char *kwnames[] = {
26225 (char *) "self", NULL
26226 };
26227
26228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = ((wxWindow const *)arg1)->GetMinSize();
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 wxSize * resultptr;
26240 resultptr = new wxSize((wxSize &)(result));
26241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxWindow *arg1 = (wxWindow *) 0 ;
26252 wxSize *arg2 = 0 ;
26253 wxSize temp2 ;
26254 PyObject * obj0 = 0 ;
26255 PyObject * obj1 = 0 ;
26256 char *kwnames[] = {
26257 (char *) "self",(char *) "minSize", NULL
26258 };
26259
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 arg2 = &temp2;
26265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26266 }
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 (arg1)->SetMinSize((wxSize const &)*arg2);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 Py_INCREF(Py_None); resultobj = Py_None;
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj;
26283 wxWindow *arg1 = (wxWindow *) 0 ;
26284 wxSize *arg2 = 0 ;
26285 wxSize temp2 ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char *kwnames[] = {
26289 (char *) "self",(char *) "maxSize", NULL
26290 };
26291
26292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26294 if (SWIG_arg_fail(1)) SWIG_fail;
26295 {
26296 arg2 = &temp2;
26297 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26298 }
26299 {
26300 PyThreadState* __tstate = wxPyBeginAllowThreads();
26301 (arg1)->SetMaxSize((wxSize const &)*arg2);
26302
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 Py_INCREF(Py_None); resultobj = Py_None;
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj;
26315 wxWindow *arg1 = (wxWindow *) 0 ;
26316 int result;
26317 PyObject * obj0 = 0 ;
26318 char *kwnames[] = {
26319 (char *) "self", NULL
26320 };
26321
26322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26324 if (SWIG_arg_fail(1)) SWIG_fail;
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26328
26329 wxPyEndAllowThreads(__tstate);
26330 if (PyErr_Occurred()) SWIG_fail;
26331 }
26332 {
26333 resultobj = SWIG_From_int((int)(result));
26334 }
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxWindow *arg1 = (wxWindow *) 0 ;
26344 int result;
26345 PyObject * obj0 = 0 ;
26346 char *kwnames[] = {
26347 (char *) "self", NULL
26348 };
26349
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26352 if (SWIG_arg_fail(1)) SWIG_fail;
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26356
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = SWIG_From_int((int)(result));
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj;
26371 wxWindow *arg1 = (wxWindow *) 0 ;
26372 int result;
26373 PyObject * obj0 = 0 ;
26374 char *kwnames[] = {
26375 (char *) "self", NULL
26376 };
26377
26378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26380 if (SWIG_arg_fail(1)) SWIG_fail;
26381 {
26382 PyThreadState* __tstate = wxPyBeginAllowThreads();
26383 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26384
26385 wxPyEndAllowThreads(__tstate);
26386 if (PyErr_Occurred()) SWIG_fail;
26387 }
26388 {
26389 resultobj = SWIG_From_int((int)(result));
26390 }
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj;
26399 wxWindow *arg1 = (wxWindow *) 0 ;
26400 int result;
26401 PyObject * obj0 = 0 ;
26402 char *kwnames[] = {
26403 (char *) "self", NULL
26404 };
26405
26406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26408 if (SWIG_arg_fail(1)) SWIG_fail;
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 resultobj = SWIG_From_int((int)(result));
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxWindow *arg1 = (wxWindow *) 0 ;
26428 wxSize *arg2 = 0 ;
26429 wxSize temp2 ;
26430 PyObject * obj0 = 0 ;
26431 PyObject * obj1 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self",(char *) "size", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 arg2 = &temp2;
26441 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 int arg2 ;
26461 int arg3 ;
26462 PyObject * obj0 = 0 ;
26463 PyObject * obj1 = 0 ;
26464 PyObject * obj2 = 0 ;
26465 char *kwnames[] = {
26466 (char *) "self",(char *) "w",(char *) "h", NULL
26467 };
26468
26469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26471 if (SWIG_arg_fail(1)) SWIG_fail;
26472 {
26473 arg2 = (int)(SWIG_As_int(obj1));
26474 if (SWIG_arg_fail(2)) SWIG_fail;
26475 }
26476 {
26477 arg3 = (int)(SWIG_As_int(obj2));
26478 if (SWIG_arg_fail(3)) SWIG_fail;
26479 }
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 (arg1)->SetVirtualSize(arg2,arg3);
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 Py_INCREF(Py_None); resultobj = Py_None;
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxWindow *arg1 = (wxWindow *) 0 ;
26497 wxSize result;
26498 PyObject * obj0 = 0 ;
26499 char *kwnames[] = {
26500 (char *) "self", NULL
26501 };
26502
26503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26505 if (SWIG_arg_fail(1)) SWIG_fail;
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = ((wxWindow const *)arg1)->GetVirtualSize();
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 {
26514 wxSize * resultptr;
26515 resultptr = new wxSize((wxSize &)(result));
26516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26525 PyObject *resultobj;
26526 wxWindow *arg1 = (wxWindow *) 0 ;
26527 int *arg2 = (int *) 0 ;
26528 int *arg3 = (int *) 0 ;
26529 int temp2 ;
26530 int res2 = 0 ;
26531 int temp3 ;
26532 int res3 = 0 ;
26533 PyObject * obj0 = 0 ;
26534 char *kwnames[] = {
26535 (char *) "self", NULL
26536 };
26537
26538 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26539 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26542 if (SWIG_arg_fail(1)) SWIG_fail;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 Py_INCREF(Py_None); resultobj = Py_None;
26551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26552 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26554 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj;
26563 wxWindow *arg1 = (wxWindow *) 0 ;
26564 wxSize result;
26565 PyObject * obj0 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(1)) SWIG_fail;
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26576
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 {
26581 wxSize * resultptr;
26582 resultptr = new wxSize((wxSize &)(result));
26583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26584 }
26585 return resultobj;
26586 fail:
26587 return NULL;
26588 }
26589
26590
26591 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj;
26593 wxWindow *arg1 = (wxWindow *) 0 ;
26594 bool arg2 = (bool) true ;
26595 bool result;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char *kwnames[] = {
26599 (char *) "self",(char *) "show", NULL
26600 };
26601
26602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26604 if (SWIG_arg_fail(1)) SWIG_fail;
26605 if (obj1) {
26606 {
26607 arg2 = (bool)(SWIG_As_bool(obj1));
26608 if (SWIG_arg_fail(2)) SWIG_fail;
26609 }
26610 }
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 result = (bool)(arg1)->Show(arg2);
26614
26615 wxPyEndAllowThreads(__tstate);
26616 if (PyErr_Occurred()) SWIG_fail;
26617 }
26618 {
26619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26620 }
26621 return resultobj;
26622 fail:
26623 return NULL;
26624 }
26625
26626
26627 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj;
26629 wxWindow *arg1 = (wxWindow *) 0 ;
26630 bool result;
26631 PyObject * obj0 = 0 ;
26632 char *kwnames[] = {
26633 (char *) "self", NULL
26634 };
26635
26636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26638 if (SWIG_arg_fail(1)) SWIG_fail;
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (bool)(arg1)->Hide();
26642
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 {
26647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26648 }
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj;
26657 wxWindow *arg1 = (wxWindow *) 0 ;
26658 bool arg2 = (bool) true ;
26659 bool result;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662 char *kwnames[] = {
26663 (char *) "self",(char *) "enable", NULL
26664 };
26665
26666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26668 if (SWIG_arg_fail(1)) SWIG_fail;
26669 if (obj1) {
26670 {
26671 arg2 = (bool)(SWIG_As_bool(obj1));
26672 if (SWIG_arg_fail(2)) SWIG_fail;
26673 }
26674 }
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 result = (bool)(arg1)->Enable(arg2);
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 {
26683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26684 }
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj;
26693 wxWindow *arg1 = (wxWindow *) 0 ;
26694 bool result;
26695 PyObject * obj0 = 0 ;
26696 char *kwnames[] = {
26697 (char *) "self", NULL
26698 };
26699
26700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26702 if (SWIG_arg_fail(1)) SWIG_fail;
26703 {
26704 PyThreadState* __tstate = wxPyBeginAllowThreads();
26705 result = (bool)(arg1)->Disable();
26706
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 {
26711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26712 }
26713 return resultobj;
26714 fail:
26715 return NULL;
26716 }
26717
26718
26719 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 bool result;
26723 PyObject * obj0 = 0 ;
26724 char *kwnames[] = {
26725 (char *) "self", NULL
26726 };
26727
26728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26730 if (SWIG_arg_fail(1)) SWIG_fail;
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (bool)((wxWindow const *)arg1)->IsShown();
26734
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj;
26749 wxWindow *arg1 = (wxWindow *) 0 ;
26750 bool result;
26751 PyObject * obj0 = 0 ;
26752 char *kwnames[] = {
26753 (char *) "self", NULL
26754 };
26755
26756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26758 if (SWIG_arg_fail(1)) SWIG_fail;
26759 {
26760 PyThreadState* __tstate = wxPyBeginAllowThreads();
26761 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26762
26763 wxPyEndAllowThreads(__tstate);
26764 if (PyErr_Occurred()) SWIG_fail;
26765 }
26766 {
26767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26768 }
26769 return resultobj;
26770 fail:
26771 return NULL;
26772 }
26773
26774
26775 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26776 PyObject *resultobj;
26777 wxWindow *arg1 = (wxWindow *) 0 ;
26778 long arg2 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char *kwnames[] = {
26782 (char *) "self",(char *) "style", NULL
26783 };
26784
26785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26787 if (SWIG_arg_fail(1)) SWIG_fail;
26788 {
26789 arg2 = (long)(SWIG_As_long(obj1));
26790 if (SWIG_arg_fail(2)) SWIG_fail;
26791 }
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 (arg1)->SetWindowStyleFlag(arg2);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 Py_INCREF(Py_None); resultobj = Py_None;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj;
26808 wxWindow *arg1 = (wxWindow *) 0 ;
26809 long result;
26810 PyObject * obj0 = 0 ;
26811 char *kwnames[] = {
26812 (char *) "self", NULL
26813 };
26814
26815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26817 if (SWIG_arg_fail(1)) SWIG_fail;
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26821
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 {
26826 resultobj = SWIG_From_long((long)(result));
26827 }
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj;
26836 wxWindow *arg1 = (wxWindow *) 0 ;
26837 int arg2 ;
26838 bool result;
26839 PyObject * obj0 = 0 ;
26840 PyObject * obj1 = 0 ;
26841 char *kwnames[] = {
26842 (char *) "self",(char *) "flag", NULL
26843 };
26844
26845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26847 if (SWIG_arg_fail(1)) SWIG_fail;
26848 {
26849 arg2 = (int)(SWIG_As_int(obj1));
26850 if (SWIG_arg_fail(2)) SWIG_fail;
26851 }
26852 {
26853 PyThreadState* __tstate = wxPyBeginAllowThreads();
26854 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26855
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 {
26860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26861 }
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj;
26870 wxWindow *arg1 = (wxWindow *) 0 ;
26871 bool result;
26872 PyObject * obj0 = 0 ;
26873 char *kwnames[] = {
26874 (char *) "self", NULL
26875 };
26876
26877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26879 if (SWIG_arg_fail(1)) SWIG_fail;
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = (bool)((wxWindow const *)arg1)->IsRetained();
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 long arg2 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 char *kwnames[] = {
26903 (char *) "self",(char *) "exStyle", NULL
26904 };
26905
26906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26908 if (SWIG_arg_fail(1)) SWIG_fail;
26909 {
26910 arg2 = (long)(SWIG_As_long(obj1));
26911 if (SWIG_arg_fail(2)) SWIG_fail;
26912 }
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 (arg1)->SetExtraStyle(arg2);
26916
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 Py_INCREF(Py_None); resultobj = Py_None;
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26928 PyObject *resultobj;
26929 wxWindow *arg1 = (wxWindow *) 0 ;
26930 long result;
26931 PyObject * obj0 = 0 ;
26932 char *kwnames[] = {
26933 (char *) "self", NULL
26934 };
26935
26936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26938 if (SWIG_arg_fail(1)) SWIG_fail;
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 {
26947 resultobj = SWIG_From_long((long)(result));
26948 }
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj;
26957 wxWindow *arg1 = (wxWindow *) 0 ;
26958 bool arg2 = (bool) true ;
26959 PyObject * obj0 = 0 ;
26960 PyObject * obj1 = 0 ;
26961 char *kwnames[] = {
26962 (char *) "self",(char *) "modal", NULL
26963 };
26964
26965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26967 if (SWIG_arg_fail(1)) SWIG_fail;
26968 if (obj1) {
26969 {
26970 arg2 = (bool)(SWIG_As_bool(obj1));
26971 if (SWIG_arg_fail(2)) SWIG_fail;
26972 }
26973 }
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 (arg1)->MakeModal(arg2);
26977
26978 wxPyEndAllowThreads(__tstate);
26979 if (PyErr_Occurred()) SWIG_fail;
26980 }
26981 Py_INCREF(Py_None); resultobj = Py_None;
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26989 PyObject *resultobj;
26990 wxWindow *arg1 = (wxWindow *) 0 ;
26991 bool arg2 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self",(char *) "enableTheme", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 arg2 = (bool)(SWIG_As_bool(obj1));
27003 if (SWIG_arg_fail(2)) SWIG_fail;
27004 }
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 (arg1)->SetThemeEnabled(arg2);
27008
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 Py_INCREF(Py_None); resultobj = Py_None;
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxWindow *arg1 = (wxWindow *) 0 ;
27022 bool result;
27023 PyObject * obj0 = 0 ;
27024 char *kwnames[] = {
27025 (char *) "self", NULL
27026 };
27027
27028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27030 if (SWIG_arg_fail(1)) SWIG_fail;
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 {
27039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27040 }
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj;
27049 wxWindow *arg1 = (wxWindow *) 0 ;
27050 PyObject * obj0 = 0 ;
27051 char *kwnames[] = {
27052 (char *) "self", NULL
27053 };
27054
27055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27057 if (SWIG_arg_fail(1)) SWIG_fail;
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 (arg1)->SetFocus();
27061
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 Py_INCREF(Py_None); resultobj = Py_None;
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27073 PyObject *resultobj;
27074 wxWindow *arg1 = (wxWindow *) 0 ;
27075 PyObject * obj0 = 0 ;
27076 char *kwnames[] = {
27077 (char *) "self", NULL
27078 };
27079
27080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27082 if (SWIG_arg_fail(1)) SWIG_fail;
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 (arg1)->SetFocusFromKbd();
27086
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 Py_INCREF(Py_None); resultobj = Py_None;
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj;
27099 wxWindow *result;
27100 char *kwnames[] = {
27101 NULL
27102 };
27103
27104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27105 {
27106 if (!wxPyCheckForApp()) SWIG_fail;
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 result = (wxWindow *)wxWindow::FindFocus();
27109
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 {
27114 resultobj = wxPyMake_wxObject(result, 0);
27115 }
27116 return resultobj;
27117 fail:
27118 return NULL;
27119 }
27120
27121
27122 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27123 PyObject *resultobj;
27124 wxWindow *arg1 = (wxWindow *) 0 ;
27125 bool result;
27126 PyObject * obj0 = 0 ;
27127 char *kwnames[] = {
27128 (char *) "self", NULL
27129 };
27130
27131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27133 if (SWIG_arg_fail(1)) SWIG_fail;
27134 {
27135 PyThreadState* __tstate = wxPyBeginAllowThreads();
27136 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27137
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 {
27142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27143 }
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj;
27152 wxWindow *arg1 = (wxWindow *) 0 ;
27153 bool result;
27154 PyObject * obj0 = 0 ;
27155 char *kwnames[] = {
27156 (char *) "self", NULL
27157 };
27158
27159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27161 if (SWIG_arg_fail(1)) SWIG_fail;
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27179 PyObject *resultobj;
27180 wxWindow *arg1 = (wxWindow *) 0 ;
27181 wxWindow *result;
27182 PyObject * obj0 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27193
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 resultobj = wxPyMake_wxObject(result, 0);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27207 PyObject *resultobj;
27208 wxWindow *arg1 = (wxWindow *) 0 ;
27209 wxWindow *arg2 = (wxWindow *) 0 ;
27210 wxWindow *result;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "self",(char *) "child", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27225
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 {
27230 resultobj = wxPyMake_wxObject(result, 0);
27231 }
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj;
27240 wxWindow *arg1 = (wxWindow *) 0 ;
27241 wxWindow *arg2 = (wxWindow *) 0 ;
27242 PyObject * obj0 = 0 ;
27243 PyObject * obj1 = 0 ;
27244 char *kwnames[] = {
27245 (char *) "self",(char *) "win", NULL
27246 };
27247
27248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(1)) SWIG_fail;
27251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(2)) SWIG_fail;
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 (arg1)->SetTmpDefaultItem(arg2);
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 Py_INCREF(Py_None); resultobj = Py_None;
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj;
27269 wxWindow *arg1 = (wxWindow *) 0 ;
27270 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27271 bool result;
27272 PyObject * obj0 = 0 ;
27273 PyObject * obj1 = 0 ;
27274 char *kwnames[] = {
27275 (char *) "self",(char *) "flags", NULL
27276 };
27277
27278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27280 if (SWIG_arg_fail(1)) SWIG_fail;
27281 if (obj1) {
27282 {
27283 arg2 = (int)(SWIG_As_int(obj1));
27284 if (SWIG_arg_fail(2)) SWIG_fail;
27285 }
27286 }
27287 {
27288 PyThreadState* __tstate = wxPyBeginAllowThreads();
27289 result = (bool)(arg1)->Navigate(arg2);
27290
27291 wxPyEndAllowThreads(__tstate);
27292 if (PyErr_Occurred()) SWIG_fail;
27293 }
27294 {
27295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27296 }
27297 return resultobj;
27298 fail:
27299 return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxWindow *arg1 = (wxWindow *) 0 ;
27306 wxWindow *arg2 = (wxWindow *) 0 ;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self",(char *) "win", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(2)) SWIG_fail;
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 (arg1)->MoveAfterInTabOrder(arg2);
27321
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 Py_INCREF(Py_None); resultobj = Py_None;
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxWindow *arg1 = (wxWindow *) 0 ;
27335 wxWindow *arg2 = (wxWindow *) 0 ;
27336 PyObject * obj0 = 0 ;
27337 PyObject * obj1 = 0 ;
27338 char *kwnames[] = {
27339 (char *) "self",(char *) "win", NULL
27340 };
27341
27342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27344 if (SWIG_arg_fail(1)) SWIG_fail;
27345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27346 if (SWIG_arg_fail(2)) SWIG_fail;
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 (arg1)->MoveBeforeInTabOrder(arg2);
27350
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 Py_INCREF(Py_None); resultobj = Py_None;
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27362 PyObject *resultobj;
27363 wxWindow *arg1 = (wxWindow *) 0 ;
27364 PyObject *result;
27365 PyObject * obj0 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 result = (PyObject *)wxWindow_GetChildren(arg1);
27376
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = result;
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj;
27389 wxWindow *arg1 = (wxWindow *) 0 ;
27390 wxWindow *result;
27391 PyObject * obj0 = 0 ;
27392 char *kwnames[] = {
27393 (char *) "self", NULL
27394 };
27395
27396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27398 if (SWIG_arg_fail(1)) SWIG_fail;
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27402
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 {
27407 resultobj = wxPyMake_wxObject(result, 0);
27408 }
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj;
27417 wxWindow *arg1 = (wxWindow *) 0 ;
27418 wxWindow *result;
27419 PyObject * obj0 = 0 ;
27420 char *kwnames[] = {
27421 (char *) "self", NULL
27422 };
27423
27424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27426 if (SWIG_arg_fail(1)) SWIG_fail;
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27430
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 {
27435 resultobj = wxPyMake_wxObject(result, 0);
27436 }
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27444 PyObject *resultobj;
27445 wxWindow *arg1 = (wxWindow *) 0 ;
27446 bool result;
27447 PyObject * obj0 = 0 ;
27448 char *kwnames[] = {
27449 (char *) "self", NULL
27450 };
27451
27452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27454 if (SWIG_arg_fail(1)) SWIG_fail;
27455 {
27456 PyThreadState* __tstate = wxPyBeginAllowThreads();
27457 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27458
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 {
27463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27464 }
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27472 PyObject *resultobj;
27473 wxWindow *arg1 = (wxWindow *) 0 ;
27474 wxWindow *arg2 = (wxWindow *) 0 ;
27475 bool result;
27476 PyObject * obj0 = 0 ;
27477 PyObject * obj1 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self",(char *) "newParent", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(1)) SWIG_fail;
27485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(2)) SWIG_fail;
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 result = (bool)(arg1)->Reparent(arg2);
27490
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 {
27495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27496 }
27497 return resultobj;
27498 fail:
27499 return NULL;
27500 }
27501
27502
27503 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27504 PyObject *resultobj;
27505 wxWindow *arg1 = (wxWindow *) 0 ;
27506 wxWindow *arg2 = (wxWindow *) 0 ;
27507 PyObject * obj0 = 0 ;
27508 PyObject * obj1 = 0 ;
27509 char *kwnames[] = {
27510 (char *) "self",(char *) "child", NULL
27511 };
27512
27513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(2)) SWIG_fail;
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 (arg1)->AddChild(arg2);
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 Py_INCREF(Py_None); resultobj = Py_None;
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj;
27534 wxWindow *arg1 = (wxWindow *) 0 ;
27535 wxWindow *arg2 = (wxWindow *) 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char *kwnames[] = {
27539 (char *) "self",(char *) "child", NULL
27540 };
27541
27542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27544 if (SWIG_arg_fail(1)) SWIG_fail;
27545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(2)) SWIG_fail;
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->RemoveChild(arg2);
27550
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 Py_INCREF(Py_None); resultobj = Py_None;
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27562 PyObject *resultobj;
27563 wxWindow *arg1 = (wxWindow *) 0 ;
27564 long arg2 ;
27565 wxWindow *result;
27566 PyObject * obj0 = 0 ;
27567 PyObject * obj1 = 0 ;
27568 char *kwnames[] = {
27569 (char *) "self",(char *) "winid", NULL
27570 };
27571
27572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27574 if (SWIG_arg_fail(1)) SWIG_fail;
27575 {
27576 arg2 = (long)(SWIG_As_long(obj1));
27577 if (SWIG_arg_fail(2)) SWIG_fail;
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = (wxWindow *)(arg1)->FindWindow(arg2);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = wxPyMake_wxObject(result, 0);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj;
27597 wxWindow *arg1 = (wxWindow *) 0 ;
27598 wxString *arg2 = 0 ;
27599 wxWindow *result;
27600 bool temp2 = false ;
27601 PyObject * obj0 = 0 ;
27602 PyObject * obj1 = 0 ;
27603 char *kwnames[] = {
27604 (char *) "self",(char *) "name", NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27609 if (SWIG_arg_fail(1)) SWIG_fail;
27610 {
27611 arg2 = wxString_in_helper(obj1);
27612 if (arg2 == NULL) SWIG_fail;
27613 temp2 = true;
27614 }
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 {
27623 resultobj = wxPyMake_wxObject(result, 0);
27624 }
27625 {
27626 if (temp2)
27627 delete arg2;
27628 }
27629 return resultobj;
27630 fail:
27631 {
27632 if (temp2)
27633 delete arg2;
27634 }
27635 return NULL;
27636 }
27637
27638
27639 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj;
27641 wxWindow *arg1 = (wxWindow *) 0 ;
27642 wxEvtHandler *result;
27643 PyObject * obj0 = 0 ;
27644 char *kwnames[] = {
27645 (char *) "self", NULL
27646 };
27647
27648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27650 if (SWIG_arg_fail(1)) SWIG_fail;
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27654
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 {
27659 resultobj = wxPyMake_wxObject(result, 0);
27660 }
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxWindow *arg1 = (wxWindow *) 0 ;
27670 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self",(char *) "handler", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(1)) SWIG_fail;
27680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(2)) SWIG_fail;
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 (arg1)->SetEventHandler(arg2);
27685
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 Py_INCREF(Py_None); resultobj = Py_None;
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxWindow *arg1 = (wxWindow *) 0 ;
27699 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27700 PyObject * obj0 = 0 ;
27701 PyObject * obj1 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "self",(char *) "handler", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(2)) SWIG_fail;
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->PushEventHandler(arg2);
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 Py_INCREF(Py_None); resultobj = Py_None;
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 bool arg2 = (bool) false ;
27729 wxEvtHandler *result;
27730 PyObject * obj0 = 0 ;
27731 PyObject * obj1 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "self",(char *) "deleteHandler", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) 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 if (obj1) {
27740 {
27741 arg2 = (bool)(SWIG_As_bool(obj1));
27742 if (SWIG_arg_fail(2)) SWIG_fail;
27743 }
27744 }
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = wxPyMake_wxObject(result, 0);
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj;
27763 wxWindow *arg1 = (wxWindow *) 0 ;
27764 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27765 bool result;
27766 PyObject * obj0 = 0 ;
27767 PyObject * obj1 = 0 ;
27768 char *kwnames[] = {
27769 (char *) "self",(char *) "handler", NULL
27770 };
27771
27772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(2)) SWIG_fail;
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (bool)(arg1)->RemoveEventHandler(arg2);
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj;
27795 wxWindow *arg1 = (wxWindow *) 0 ;
27796 wxValidator *arg2 = 0 ;
27797 PyObject * obj0 = 0 ;
27798 PyObject * obj1 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self",(char *) "validator", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 {
27807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27808 if (SWIG_arg_fail(2)) SWIG_fail;
27809 if (arg2 == NULL) {
27810 SWIG_null_ref("wxValidator");
27811 }
27812 if (SWIG_arg_fail(2)) SWIG_fail;
27813 }
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->SetValidator((wxValidator const &)*arg2);
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 Py_INCREF(Py_None); resultobj = Py_None;
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj;
27830 wxWindow *arg1 = (wxWindow *) 0 ;
27831 wxValidator *result;
27832 PyObject * obj0 = 0 ;
27833 char *kwnames[] = {
27834 (char *) "self", NULL
27835 };
27836
27837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (wxValidator *)(arg1)->GetValidator();
27843
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 {
27848 resultobj = wxPyMake_wxObject(result, 0);
27849 }
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxWindow *arg1 = (wxWindow *) 0 ;
27859 bool result;
27860 PyObject * obj0 = 0 ;
27861 char *kwnames[] = {
27862 (char *) "self", NULL
27863 };
27864
27865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (bool)(arg1)->Validate();
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj;
27886 wxWindow *arg1 = (wxWindow *) 0 ;
27887 bool result;
27888 PyObject * obj0 = 0 ;
27889 char *kwnames[] = {
27890 (char *) "self", NULL
27891 };
27892
27893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27895 if (SWIG_arg_fail(1)) SWIG_fail;
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (bool)(arg1)->TransferDataToWindow();
27899
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj;
27914 wxWindow *arg1 = (wxWindow *) 0 ;
27915 bool result;
27916 PyObject * obj0 = 0 ;
27917 char *kwnames[] = {
27918 (char *) "self", NULL
27919 };
27920
27921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27923 if (SWIG_arg_fail(1)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (bool)(arg1)->TransferDataFromWindow();
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 {
27932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27933 }
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27941 PyObject *resultobj;
27942 wxWindow *arg1 = (wxWindow *) 0 ;
27943 PyObject * obj0 = 0 ;
27944 char *kwnames[] = {
27945 (char *) "self", NULL
27946 };
27947
27948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27950 if (SWIG_arg_fail(1)) SWIG_fail;
27951 {
27952 PyThreadState* __tstate = wxPyBeginAllowThreads();
27953 (arg1)->InitDialog();
27954
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 Py_INCREF(Py_None); resultobj = Py_None;
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxAcceleratorTable *arg2 = 0 ;
27969 PyObject * obj0 = 0 ;
27970 PyObject * obj1 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "self",(char *) "accel", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 {
27979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27980 if (SWIG_arg_fail(2)) SWIG_fail;
27981 if (arg2 == NULL) {
27982 SWIG_null_ref("wxAcceleratorTable");
27983 }
27984 if (SWIG_arg_fail(2)) SWIG_fail;
27985 }
27986 {
27987 PyThreadState* __tstate = wxPyBeginAllowThreads();
27988 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27989
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 Py_INCREF(Py_None); resultobj = Py_None;
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj;
28002 wxWindow *arg1 = (wxWindow *) 0 ;
28003 wxAcceleratorTable *result;
28004 PyObject * obj0 = 0 ;
28005 char *kwnames[] = {
28006 (char *) "self", NULL
28007 };
28008
28009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(1)) SWIG_fail;
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28015
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj;
28028 wxWindow *arg1 = (wxWindow *) 0 ;
28029 int arg2 ;
28030 int arg3 ;
28031 int arg4 ;
28032 bool result;
28033 PyObject * obj0 = 0 ;
28034 PyObject * obj1 = 0 ;
28035 PyObject * obj2 = 0 ;
28036 PyObject * obj3 = 0 ;
28037 char *kwnames[] = {
28038 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28039 };
28040
28041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28043 if (SWIG_arg_fail(1)) SWIG_fail;
28044 {
28045 arg2 = (int)(SWIG_As_int(obj1));
28046 if (SWIG_arg_fail(2)) SWIG_fail;
28047 }
28048 {
28049 arg3 = (int)(SWIG_As_int(obj2));
28050 if (SWIG_arg_fail(3)) SWIG_fail;
28051 }
28052 {
28053 arg4 = (int)(SWIG_As_int(obj3));
28054 if (SWIG_arg_fail(4)) SWIG_fail;
28055 }
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28059
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 {
28064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28065 }
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj;
28074 wxWindow *arg1 = (wxWindow *) 0 ;
28075 int arg2 ;
28076 bool result;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char *kwnames[] = {
28080 (char *) "self",(char *) "hotkeyId", NULL
28081 };
28082
28083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28085 if (SWIG_arg_fail(1)) SWIG_fail;
28086 {
28087 arg2 = (int)(SWIG_As_int(obj1));
28088 if (SWIG_arg_fail(2)) SWIG_fail;
28089 }
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 {
28098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28099 }
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj;
28108 wxWindow *arg1 = (wxWindow *) 0 ;
28109 wxPoint *arg2 = 0 ;
28110 wxPoint result;
28111 wxPoint temp2 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self",(char *) "pt", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 arg2 = &temp2;
28123 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28124 }
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28128
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 {
28133 wxPoint * resultptr;
28134 resultptr = new wxPoint((wxPoint &)(result));
28135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28136 }
28137 return resultobj;
28138 fail:
28139 return NULL;
28140 }
28141
28142
28143 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28144 PyObject *resultobj;
28145 wxWindow *arg1 = (wxWindow *) 0 ;
28146 wxSize *arg2 = 0 ;
28147 wxSize result;
28148 wxSize temp2 ;
28149 PyObject * obj0 = 0 ;
28150 PyObject * obj1 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self",(char *) "sz", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 arg2 = &temp2;
28160 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 {
28170 wxSize * resultptr;
28171 resultptr = new wxSize((wxSize &)(result));
28172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 wxPoint *arg2 = 0 ;
28184 wxPoint result;
28185 wxPoint temp2 ;
28186 PyObject * obj0 = 0 ;
28187 PyObject * obj1 = 0 ;
28188 char *kwnames[] = {
28189 (char *) "self",(char *) "pt", NULL
28190 };
28191
28192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28194 if (SWIG_arg_fail(1)) SWIG_fail;
28195 {
28196 arg2 = &temp2;
28197 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28198 }
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28202
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 {
28207 wxPoint * resultptr;
28208 resultptr = new wxPoint((wxPoint &)(result));
28209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28210 }
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28218 PyObject *resultobj;
28219 wxWindow *arg1 = (wxWindow *) 0 ;
28220 wxSize *arg2 = 0 ;
28221 wxSize result;
28222 wxSize temp2 ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char *kwnames[] = {
28226 (char *) "self",(char *) "sz", NULL
28227 };
28228
28229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28231 if (SWIG_arg_fail(1)) SWIG_fail;
28232 {
28233 arg2 = &temp2;
28234 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28235 }
28236 {
28237 PyThreadState* __tstate = wxPyBeginAllowThreads();
28238 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28239
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 {
28244 wxSize * resultptr;
28245 resultptr = new wxSize((wxSize &)(result));
28246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 wxPoint *arg2 = 0 ;
28258 wxPoint result;
28259 wxPoint temp2 ;
28260 PyObject * obj0 = 0 ;
28261 PyObject * obj1 = 0 ;
28262 char *kwnames[] = {
28263 (char *) "self",(char *) "pt", NULL
28264 };
28265
28266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28268 if (SWIG_arg_fail(1)) SWIG_fail;
28269 {
28270 arg2 = &temp2;
28271 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28272 }
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 {
28281 wxPoint * resultptr;
28282 resultptr = new wxPoint((wxPoint &)(result));
28283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28284 }
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 wxSize *arg2 = 0 ;
28295 wxSize result;
28296 wxSize temp2 ;
28297 PyObject * obj0 = 0 ;
28298 PyObject * obj1 = 0 ;
28299 char *kwnames[] = {
28300 (char *) "self",(char *) "sz", NULL
28301 };
28302
28303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28305 if (SWIG_arg_fail(1)) SWIG_fail;
28306 {
28307 arg2 = &temp2;
28308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28309 }
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 wxSize * resultptr;
28319 resultptr = new wxSize((wxSize &)(result));
28320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28329 PyObject *resultobj;
28330 wxWindow *arg1 = (wxWindow *) 0 ;
28331 int arg2 ;
28332 int arg3 ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 PyObject * obj2 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self",(char *) "x",(char *) "y", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 {
28344 arg2 = (int)(SWIG_As_int(obj1));
28345 if (SWIG_arg_fail(2)) SWIG_fail;
28346 }
28347 {
28348 arg3 = (int)(SWIG_As_int(obj2));
28349 if (SWIG_arg_fail(3)) SWIG_fail;
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 (arg1)->WarpPointer(arg2,arg3);
28354
28355 wxPyEndAllowThreads(__tstate);
28356 if (PyErr_Occurred()) SWIG_fail;
28357 }
28358 Py_INCREF(Py_None); resultobj = Py_None;
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxWindow *arg1 = (wxWindow *) 0 ;
28368 PyObject * obj0 = 0 ;
28369 char *kwnames[] = {
28370 (char *) "self", NULL
28371 };
28372
28373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28375 if (SWIG_arg_fail(1)) SWIG_fail;
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 (arg1)->CaptureMouse();
28379
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 Py_INCREF(Py_None); resultobj = Py_None;
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxWindow *arg1 = (wxWindow *) 0 ;
28393 PyObject * obj0 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "self", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 (arg1)->ReleaseMouse();
28404
28405 wxPyEndAllowThreads(__tstate);
28406 if (PyErr_Occurred()) SWIG_fail;
28407 }
28408 Py_INCREF(Py_None); resultobj = Py_None;
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj;
28417 wxWindow *result;
28418 char *kwnames[] = {
28419 NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28423 {
28424 if (!wxPyCheckForApp()) SWIG_fail;
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (wxWindow *)wxWindow::GetCapture();
28427
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 {
28432 resultobj = wxPyMake_wxObject(result, 0);
28433 }
28434 return resultobj;
28435 fail:
28436 return NULL;
28437 }
28438
28439
28440 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28441 PyObject *resultobj;
28442 wxWindow *arg1 = (wxWindow *) 0 ;
28443 bool result;
28444 PyObject * obj0 = 0 ;
28445 char *kwnames[] = {
28446 (char *) "self", NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28451 if (SWIG_arg_fail(1)) SWIG_fail;
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 result = (bool)((wxWindow const *)arg1)->HasCapture();
28455
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj;
28470 wxWindow *arg1 = (wxWindow *) 0 ;
28471 bool arg2 = (bool) true ;
28472 wxRect *arg3 = (wxRect *) NULL ;
28473 PyObject * obj0 = 0 ;
28474 PyObject * obj1 = 0 ;
28475 PyObject * obj2 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 if (obj1) {
28484 {
28485 arg2 = (bool)(SWIG_As_bool(obj1));
28486 if (SWIG_arg_fail(2)) SWIG_fail;
28487 }
28488 }
28489 if (obj2) {
28490 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(3)) SWIG_fail;
28492 }
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28496
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 Py_INCREF(Py_None); resultobj = Py_None;
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj;
28509 wxWindow *arg1 = (wxWindow *) 0 ;
28510 wxRect *arg2 = 0 ;
28511 wxRect temp2 ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self",(char *) "rect", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 {
28522 arg2 = &temp2;
28523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 (arg1)->RefreshRect((wxRect const &)*arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 Py_INCREF(Py_None); resultobj = Py_None;
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj;
28541 wxWindow *arg1 = (wxWindow *) 0 ;
28542 PyObject * obj0 = 0 ;
28543 char *kwnames[] = {
28544 (char *) "self", NULL
28545 };
28546
28547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28549 if (SWIG_arg_fail(1)) SWIG_fail;
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 (arg1)->Update();
28553
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 Py_INCREF(Py_None); resultobj = Py_None;
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28565 PyObject *resultobj;
28566 wxWindow *arg1 = (wxWindow *) 0 ;
28567 PyObject * obj0 = 0 ;
28568 char *kwnames[] = {
28569 (char *) "self", NULL
28570 };
28571
28572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(1)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 (arg1)->ClearBackground();
28578
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 Py_INCREF(Py_None); resultobj = Py_None;
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28590 PyObject *resultobj;
28591 wxWindow *arg1 = (wxWindow *) 0 ;
28592 PyObject * obj0 = 0 ;
28593 char *kwnames[] = {
28594 (char *) "self", NULL
28595 };
28596
28597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28599 if (SWIG_arg_fail(1)) SWIG_fail;
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->Freeze();
28603
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 Py_INCREF(Py_None); resultobj = Py_None;
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxWindow *arg1 = (wxWindow *) 0 ;
28617 PyObject * obj0 = 0 ;
28618 char *kwnames[] = {
28619 (char *) "self", NULL
28620 };
28621
28622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28624 if (SWIG_arg_fail(1)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 (arg1)->Thaw();
28628
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 Py_INCREF(Py_None); resultobj = Py_None;
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 wxDC *arg2 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 char *kwnames[] = {
28646 (char *) "self",(char *) "dc", NULL
28647 };
28648
28649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28651 if (SWIG_arg_fail(1)) SWIG_fail;
28652 {
28653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(2)) SWIG_fail;
28655 if (arg2 == NULL) {
28656 SWIG_null_ref("wxDC");
28657 }
28658 if (SWIG_arg_fail(2)) SWIG_fail;
28659 }
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 (arg1)->PrepareDC(*arg2);
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_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj;
28676 wxWindow *arg1 = (wxWindow *) 0 ;
28677 wxRegion *result;
28678 PyObject * obj0 = 0 ;
28679 char *kwnames[] = {
28680 (char *) "self", NULL
28681 };
28682
28683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28685 if (SWIG_arg_fail(1)) SWIG_fail;
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 {
28689 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28690 result = (wxRegion *) &_result_ref;
28691 }
28692
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxWindow *arg1 = (wxWindow *) 0 ;
28706 wxRect result;
28707 PyObject * obj0 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 wxRect * resultptr;
28724 resultptr = new wxRect((wxRect &)(result));
28725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28726 }
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj;
28735 wxWindow *arg1 = (wxWindow *) 0 ;
28736 int arg2 ;
28737 int arg3 ;
28738 int arg4 = (int) 1 ;
28739 int arg5 = (int) 1 ;
28740 bool result;
28741 PyObject * obj0 = 0 ;
28742 PyObject * obj1 = 0 ;
28743 PyObject * obj2 = 0 ;
28744 PyObject * obj3 = 0 ;
28745 PyObject * obj4 = 0 ;
28746 char *kwnames[] = {
28747 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28748 };
28749
28750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28752 if (SWIG_arg_fail(1)) SWIG_fail;
28753 {
28754 arg2 = (int)(SWIG_As_int(obj1));
28755 if (SWIG_arg_fail(2)) SWIG_fail;
28756 }
28757 {
28758 arg3 = (int)(SWIG_As_int(obj2));
28759 if (SWIG_arg_fail(3)) SWIG_fail;
28760 }
28761 if (obj3) {
28762 {
28763 arg4 = (int)(SWIG_As_int(obj3));
28764 if (SWIG_arg_fail(4)) SWIG_fail;
28765 }
28766 }
28767 if (obj4) {
28768 {
28769 arg5 = (int)(SWIG_As_int(obj4));
28770 if (SWIG_arg_fail(5)) SWIG_fail;
28771 }
28772 }
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj;
28791 wxWindow *arg1 = (wxWindow *) 0 ;
28792 wxPoint *arg2 = 0 ;
28793 bool result;
28794 wxPoint temp2 ;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "pt", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 {
28805 arg2 = &temp2;
28806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28807 }
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28811
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 {
28816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28817 }
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxWindow *arg1 = (wxWindow *) 0 ;
28827 wxRect *arg2 = 0 ;
28828 bool result;
28829 wxRect temp2 ;
28830 PyObject * obj0 = 0 ;
28831 PyObject * obj1 = 0 ;
28832 char *kwnames[] = {
28833 (char *) "self",(char *) "rect", NULL
28834 };
28835
28836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28838 if (SWIG_arg_fail(1)) SWIG_fail;
28839 {
28840 arg2 = &temp2;
28841 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 {
28851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj;
28861 wxWindow *arg1 = (wxWindow *) 0 ;
28862 wxVisualAttributes result;
28863 PyObject * obj0 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 {
28879 wxVisualAttributes * resultptr;
28880 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28892 wxVisualAttributes result;
28893 PyObject * obj0 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "variant", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28899 if (obj0) {
28900 {
28901 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28902 if (SWIG_arg_fail(1)) SWIG_fail;
28903 }
28904 }
28905 {
28906 if (!wxPyCheckForApp()) SWIG_fail;
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28909
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 {
28914 wxVisualAttributes * resultptr;
28915 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28917 }
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj;
28926 wxWindow *arg1 = (wxWindow *) 0 ;
28927 wxColour *arg2 = 0 ;
28928 bool result;
28929 wxColour temp2 ;
28930 PyObject * obj0 = 0 ;
28931 PyObject * obj1 = 0 ;
28932 char *kwnames[] = {
28933 (char *) "self",(char *) "colour", NULL
28934 };
28935
28936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28938 if (SWIG_arg_fail(1)) SWIG_fail;
28939 {
28940 arg2 = &temp2;
28941 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28942 }
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28946
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 {
28951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28952 }
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28960 PyObject *resultobj;
28961 wxWindow *arg1 = (wxWindow *) 0 ;
28962 wxColour *arg2 = 0 ;
28963 wxColour temp2 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 char *kwnames[] = {
28967 (char *) "self",(char *) "colour", NULL
28968 };
28969
28970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(1)) SWIG_fail;
28973 {
28974 arg2 = &temp2;
28975 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28980
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 Py_INCREF(Py_None); resultobj = Py_None;
28985 return resultobj;
28986 fail:
28987 return NULL;
28988 }
28989
28990
28991 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28992 PyObject *resultobj;
28993 wxWindow *arg1 = (wxWindow *) 0 ;
28994 wxColour *arg2 = 0 ;
28995 bool result;
28996 wxColour temp2 ;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 char *kwnames[] = {
29000 (char *) "self",(char *) "colour", NULL
29001 };
29002
29003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29005 if (SWIG_arg_fail(1)) SWIG_fail;
29006 {
29007 arg2 = &temp2;
29008 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29013
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 {
29018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29019 }
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj;
29028 wxWindow *arg1 = (wxWindow *) 0 ;
29029 wxColour *arg2 = 0 ;
29030 wxColour temp2 ;
29031 PyObject * obj0 = 0 ;
29032 PyObject * obj1 = 0 ;
29033 char *kwnames[] = {
29034 (char *) "self",(char *) "colour", NULL
29035 };
29036
29037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29039 if (SWIG_arg_fail(1)) SWIG_fail;
29040 {
29041 arg2 = &temp2;
29042 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29043 }
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 Py_INCREF(Py_None); resultobj = Py_None;
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29059 PyObject *resultobj;
29060 wxWindow *arg1 = (wxWindow *) 0 ;
29061 wxColour result;
29062 PyObject * obj0 = 0 ;
29063 char *kwnames[] = {
29064 (char *) "self", NULL
29065 };
29066
29067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29069 if (SWIG_arg_fail(1)) SWIG_fail;
29070 {
29071 PyThreadState* __tstate = wxPyBeginAllowThreads();
29072 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29073
29074 wxPyEndAllowThreads(__tstate);
29075 if (PyErr_Occurred()) SWIG_fail;
29076 }
29077 {
29078 wxColour * resultptr;
29079 resultptr = new wxColour((wxColour &)(result));
29080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29081 }
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj;
29090 wxWindow *arg1 = (wxWindow *) 0 ;
29091 wxColour result;
29092 PyObject * obj0 = 0 ;
29093 char *kwnames[] = {
29094 (char *) "self", NULL
29095 };
29096
29097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29099 if (SWIG_arg_fail(1)) SWIG_fail;
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = ((wxWindow const *)arg1)->GetForegroundColour();
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 wxColour * resultptr;
29109 resultptr = new wxColour((wxColour &)(result));
29110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29111 }
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj;
29120 wxWindow *arg1 = (wxWindow *) 0 ;
29121 wxBackgroundStyle arg2 ;
29122 bool result;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 char *kwnames[] = {
29126 (char *) "self",(char *) "style", NULL
29127 };
29128
29129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29131 if (SWIG_arg_fail(1)) SWIG_fail;
29132 {
29133 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29134 if (SWIG_arg_fail(2)) SWIG_fail;
29135 }
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29139
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 {
29144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29145 }
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj;
29154 wxWindow *arg1 = (wxWindow *) 0 ;
29155 wxBackgroundStyle result;
29156 PyObject * obj0 = 0 ;
29157 char *kwnames[] = {
29158 (char *) "self", NULL
29159 };
29160
29161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29163 if (SWIG_arg_fail(1)) SWIG_fail;
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29167
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 resultobj = SWIG_From_int((result));
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj;
29180 wxWindow *arg1 = (wxWindow *) 0 ;
29181 wxCursor *arg2 = 0 ;
29182 bool result;
29183 PyObject * obj0 = 0 ;
29184 PyObject * obj1 = 0 ;
29185 char *kwnames[] = {
29186 (char *) "self",(char *) "cursor", NULL
29187 };
29188
29189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29191 if (SWIG_arg_fail(1)) SWIG_fail;
29192 {
29193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29194 if (SWIG_arg_fail(2)) SWIG_fail;
29195 if (arg2 == NULL) {
29196 SWIG_null_ref("wxCursor");
29197 }
29198 if (SWIG_arg_fail(2)) SWIG_fail;
29199 }
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 {
29208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxWindow *arg1 = (wxWindow *) 0 ;
29219 wxCursor result;
29220 PyObject * obj0 = 0 ;
29221 char *kwnames[] = {
29222 (char *) "self", NULL
29223 };
29224
29225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29227 if (SWIG_arg_fail(1)) SWIG_fail;
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = (arg1)->GetCursor();
29231
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 {
29236 wxCursor * resultptr;
29237 resultptr = new wxCursor((wxCursor &)(result));
29238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29239 }
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxWindow *arg1 = (wxWindow *) 0 ;
29249 wxFont *arg2 = 0 ;
29250 bool result;
29251 PyObject * obj0 = 0 ;
29252 PyObject * obj1 = 0 ;
29253 char *kwnames[] = {
29254 (char *) "self",(char *) "font", NULL
29255 };
29256
29257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29259 if (SWIG_arg_fail(1)) SWIG_fail;
29260 {
29261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(2)) SWIG_fail;
29263 if (arg2 == NULL) {
29264 SWIG_null_ref("wxFont");
29265 }
29266 if (SWIG_arg_fail(2)) SWIG_fail;
29267 }
29268 {
29269 PyThreadState* __tstate = wxPyBeginAllowThreads();
29270 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29271
29272 wxPyEndAllowThreads(__tstate);
29273 if (PyErr_Occurred()) SWIG_fail;
29274 }
29275 {
29276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29277 }
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29285 PyObject *resultobj;
29286 wxWindow *arg1 = (wxWindow *) 0 ;
29287 wxFont *arg2 = 0 ;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 char *kwnames[] = {
29291 (char *) "self",(char *) "font", NULL
29292 };
29293
29294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29296 if (SWIG_arg_fail(1)) SWIG_fail;
29297 {
29298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(2)) SWIG_fail;
29300 if (arg2 == NULL) {
29301 SWIG_null_ref("wxFont");
29302 }
29303 if (SWIG_arg_fail(2)) SWIG_fail;
29304 }
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 (arg1)->SetOwnFont((wxFont const &)*arg2);
29308
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 Py_INCREF(Py_None); resultobj = Py_None;
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29320 PyObject *resultobj;
29321 wxWindow *arg1 = (wxWindow *) 0 ;
29322 wxFont result;
29323 PyObject * obj0 = 0 ;
29324 char *kwnames[] = {
29325 (char *) "self", NULL
29326 };
29327
29328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29330 if (SWIG_arg_fail(1)) SWIG_fail;
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (arg1)->GetFont();
29334
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 {
29339 wxFont * resultptr;
29340 resultptr = new wxFont((wxFont &)(result));
29341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29342 }
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29350 PyObject *resultobj;
29351 wxWindow *arg1 = (wxWindow *) 0 ;
29352 wxCaret *arg2 = (wxCaret *) 0 ;
29353 PyObject * obj0 = 0 ;
29354 PyObject * obj1 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self",(char *) "caret", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29363 if (SWIG_arg_fail(2)) SWIG_fail;
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 (arg1)->SetCaret(arg2);
29367
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 Py_INCREF(Py_None); resultobj = Py_None;
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj;
29380 wxWindow *arg1 = (wxWindow *) 0 ;
29381 wxCaret *result;
29382 PyObject * obj0 = 0 ;
29383 char *kwnames[] = {
29384 (char *) "self", NULL
29385 };
29386
29387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29389 if (SWIG_arg_fail(1)) SWIG_fail;
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29393
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj;
29406 wxWindow *arg1 = (wxWindow *) 0 ;
29407 int result;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 {
29424 resultobj = SWIG_From_int((int)(result));
29425 }
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxWindow *arg1 = (wxWindow *) 0 ;
29435 int result;
29436 PyObject * obj0 = 0 ;
29437 char *kwnames[] = {
29438 (char *) "self", NULL
29439 };
29440
29441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29443 if (SWIG_arg_fail(1)) SWIG_fail;
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 {
29452 resultobj = SWIG_From_int((int)(result));
29453 }
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj;
29462 wxWindow *arg1 = (wxWindow *) 0 ;
29463 wxString *arg2 = 0 ;
29464 int *arg3 = (int *) 0 ;
29465 int *arg4 = (int *) 0 ;
29466 bool temp2 = false ;
29467 int temp3 ;
29468 int res3 = 0 ;
29469 int temp4 ;
29470 int res4 = 0 ;
29471 PyObject * obj0 = 0 ;
29472 PyObject * obj1 = 0 ;
29473 char *kwnames[] = {
29474 (char *) "self",(char *) "string", NULL
29475 };
29476
29477 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29478 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
29484 if (arg2 == NULL) SWIG_fail;
29485 temp2 = true;
29486 }
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 Py_INCREF(Py_None); resultobj = Py_None;
29495 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29496 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29497 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29498 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29499 {
29500 if (temp2)
29501 delete arg2;
29502 }
29503 return resultobj;
29504 fail:
29505 {
29506 if (temp2)
29507 delete arg2;
29508 }
29509 return NULL;
29510 }
29511
29512
29513 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj;
29515 wxWindow *arg1 = (wxWindow *) 0 ;
29516 wxString *arg2 = 0 ;
29517 int *arg3 = (int *) 0 ;
29518 int *arg4 = (int *) 0 ;
29519 int *arg5 = (int *) 0 ;
29520 int *arg6 = (int *) 0 ;
29521 wxFont *arg7 = (wxFont *) NULL ;
29522 bool temp2 = false ;
29523 int temp3 ;
29524 int res3 = 0 ;
29525 int temp4 ;
29526 int res4 = 0 ;
29527 int temp5 ;
29528 int res5 = 0 ;
29529 int temp6 ;
29530 int res6 = 0 ;
29531 PyObject * obj0 = 0 ;
29532 PyObject * obj1 = 0 ;
29533 PyObject * obj2 = 0 ;
29534 char *kwnames[] = {
29535 (char *) "self",(char *) "string",(char *) "font", NULL
29536 };
29537
29538 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29539 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29540 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29541 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29544 if (SWIG_arg_fail(1)) SWIG_fail;
29545 {
29546 arg2 = wxString_in_helper(obj1);
29547 if (arg2 == NULL) SWIG_fail;
29548 temp2 = true;
29549 }
29550 if (obj2) {
29551 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29552 if (SWIG_arg_fail(7)) SWIG_fail;
29553 }
29554 {
29555 PyThreadState* __tstate = wxPyBeginAllowThreads();
29556 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29557
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 Py_INCREF(Py_None); resultobj = Py_None;
29562 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29563 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29564 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29565 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29566 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29567 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29568 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29569 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29570 {
29571 if (temp2)
29572 delete arg2;
29573 }
29574 return resultobj;
29575 fail:
29576 {
29577 if (temp2)
29578 delete arg2;
29579 }
29580 return NULL;
29581 }
29582
29583
29584 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj;
29586 wxWindow *arg1 = (wxWindow *) 0 ;
29587 int *arg2 = (int *) 0 ;
29588 int *arg3 = (int *) 0 ;
29589 int temp2 ;
29590 int res2 = 0 ;
29591 int temp3 ;
29592 int res3 = 0 ;
29593 PyObject * obj0 = 0 ;
29594 PyObject * obj1 = 0 ;
29595 PyObject * obj2 = 0 ;
29596 char *kwnames[] = {
29597 (char *) "self",(char *) "x",(char *) "y", NULL
29598 };
29599
29600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29602 if (SWIG_arg_fail(1)) SWIG_fail;
29603 {
29604 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29605 temp2 = SWIG_As_int(obj1);
29606 if (SWIG_arg_fail(2)) SWIG_fail;
29607 arg2 = &temp2;
29608 res2 = SWIG_NEWOBJ;
29609 }
29610 }
29611 {
29612 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29613 temp3 = SWIG_As_int(obj2);
29614 if (SWIG_arg_fail(3)) SWIG_fail;
29615 arg3 = &temp3;
29616 res3 = SWIG_NEWOBJ;
29617 }
29618 }
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29622
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 Py_INCREF(Py_None); resultobj = Py_None;
29627 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29628 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29629 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29630 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29631 return resultobj;
29632 fail:
29633 return NULL;
29634 }
29635
29636
29637 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29638 PyObject *resultobj;
29639 wxWindow *arg1 = (wxWindow *) 0 ;
29640 int *arg2 = (int *) 0 ;
29641 int *arg3 = (int *) 0 ;
29642 int temp2 ;
29643 int res2 = 0 ;
29644 int temp3 ;
29645 int res3 = 0 ;
29646 PyObject * obj0 = 0 ;
29647 PyObject * obj1 = 0 ;
29648 PyObject * obj2 = 0 ;
29649 char *kwnames[] = {
29650 (char *) "self",(char *) "x",(char *) "y", NULL
29651 };
29652
29653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29655 if (SWIG_arg_fail(1)) SWIG_fail;
29656 {
29657 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29658 temp2 = SWIG_As_int(obj1);
29659 if (SWIG_arg_fail(2)) SWIG_fail;
29660 arg2 = &temp2;
29661 res2 = SWIG_NEWOBJ;
29662 }
29663 }
29664 {
29665 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29666 temp3 = SWIG_As_int(obj2);
29667 if (SWIG_arg_fail(3)) SWIG_fail;
29668 arg3 = &temp3;
29669 res3 = SWIG_NEWOBJ;
29670 }
29671 }
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 Py_INCREF(Py_None); resultobj = Py_None;
29680 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29681 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29682 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29683 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj;
29692 wxWindow *arg1 = (wxWindow *) 0 ;
29693 wxPoint *arg2 = 0 ;
29694 wxPoint result;
29695 wxPoint temp2 ;
29696 PyObject * obj0 = 0 ;
29697 PyObject * obj1 = 0 ;
29698 char *kwnames[] = {
29699 (char *) "self",(char *) "pt", NULL
29700 };
29701
29702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29704 if (SWIG_arg_fail(1)) SWIG_fail;
29705 {
29706 arg2 = &temp2;
29707 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29708 }
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29712
29713 wxPyEndAllowThreads(__tstate);
29714 if (PyErr_Occurred()) SWIG_fail;
29715 }
29716 {
29717 wxPoint * resultptr;
29718 resultptr = new wxPoint((wxPoint &)(result));
29719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29720 }
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29728 PyObject *resultobj;
29729 wxWindow *arg1 = (wxWindow *) 0 ;
29730 wxPoint *arg2 = 0 ;
29731 wxPoint result;
29732 wxPoint temp2 ;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 char *kwnames[] = {
29736 (char *) "self",(char *) "pt", NULL
29737 };
29738
29739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29741 if (SWIG_arg_fail(1)) SWIG_fail;
29742 {
29743 arg2 = &temp2;
29744 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 {
29754 wxPoint * resultptr;
29755 resultptr = new wxPoint((wxPoint &)(result));
29756 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29757 }
29758 return resultobj;
29759 fail:
29760 return NULL;
29761 }
29762
29763
29764 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj;
29766 wxWindow *arg1 = (wxWindow *) 0 ;
29767 int arg2 ;
29768 int arg3 ;
29769 wxHitTest result;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 char *kwnames[] = {
29774 (char *) "self",(char *) "x",(char *) "y", NULL
29775 };
29776
29777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29779 if (SWIG_arg_fail(1)) SWIG_fail;
29780 {
29781 arg2 = (int)(SWIG_As_int(obj1));
29782 if (SWIG_arg_fail(2)) SWIG_fail;
29783 }
29784 {
29785 arg3 = (int)(SWIG_As_int(obj2));
29786 if (SWIG_arg_fail(3)) SWIG_fail;
29787 }
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_From_int((result));
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj;
29804 wxWindow *arg1 = (wxWindow *) 0 ;
29805 wxPoint *arg2 = 0 ;
29806 wxHitTest result;
29807 wxPoint temp2 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char *kwnames[] = {
29811 (char *) "self",(char *) "pt", NULL
29812 };
29813
29814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 {
29818 arg2 = &temp2;
29819 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29820 }
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29824
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_From_int((result));
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29836 PyObject *resultobj;
29837 wxWindow *arg1 = (wxWindow *) 0 ;
29838 long arg2 ;
29839 wxBorder result;
29840 PyObject * obj0 = 0 ;
29841 PyObject * obj1 = 0 ;
29842
29843 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29845 if (SWIG_arg_fail(1)) SWIG_fail;
29846 {
29847 arg2 = (long)(SWIG_As_long(obj1));
29848 if (SWIG_arg_fail(2)) SWIG_fail;
29849 }
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29853
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 resultobj = SWIG_From_int((result));
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29865 PyObject *resultobj;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 wxBorder result;
29868 PyObject * obj0 = 0 ;
29869
29870 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29872 if (SWIG_arg_fail(1)) SWIG_fail;
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29876
29877 wxPyEndAllowThreads(__tstate);
29878 if (PyErr_Occurred()) SWIG_fail;
29879 }
29880 resultobj = SWIG_From_int((result));
29881 return resultobj;
29882 fail:
29883 return NULL;
29884 }
29885
29886
29887 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29888 int argc;
29889 PyObject *argv[3];
29890 int ii;
29891
29892 argc = PyObject_Length(args);
29893 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29894 argv[ii] = PyTuple_GetItem(args,ii);
29895 }
29896 if (argc == 1) {
29897 int _v;
29898 {
29899 void *ptr;
29900 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29901 _v = 0;
29902 PyErr_Clear();
29903 } else {
29904 _v = 1;
29905 }
29906 }
29907 if (_v) {
29908 return _wrap_Window_GetBorder__SWIG_1(self,args);
29909 }
29910 }
29911 if (argc == 2) {
29912 int _v;
29913 {
29914 void *ptr;
29915 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29916 _v = 0;
29917 PyErr_Clear();
29918 } else {
29919 _v = 1;
29920 }
29921 }
29922 if (_v) {
29923 _v = SWIG_Check_long(argv[1]);
29924 if (_v) {
29925 return _wrap_Window_GetBorder__SWIG_0(self,args);
29926 }
29927 }
29928 }
29929
29930 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29931 return NULL;
29932 }
29933
29934
29935 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj;
29937 wxWindow *arg1 = (wxWindow *) 0 ;
29938 long arg2 = (long) wxUPDATE_UI_NONE ;
29939 PyObject * obj0 = 0 ;
29940 PyObject * obj1 = 0 ;
29941 char *kwnames[] = {
29942 (char *) "self",(char *) "flags", NULL
29943 };
29944
29945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29947 if (SWIG_arg_fail(1)) SWIG_fail;
29948 if (obj1) {
29949 {
29950 arg2 = (long)(SWIG_As_long(obj1));
29951 if (SWIG_arg_fail(2)) SWIG_fail;
29952 }
29953 }
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 (arg1)->UpdateWindowUI(arg2);
29957
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 Py_INCREF(Py_None); resultobj = Py_None;
29962 return resultobj;
29963 fail:
29964 return NULL;
29965 }
29966
29967
29968 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29969 PyObject *resultobj;
29970 wxWindow *arg1 = (wxWindow *) 0 ;
29971 wxMenu *arg2 = (wxMenu *) 0 ;
29972 int arg3 = (int) -1 ;
29973 int arg4 = (int) -1 ;
29974 bool result;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 PyObject * obj2 = 0 ;
29978 PyObject * obj3 = 0 ;
29979 char *kwnames[] = {
29980 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
29981 };
29982
29983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29985 if (SWIG_arg_fail(1)) SWIG_fail;
29986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(2)) SWIG_fail;
29988 if (obj2) {
29989 {
29990 arg3 = (int)(SWIG_As_int(obj2));
29991 if (SWIG_arg_fail(3)) SWIG_fail;
29992 }
29993 }
29994 if (obj3) {
29995 {
29996 arg4 = (int)(SWIG_As_int(obj3));
29997 if (SWIG_arg_fail(4)) SWIG_fail;
29998 }
29999 }
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30003
30004 wxPyEndAllowThreads(__tstate);
30005 if (PyErr_Occurred()) SWIG_fail;
30006 }
30007 {
30008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30009 }
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj;
30018 wxWindow *arg1 = (wxWindow *) 0 ;
30019 wxMenu *arg2 = (wxMenu *) 0 ;
30020 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30021 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30022 bool result;
30023 wxPoint temp3 ;
30024 PyObject * obj0 = 0 ;
30025 PyObject * obj1 = 0 ;
30026 PyObject * obj2 = 0 ;
30027 char *kwnames[] = {
30028 (char *) "self",(char *) "menu",(char *) "pos", NULL
30029 };
30030
30031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(1)) SWIG_fail;
30034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30035 if (SWIG_arg_fail(2)) SWIG_fail;
30036 if (obj2) {
30037 {
30038 arg3 = &temp3;
30039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30040 }
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30045
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 {
30050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30051 }
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj;
30060 wxWindow *arg1 = (wxWindow *) 0 ;
30061 long result;
30062 PyObject * obj0 = 0 ;
30063 char *kwnames[] = {
30064 (char *) "self", NULL
30065 };
30066
30067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(1)) SWIG_fail;
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 result = (long)wxWindow_GetHandle(arg1);
30073
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 {
30078 resultobj = SWIG_From_long((long)(result));
30079 }
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxWindow *arg1 = (wxWindow *) 0 ;
30089 long arg2 ;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self",(char *) "handle", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 arg2 = (long)(SWIG_As_long(obj1));
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 }
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 wxWindow_AssociateHandle(arg1,arg2);
30106
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 Py_INCREF(Py_None); resultobj = Py_None;
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj;
30119 wxWindow *arg1 = (wxWindow *) 0 ;
30120 PyObject * obj0 = 0 ;
30121 char *kwnames[] = {
30122 (char *) "self", NULL
30123 };
30124
30125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30127 if (SWIG_arg_fail(1)) SWIG_fail;
30128 {
30129 PyThreadState* __tstate = wxPyBeginAllowThreads();
30130 (arg1)->DissociateHandle();
30131
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 Py_INCREF(Py_None); resultobj = Py_None;
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30143 PyObject *resultobj;
30144 wxWindow *arg1 = (wxWindow *) 0 ;
30145 int arg2 ;
30146 bool result;
30147 PyObject * obj0 = 0 ;
30148 PyObject * obj1 = 0 ;
30149 char *kwnames[] = {
30150 (char *) "self",(char *) "orient", NULL
30151 };
30152
30153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(1)) SWIG_fail;
30156 {
30157 arg2 = (int)(SWIG_As_int(obj1));
30158 if (SWIG_arg_fail(2)) SWIG_fail;
30159 }
30160 {
30161 PyThreadState* __tstate = wxPyBeginAllowThreads();
30162 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30163
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 {
30168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30169 }
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj;
30178 wxWindow *arg1 = (wxWindow *) 0 ;
30179 int arg2 ;
30180 int arg3 ;
30181 int arg4 ;
30182 int arg5 ;
30183 bool arg6 = (bool) true ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 PyObject * obj2 = 0 ;
30187 PyObject * obj3 = 0 ;
30188 PyObject * obj4 = 0 ;
30189 PyObject * obj5 = 0 ;
30190 char *kwnames[] = {
30191 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30192 };
30193
30194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30196 if (SWIG_arg_fail(1)) SWIG_fail;
30197 {
30198 arg2 = (int)(SWIG_As_int(obj1));
30199 if (SWIG_arg_fail(2)) SWIG_fail;
30200 }
30201 {
30202 arg3 = (int)(SWIG_As_int(obj2));
30203 if (SWIG_arg_fail(3)) SWIG_fail;
30204 }
30205 {
30206 arg4 = (int)(SWIG_As_int(obj3));
30207 if (SWIG_arg_fail(4)) SWIG_fail;
30208 }
30209 {
30210 arg5 = (int)(SWIG_As_int(obj4));
30211 if (SWIG_arg_fail(5)) SWIG_fail;
30212 }
30213 if (obj5) {
30214 {
30215 arg6 = (bool)(SWIG_As_bool(obj5));
30216 if (SWIG_arg_fail(6)) SWIG_fail;
30217 }
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30222
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 Py_INCREF(Py_None); resultobj = Py_None;
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj;
30235 wxWindow *arg1 = (wxWindow *) 0 ;
30236 int arg2 ;
30237 int arg3 ;
30238 bool arg4 = (bool) true ;
30239 PyObject * obj0 = 0 ;
30240 PyObject * obj1 = 0 ;
30241 PyObject * obj2 = 0 ;
30242 PyObject * obj3 = 0 ;
30243 char *kwnames[] = {
30244 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30245 };
30246
30247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30249 if (SWIG_arg_fail(1)) SWIG_fail;
30250 {
30251 arg2 = (int)(SWIG_As_int(obj1));
30252 if (SWIG_arg_fail(2)) SWIG_fail;
30253 }
30254 {
30255 arg3 = (int)(SWIG_As_int(obj2));
30256 if (SWIG_arg_fail(3)) SWIG_fail;
30257 }
30258 if (obj3) {
30259 {
30260 arg4 = (bool)(SWIG_As_bool(obj3));
30261 if (SWIG_arg_fail(4)) SWIG_fail;
30262 }
30263 }
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 (arg1)->SetScrollPos(arg2,arg3,arg4);
30267
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 Py_INCREF(Py_None); resultobj = Py_None;
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30279 PyObject *resultobj;
30280 wxWindow *arg1 = (wxWindow *) 0 ;
30281 int arg2 ;
30282 int result;
30283 PyObject * obj0 = 0 ;
30284 PyObject * obj1 = 0 ;
30285 char *kwnames[] = {
30286 (char *) "self",(char *) "orientation", NULL
30287 };
30288
30289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30291 if (SWIG_arg_fail(1)) SWIG_fail;
30292 {
30293 arg2 = (int)(SWIG_As_int(obj1));
30294 if (SWIG_arg_fail(2)) SWIG_fail;
30295 }
30296 {
30297 PyThreadState* __tstate = wxPyBeginAllowThreads();
30298 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30299
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 {
30304 resultobj = SWIG_From_int((int)(result));
30305 }
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30313 PyObject *resultobj;
30314 wxWindow *arg1 = (wxWindow *) 0 ;
30315 int arg2 ;
30316 int result;
30317 PyObject * obj0 = 0 ;
30318 PyObject * obj1 = 0 ;
30319 char *kwnames[] = {
30320 (char *) "self",(char *) "orientation", NULL
30321 };
30322
30323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30325 if (SWIG_arg_fail(1)) SWIG_fail;
30326 {
30327 arg2 = (int)(SWIG_As_int(obj1));
30328 if (SWIG_arg_fail(2)) SWIG_fail;
30329 }
30330 {
30331 PyThreadState* __tstate = wxPyBeginAllowThreads();
30332 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30333
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 {
30338 resultobj = SWIG_From_int((int)(result));
30339 }
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30347 PyObject *resultobj;
30348 wxWindow *arg1 = (wxWindow *) 0 ;
30349 int arg2 ;
30350 int result;
30351 PyObject * obj0 = 0 ;
30352 PyObject * obj1 = 0 ;
30353 char *kwnames[] = {
30354 (char *) "self",(char *) "orientation", NULL
30355 };
30356
30357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30359 if (SWIG_arg_fail(1)) SWIG_fail;
30360 {
30361 arg2 = (int)(SWIG_As_int(obj1));
30362 if (SWIG_arg_fail(2)) SWIG_fail;
30363 }
30364 {
30365 PyThreadState* __tstate = wxPyBeginAllowThreads();
30366 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30367
30368 wxPyEndAllowThreads(__tstate);
30369 if (PyErr_Occurred()) SWIG_fail;
30370 }
30371 {
30372 resultobj = SWIG_From_int((int)(result));
30373 }
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30381 PyObject *resultobj;
30382 wxWindow *arg1 = (wxWindow *) 0 ;
30383 int arg2 ;
30384 int arg3 ;
30385 wxRect *arg4 = (wxRect *) NULL ;
30386 PyObject * obj0 = 0 ;
30387 PyObject * obj1 = 0 ;
30388 PyObject * obj2 = 0 ;
30389 PyObject * obj3 = 0 ;
30390 char *kwnames[] = {
30391 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30392 };
30393
30394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30396 if (SWIG_arg_fail(1)) SWIG_fail;
30397 {
30398 arg2 = (int)(SWIG_As_int(obj1));
30399 if (SWIG_arg_fail(2)) SWIG_fail;
30400 }
30401 {
30402 arg3 = (int)(SWIG_As_int(obj2));
30403 if (SWIG_arg_fail(3)) SWIG_fail;
30404 }
30405 if (obj3) {
30406 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30407 if (SWIG_arg_fail(4)) SWIG_fail;
30408 }
30409 {
30410 PyThreadState* __tstate = wxPyBeginAllowThreads();
30411 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30412
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 Py_INCREF(Py_None); resultobj = Py_None;
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj;
30425 wxWindow *arg1 = (wxWindow *) 0 ;
30426 int arg2 ;
30427 bool result;
30428 PyObject * obj0 = 0 ;
30429 PyObject * obj1 = 0 ;
30430 char *kwnames[] = {
30431 (char *) "self",(char *) "lines", NULL
30432 };
30433
30434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30436 if (SWIG_arg_fail(1)) SWIG_fail;
30437 {
30438 arg2 = (int)(SWIG_As_int(obj1));
30439 if (SWIG_arg_fail(2)) SWIG_fail;
30440 }
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = (bool)(arg1)->ScrollLines(arg2);
30444
30445 wxPyEndAllowThreads(__tstate);
30446 if (PyErr_Occurred()) SWIG_fail;
30447 }
30448 {
30449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30450 }
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj;
30459 wxWindow *arg1 = (wxWindow *) 0 ;
30460 int arg2 ;
30461 bool result;
30462 PyObject * obj0 = 0 ;
30463 PyObject * obj1 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self",(char *) "pages", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 arg2 = (int)(SWIG_As_int(obj1));
30473 if (SWIG_arg_fail(2)) SWIG_fail;
30474 }
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 result = (bool)(arg1)->ScrollPages(arg2);
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 {
30483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30484 }
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30492 PyObject *resultobj;
30493 wxWindow *arg1 = (wxWindow *) 0 ;
30494 bool result;
30495 PyObject * obj0 = 0 ;
30496 char *kwnames[] = {
30497 (char *) "self", NULL
30498 };
30499
30500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30502 if (SWIG_arg_fail(1)) SWIG_fail;
30503 {
30504 PyThreadState* __tstate = wxPyBeginAllowThreads();
30505 result = (bool)(arg1)->LineUp();
30506
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 {
30511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30512 }
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30520 PyObject *resultobj;
30521 wxWindow *arg1 = (wxWindow *) 0 ;
30522 bool result;
30523 PyObject * obj0 = 0 ;
30524 char *kwnames[] = {
30525 (char *) "self", NULL
30526 };
30527
30528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30530 if (SWIG_arg_fail(1)) SWIG_fail;
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 result = (bool)(arg1)->LineDown();
30534
30535 wxPyEndAllowThreads(__tstate);
30536 if (PyErr_Occurred()) SWIG_fail;
30537 }
30538 {
30539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30540 }
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30548 PyObject *resultobj;
30549 wxWindow *arg1 = (wxWindow *) 0 ;
30550 bool result;
30551 PyObject * obj0 = 0 ;
30552 char *kwnames[] = {
30553 (char *) "self", NULL
30554 };
30555
30556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30558 if (SWIG_arg_fail(1)) SWIG_fail;
30559 {
30560 PyThreadState* __tstate = wxPyBeginAllowThreads();
30561 result = (bool)(arg1)->PageUp();
30562
30563 wxPyEndAllowThreads(__tstate);
30564 if (PyErr_Occurred()) SWIG_fail;
30565 }
30566 {
30567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30568 }
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj;
30577 wxWindow *arg1 = (wxWindow *) 0 ;
30578 bool result;
30579 PyObject * obj0 = 0 ;
30580 char *kwnames[] = {
30581 (char *) "self", NULL
30582 };
30583
30584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30586 if (SWIG_arg_fail(1)) SWIG_fail;
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 result = (bool)(arg1)->PageDown();
30590
30591 wxPyEndAllowThreads(__tstate);
30592 if (PyErr_Occurred()) SWIG_fail;
30593 }
30594 {
30595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30596 }
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30604 PyObject *resultobj;
30605 wxWindow *arg1 = (wxWindow *) 0 ;
30606 wxString *arg2 = 0 ;
30607 bool temp2 = false ;
30608 PyObject * obj0 = 0 ;
30609 PyObject * obj1 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self",(char *) "text", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 {
30618 arg2 = wxString_in_helper(obj1);
30619 if (arg2 == NULL) SWIG_fail;
30620 temp2 = true;
30621 }
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 (arg1)->SetHelpText((wxString const &)*arg2);
30625
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 Py_INCREF(Py_None); resultobj = Py_None;
30630 {
30631 if (temp2)
30632 delete arg2;
30633 }
30634 return resultobj;
30635 fail:
30636 {
30637 if (temp2)
30638 delete arg2;
30639 }
30640 return NULL;
30641 }
30642
30643
30644 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30645 PyObject *resultobj;
30646 wxWindow *arg1 = (wxWindow *) 0 ;
30647 wxString *arg2 = 0 ;
30648 bool temp2 = false ;
30649 PyObject * obj0 = 0 ;
30650 PyObject * obj1 = 0 ;
30651 char *kwnames[] = {
30652 (char *) "self",(char *) "text", NULL
30653 };
30654
30655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30657 if (SWIG_arg_fail(1)) SWIG_fail;
30658 {
30659 arg2 = wxString_in_helper(obj1);
30660 if (arg2 == NULL) SWIG_fail;
30661 temp2 = true;
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30666
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 Py_INCREF(Py_None); resultobj = Py_None;
30671 {
30672 if (temp2)
30673 delete arg2;
30674 }
30675 return resultobj;
30676 fail:
30677 {
30678 if (temp2)
30679 delete arg2;
30680 }
30681 return NULL;
30682 }
30683
30684
30685 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj;
30687 wxWindow *arg1 = (wxWindow *) 0 ;
30688 wxString result;
30689 PyObject * obj0 = 0 ;
30690 char *kwnames[] = {
30691 (char *) "self", NULL
30692 };
30693
30694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(1)) SWIG_fail;
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 result = ((wxWindow const *)arg1)->GetHelpText();
30700
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 {
30705 #if wxUSE_UNICODE
30706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30707 #else
30708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30709 #endif
30710 }
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30718 PyObject *resultobj;
30719 wxWindow *arg1 = (wxWindow *) 0 ;
30720 wxString *arg2 = 0 ;
30721 bool temp2 = false ;
30722 PyObject * obj0 = 0 ;
30723 PyObject * obj1 = 0 ;
30724 char *kwnames[] = {
30725 (char *) "self",(char *) "tip", NULL
30726 };
30727
30728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30730 if (SWIG_arg_fail(1)) SWIG_fail;
30731 {
30732 arg2 = wxString_in_helper(obj1);
30733 if (arg2 == NULL) SWIG_fail;
30734 temp2 = true;
30735 }
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 (arg1)->SetToolTip((wxString const &)*arg2);
30739
30740 wxPyEndAllowThreads(__tstate);
30741 if (PyErr_Occurred()) SWIG_fail;
30742 }
30743 Py_INCREF(Py_None); resultobj = Py_None;
30744 {
30745 if (temp2)
30746 delete arg2;
30747 }
30748 return resultobj;
30749 fail:
30750 {
30751 if (temp2)
30752 delete arg2;
30753 }
30754 return NULL;
30755 }
30756
30757
30758 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30759 PyObject *resultobj;
30760 wxWindow *arg1 = (wxWindow *) 0 ;
30761 wxToolTip *arg2 = (wxToolTip *) 0 ;
30762 PyObject * obj0 = 0 ;
30763 PyObject * obj1 = 0 ;
30764 char *kwnames[] = {
30765 (char *) "self",(char *) "tip", NULL
30766 };
30767
30768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30770 if (SWIG_arg_fail(1)) SWIG_fail;
30771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30772 if (SWIG_arg_fail(2)) SWIG_fail;
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 (arg1)->SetToolTip(arg2);
30776
30777 wxPyEndAllowThreads(__tstate);
30778 if (PyErr_Occurred()) SWIG_fail;
30779 }
30780 Py_INCREF(Py_None); resultobj = Py_None;
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30788 PyObject *resultobj;
30789 wxWindow *arg1 = (wxWindow *) 0 ;
30790 wxToolTip *result;
30791 PyObject * obj0 = 0 ;
30792 char *kwnames[] = {
30793 (char *) "self", NULL
30794 };
30795
30796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30798 if (SWIG_arg_fail(1)) SWIG_fail;
30799 {
30800 PyThreadState* __tstate = wxPyBeginAllowThreads();
30801 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30802
30803 wxPyEndAllowThreads(__tstate);
30804 if (PyErr_Occurred()) SWIG_fail;
30805 }
30806 {
30807 resultobj = wxPyMake_wxObject(result, 0);
30808 }
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30819 PyObject * obj0 = 0 ;
30820 PyObject * obj1 = 0 ;
30821 char *kwnames[] = {
30822 (char *) "self",(char *) "dropTarget", NULL
30823 };
30824
30825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30827 if (SWIG_arg_fail(1)) SWIG_fail;
30828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30829 if (SWIG_arg_fail(2)) SWIG_fail;
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 (arg1)->SetDropTarget(arg2);
30833
30834 wxPyEndAllowThreads(__tstate);
30835 if (PyErr_Occurred()) SWIG_fail;
30836 }
30837 Py_INCREF(Py_None); resultobj = Py_None;
30838 return resultobj;
30839 fail:
30840 return NULL;
30841 }
30842
30843
30844 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30845 PyObject *resultobj;
30846 wxWindow *arg1 = (wxWindow *) 0 ;
30847 wxPyDropTarget *result;
30848 PyObject * obj0 = 0 ;
30849 char *kwnames[] = {
30850 (char *) "self", NULL
30851 };
30852
30853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30855 if (SWIG_arg_fail(1)) SWIG_fail;
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30859
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30871 PyObject *resultobj;
30872 wxWindow *arg1 = (wxWindow *) 0 ;
30873 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30874 PyObject * obj0 = 0 ;
30875 PyObject * obj1 = 0 ;
30876 char *kwnames[] = {
30877 (char *) "self",(char *) "constraints", NULL
30878 };
30879
30880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30882 if (SWIG_arg_fail(1)) SWIG_fail;
30883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30884 if (SWIG_arg_fail(2)) SWIG_fail;
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 (arg1)->SetConstraints(arg2);
30888
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 Py_INCREF(Py_None); resultobj = Py_None;
30893 return resultobj;
30894 fail:
30895 return NULL;
30896 }
30897
30898
30899 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30900 PyObject *resultobj;
30901 wxWindow *arg1 = (wxWindow *) 0 ;
30902 wxLayoutConstraints *result;
30903 PyObject * obj0 = 0 ;
30904 char *kwnames[] = {
30905 (char *) "self", NULL
30906 };
30907
30908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30910 if (SWIG_arg_fail(1)) SWIG_fail;
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30914
30915 wxPyEndAllowThreads(__tstate);
30916 if (PyErr_Occurred()) SWIG_fail;
30917 }
30918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30926 PyObject *resultobj;
30927 wxWindow *arg1 = (wxWindow *) 0 ;
30928 bool arg2 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 char *kwnames[] = {
30932 (char *) "self",(char *) "autoLayout", NULL
30933 };
30934
30935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
30936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30937 if (SWIG_arg_fail(1)) SWIG_fail;
30938 {
30939 arg2 = (bool)(SWIG_As_bool(obj1));
30940 if (SWIG_arg_fail(2)) SWIG_fail;
30941 }
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 (arg1)->SetAutoLayout(arg2);
30945
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 Py_INCREF(Py_None); resultobj = Py_None;
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 bool result;
30960 PyObject * obj0 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 {
30976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30977 }
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 bool result;
30988 PyObject * obj0 = 0 ;
30989 char *kwnames[] = {
30990 (char *) "self", NULL
30991 };
30992
30993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
30994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30995 if (SWIG_arg_fail(1)) SWIG_fail;
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = (bool)(arg1)->Layout();
30999
31000 wxPyEndAllowThreads(__tstate);
31001 if (PyErr_Occurred()) SWIG_fail;
31002 }
31003 {
31004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31005 }
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31013 PyObject *resultobj;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 wxSizer *arg2 = (wxSizer *) 0 ;
31016 bool arg3 = (bool) true ;
31017 PyObject * obj0 = 0 ;
31018 PyObject * obj1 = 0 ;
31019 PyObject * obj2 = 0 ;
31020 char *kwnames[] = {
31021 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31022 };
31023
31024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31026 if (SWIG_arg_fail(1)) SWIG_fail;
31027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31028 if (SWIG_arg_fail(2)) SWIG_fail;
31029 if (obj2) {
31030 {
31031 arg3 = (bool)(SWIG_As_bool(obj2));
31032 if (SWIG_arg_fail(3)) SWIG_fail;
31033 }
31034 }
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 (arg1)->SetSizer(arg2,arg3);
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 Py_INCREF(Py_None); resultobj = Py_None;
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj;
31051 wxWindow *arg1 = (wxWindow *) 0 ;
31052 wxSizer *arg2 = (wxSizer *) 0 ;
31053 bool arg3 = (bool) true ;
31054 PyObject * obj0 = 0 ;
31055 PyObject * obj1 = 0 ;
31056 PyObject * obj2 = 0 ;
31057 char *kwnames[] = {
31058 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31059 };
31060
31061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31063 if (SWIG_arg_fail(1)) SWIG_fail;
31064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31065 if (SWIG_arg_fail(2)) SWIG_fail;
31066 if (obj2) {
31067 {
31068 arg3 = (bool)(SWIG_As_bool(obj2));
31069 if (SWIG_arg_fail(3)) SWIG_fail;
31070 }
31071 }
31072 {
31073 PyThreadState* __tstate = wxPyBeginAllowThreads();
31074 (arg1)->SetSizerAndFit(arg2,arg3);
31075
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 Py_INCREF(Py_None); resultobj = Py_None;
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxWindow *arg1 = (wxWindow *) 0 ;
31089 wxSizer *result;
31090 PyObject * obj0 = 0 ;
31091 char *kwnames[] = {
31092 (char *) "self", NULL
31093 };
31094
31095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31097 if (SWIG_arg_fail(1)) SWIG_fail;
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 {
31106 resultobj = wxPyMake_wxSizer(result, 0);
31107 }
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 wxSizer *arg2 = (wxSizer *) 0 ;
31118 PyObject * obj0 = 0 ;
31119 PyObject * obj1 = 0 ;
31120 char *kwnames[] = {
31121 (char *) "self",(char *) "sizer", NULL
31122 };
31123
31124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31126 if (SWIG_arg_fail(1)) SWIG_fail;
31127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31128 if (SWIG_arg_fail(2)) SWIG_fail;
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 (arg1)->SetContainingSizer(arg2);
31132
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 Py_INCREF(Py_None); resultobj = Py_None;
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31144 PyObject *resultobj;
31145 wxWindow *arg1 = (wxWindow *) 0 ;
31146 wxSizer *result;
31147 PyObject * obj0 = 0 ;
31148 char *kwnames[] = {
31149 (char *) "self", NULL
31150 };
31151
31152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31154 if (SWIG_arg_fail(1)) SWIG_fail;
31155 {
31156 PyThreadState* __tstate = wxPyBeginAllowThreads();
31157 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31158
31159 wxPyEndAllowThreads(__tstate);
31160 if (PyErr_Occurred()) SWIG_fail;
31161 }
31162 {
31163 resultobj = wxPyMake_wxSizer(result, 0);
31164 }
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj;
31173 wxWindow *arg1 = (wxWindow *) 0 ;
31174 PyObject * obj0 = 0 ;
31175 char *kwnames[] = {
31176 (char *) "self", NULL
31177 };
31178
31179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31181 if (SWIG_arg_fail(1)) SWIG_fail;
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 (arg1)->InheritAttributes();
31185
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 Py_INCREF(Py_None); resultobj = Py_None;
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj;
31198 wxWindow *arg1 = (wxWindow *) 0 ;
31199 bool result;
31200 PyObject * obj0 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31211
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 {
31216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31217 }
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31225 PyObject *obj;
31226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31227 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31228 Py_INCREF(obj);
31229 return Py_BuildValue((char *)"");
31230 }
31231 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31232 PyObject *resultobj;
31233 long arg1 ;
31234 wxWindow *arg2 = (wxWindow *) NULL ;
31235 wxWindow *result;
31236 PyObject * obj0 = 0 ;
31237 PyObject * obj1 = 0 ;
31238 char *kwnames[] = {
31239 (char *) "id",(char *) "parent", NULL
31240 };
31241
31242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31243 {
31244 arg1 = (long)(SWIG_As_long(obj0));
31245 if (SWIG_arg_fail(1)) SWIG_fail;
31246 }
31247 if (obj1) {
31248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31249 if (SWIG_arg_fail(2)) SWIG_fail;
31250 }
31251 {
31252 if (!wxPyCheckForApp()) SWIG_fail;
31253 PyThreadState* __tstate = wxPyBeginAllowThreads();
31254 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31255
31256 wxPyEndAllowThreads(__tstate);
31257 if (PyErr_Occurred()) SWIG_fail;
31258 }
31259 {
31260 resultobj = wxPyMake_wxObject(result, 0);
31261 }
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj;
31270 wxString *arg1 = 0 ;
31271 wxWindow *arg2 = (wxWindow *) NULL ;
31272 wxWindow *result;
31273 bool temp1 = false ;
31274 PyObject * obj0 = 0 ;
31275 PyObject * obj1 = 0 ;
31276 char *kwnames[] = {
31277 (char *) "name",(char *) "parent", NULL
31278 };
31279
31280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31281 {
31282 arg1 = wxString_in_helper(obj0);
31283 if (arg1 == NULL) SWIG_fail;
31284 temp1 = true;
31285 }
31286 if (obj1) {
31287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31288 if (SWIG_arg_fail(2)) SWIG_fail;
31289 }
31290 {
31291 if (!wxPyCheckForApp()) SWIG_fail;
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31294
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 {
31299 resultobj = wxPyMake_wxObject(result, 0);
31300 }
31301 {
31302 if (temp1)
31303 delete arg1;
31304 }
31305 return resultobj;
31306 fail:
31307 {
31308 if (temp1)
31309 delete arg1;
31310 }
31311 return NULL;
31312 }
31313
31314
31315 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj;
31317 wxString *arg1 = 0 ;
31318 wxWindow *arg2 = (wxWindow *) NULL ;
31319 wxWindow *result;
31320 bool temp1 = false ;
31321 PyObject * obj0 = 0 ;
31322 PyObject * obj1 = 0 ;
31323 char *kwnames[] = {
31324 (char *) "label",(char *) "parent", NULL
31325 };
31326
31327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31328 {
31329 arg1 = wxString_in_helper(obj0);
31330 if (arg1 == NULL) SWIG_fail;
31331 temp1 = true;
31332 }
31333 if (obj1) {
31334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31335 if (SWIG_arg_fail(2)) SWIG_fail;
31336 }
31337 {
31338 if (!wxPyCheckForApp()) SWIG_fail;
31339 PyThreadState* __tstate = wxPyBeginAllowThreads();
31340 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31341
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 {
31346 resultobj = wxPyMake_wxObject(result, 0);
31347 }
31348 {
31349 if (temp1)
31350 delete arg1;
31351 }
31352 return resultobj;
31353 fail:
31354 {
31355 if (temp1)
31356 delete arg1;
31357 }
31358 return NULL;
31359 }
31360
31361
31362 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31363 PyObject *resultobj;
31364 wxWindow *arg1 = (wxWindow *) 0 ;
31365 unsigned long arg2 ;
31366 wxWindow *result;
31367 PyObject * obj0 = 0 ;
31368 PyObject * obj1 = 0 ;
31369 char *kwnames[] = {
31370 (char *) "parent",(char *) "_hWnd", NULL
31371 };
31372
31373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31375 if (SWIG_arg_fail(1)) SWIG_fail;
31376 {
31377 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31378 if (SWIG_arg_fail(2)) SWIG_fail;
31379 }
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31383
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 {
31388 resultobj = wxPyMake_wxObject(result, 0);
31389 }
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31397 PyObject *resultobj;
31398 wxValidator *result;
31399 char *kwnames[] = {
31400 NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31404 {
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 result = (wxValidator *)new wxValidator();
31407
31408 wxPyEndAllowThreads(__tstate);
31409 if (PyErr_Occurred()) SWIG_fail;
31410 }
31411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31412 return resultobj;
31413 fail:
31414 return NULL;
31415 }
31416
31417
31418 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj;
31420 wxValidator *arg1 = (wxValidator *) 0 ;
31421 wxValidator *result;
31422 PyObject * obj0 = 0 ;
31423 char *kwnames[] = {
31424 (char *) "self", NULL
31425 };
31426
31427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31429 if (SWIG_arg_fail(1)) SWIG_fail;
31430 {
31431 PyThreadState* __tstate = wxPyBeginAllowThreads();
31432 result = (wxValidator *)(arg1)->Clone();
31433
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 {
31438 resultobj = wxPyMake_wxObject(result, 0);
31439 }
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj;
31448 wxValidator *arg1 = (wxValidator *) 0 ;
31449 wxWindow *arg2 = (wxWindow *) 0 ;
31450 bool result;
31451 PyObject * obj0 = 0 ;
31452 PyObject * obj1 = 0 ;
31453 char *kwnames[] = {
31454 (char *) "self",(char *) "parent", NULL
31455 };
31456
31457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31459 if (SWIG_arg_fail(1)) SWIG_fail;
31460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(2)) SWIG_fail;
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 result = (bool)(arg1)->Validate(arg2);
31465
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 {
31470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31471 }
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31479 PyObject *resultobj;
31480 wxValidator *arg1 = (wxValidator *) 0 ;
31481 bool result;
31482 PyObject * obj0 = 0 ;
31483 char *kwnames[] = {
31484 (char *) "self", NULL
31485 };
31486
31487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31489 if (SWIG_arg_fail(1)) SWIG_fail;
31490 {
31491 PyThreadState* __tstate = wxPyBeginAllowThreads();
31492 result = (bool)(arg1)->TransferToWindow();
31493
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 {
31498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31499 }
31500 return resultobj;
31501 fail:
31502 return NULL;
31503 }
31504
31505
31506 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj;
31508 wxValidator *arg1 = (wxValidator *) 0 ;
31509 bool result;
31510 PyObject * obj0 = 0 ;
31511 char *kwnames[] = {
31512 (char *) "self", NULL
31513 };
31514
31515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31517 if (SWIG_arg_fail(1)) SWIG_fail;
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 result = (bool)(arg1)->TransferFromWindow();
31521
31522 wxPyEndAllowThreads(__tstate);
31523 if (PyErr_Occurred()) SWIG_fail;
31524 }
31525 {
31526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31527 }
31528 return resultobj;
31529 fail:
31530 return NULL;
31531 }
31532
31533
31534 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31535 PyObject *resultobj;
31536 wxValidator *arg1 = (wxValidator *) 0 ;
31537 wxWindow *result;
31538 PyObject * obj0 = 0 ;
31539 char *kwnames[] = {
31540 (char *) "self", NULL
31541 };
31542
31543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31545 if (SWIG_arg_fail(1)) SWIG_fail;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 result = (wxWindow *)(arg1)->GetWindow();
31549
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 {
31554 resultobj = wxPyMake_wxObject(result, 0);
31555 }
31556 return resultobj;
31557 fail:
31558 return NULL;
31559 }
31560
31561
31562 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31563 PyObject *resultobj;
31564 wxValidator *arg1 = (wxValidator *) 0 ;
31565 wxWindow *arg2 = (wxWindow *) 0 ;
31566 PyObject * obj0 = 0 ;
31567 PyObject * obj1 = 0 ;
31568 char *kwnames[] = {
31569 (char *) "self",(char *) "window", NULL
31570 };
31571
31572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31574 if (SWIG_arg_fail(1)) SWIG_fail;
31575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31576 if (SWIG_arg_fail(2)) SWIG_fail;
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetWindow(arg2);
31580
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 Py_INCREF(Py_None); resultobj = Py_None;
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj;
31593 bool result;
31594 char *kwnames[] = {
31595 NULL
31596 };
31597
31598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 result = (bool)wxValidator::IsSilent();
31602
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 {
31607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31608 }
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31616 PyObject *resultobj;
31617 int arg1 = (int) true ;
31618 PyObject * obj0 = 0 ;
31619 char *kwnames[] = {
31620 (char *) "doIt", NULL
31621 };
31622
31623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31624 if (obj0) {
31625 {
31626 arg1 = (int)(SWIG_As_int(obj0));
31627 if (SWIG_arg_fail(1)) SWIG_fail;
31628 }
31629 }
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 wxValidator::SetBellOnError(arg1);
31633
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 Py_INCREF(Py_None); resultobj = Py_None;
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31645 PyObject *obj;
31646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31647 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31648 Py_INCREF(obj);
31649 return Py_BuildValue((char *)"");
31650 }
31651 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31652 PyObject *resultobj;
31653 wxPyValidator *result;
31654 char *kwnames[] = {
31655 NULL
31656 };
31657
31658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 result = (wxPyValidator *)new wxPyValidator();
31662
31663 wxPyEndAllowThreads(__tstate);
31664 if (PyErr_Occurred()) SWIG_fail;
31665 }
31666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31674 PyObject *resultobj;
31675 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31676 PyObject *arg2 = (PyObject *) 0 ;
31677 PyObject *arg3 = (PyObject *) 0 ;
31678 int arg4 = (int) true ;
31679 PyObject * obj0 = 0 ;
31680 PyObject * obj1 = 0 ;
31681 PyObject * obj2 = 0 ;
31682 PyObject * obj3 = 0 ;
31683 char *kwnames[] = {
31684 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31685 };
31686
31687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31689 if (SWIG_arg_fail(1)) SWIG_fail;
31690 arg2 = obj1;
31691 arg3 = obj2;
31692 if (obj3) {
31693 {
31694 arg4 = (int)(SWIG_As_int(obj3));
31695 if (SWIG_arg_fail(4)) SWIG_fail;
31696 }
31697 }
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31701
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 Py_INCREF(Py_None); resultobj = Py_None;
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31713 PyObject *obj;
31714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31715 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31716 Py_INCREF(obj);
31717 return Py_BuildValue((char *)"");
31718 }
31719 static int _wrap_DefaultValidator_set(PyObject *) {
31720 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31721 return 1;
31722 }
31723
31724
31725 static PyObject *_wrap_DefaultValidator_get(void) {
31726 PyObject *pyobj;
31727
31728 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31729 return pyobj;
31730 }
31731
31732
31733 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31734 PyObject *resultobj;
31735 wxString const &arg1_defvalue = wxPyEmptyString ;
31736 wxString *arg1 = (wxString *) &arg1_defvalue ;
31737 long arg2 = (long) 0 ;
31738 wxMenu *result;
31739 bool temp1 = false ;
31740 PyObject * obj0 = 0 ;
31741 PyObject * obj1 = 0 ;
31742 char *kwnames[] = {
31743 (char *) "title",(char *) "style", NULL
31744 };
31745
31746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31747 if (obj0) {
31748 {
31749 arg1 = wxString_in_helper(obj0);
31750 if (arg1 == NULL) SWIG_fail;
31751 temp1 = true;
31752 }
31753 }
31754 if (obj1) {
31755 {
31756 arg2 = (long)(SWIG_As_long(obj1));
31757 if (SWIG_arg_fail(2)) SWIG_fail;
31758 }
31759 }
31760 {
31761 if (!wxPyCheckForApp()) SWIG_fail;
31762 PyThreadState* __tstate = wxPyBeginAllowThreads();
31763 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31764
31765 wxPyEndAllowThreads(__tstate);
31766 if (PyErr_Occurred()) SWIG_fail;
31767 }
31768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31769 {
31770 if (temp1)
31771 delete arg1;
31772 }
31773 return resultobj;
31774 fail:
31775 {
31776 if (temp1)
31777 delete arg1;
31778 }
31779 return NULL;
31780 }
31781
31782
31783 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31784 PyObject *resultobj;
31785 wxMenu *arg1 = (wxMenu *) 0 ;
31786 int arg2 ;
31787 wxString *arg3 = 0 ;
31788 wxString const &arg4_defvalue = wxPyEmptyString ;
31789 wxString *arg4 = (wxString *) &arg4_defvalue ;
31790 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31791 wxMenuItem *result;
31792 bool temp3 = false ;
31793 bool temp4 = false ;
31794 PyObject * obj0 = 0 ;
31795 PyObject * obj1 = 0 ;
31796 PyObject * obj2 = 0 ;
31797 PyObject * obj3 = 0 ;
31798 PyObject * obj4 = 0 ;
31799 char *kwnames[] = {
31800 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31801 };
31802
31803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31805 if (SWIG_arg_fail(1)) SWIG_fail;
31806 {
31807 arg2 = (int)(SWIG_As_int(obj1));
31808 if (SWIG_arg_fail(2)) SWIG_fail;
31809 }
31810 {
31811 arg3 = wxString_in_helper(obj2);
31812 if (arg3 == NULL) SWIG_fail;
31813 temp3 = true;
31814 }
31815 if (obj3) {
31816 {
31817 arg4 = wxString_in_helper(obj3);
31818 if (arg4 == NULL) SWIG_fail;
31819 temp4 = true;
31820 }
31821 }
31822 if (obj4) {
31823 {
31824 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31825 if (SWIG_arg_fail(5)) SWIG_fail;
31826 }
31827 }
31828 {
31829 PyThreadState* __tstate = wxPyBeginAllowThreads();
31830 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31831
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 {
31836 resultobj = wxPyMake_wxObject(result, 0);
31837 }
31838 {
31839 if (temp3)
31840 delete arg3;
31841 }
31842 {
31843 if (temp4)
31844 delete arg4;
31845 }
31846 return resultobj;
31847 fail:
31848 {
31849 if (temp3)
31850 delete arg3;
31851 }
31852 {
31853 if (temp4)
31854 delete arg4;
31855 }
31856 return NULL;
31857 }
31858
31859
31860 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31861 PyObject *resultobj;
31862 wxMenu *arg1 = (wxMenu *) 0 ;
31863 wxMenuItem *result;
31864 PyObject * obj0 = 0 ;
31865 char *kwnames[] = {
31866 (char *) "self", NULL
31867 };
31868
31869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31871 if (SWIG_arg_fail(1)) SWIG_fail;
31872 {
31873 PyThreadState* __tstate = wxPyBeginAllowThreads();
31874 result = (wxMenuItem *)(arg1)->AppendSeparator();
31875
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 {
31880 resultobj = wxPyMake_wxObject(result, 0);
31881 }
31882 return resultobj;
31883 fail:
31884 return NULL;
31885 }
31886
31887
31888 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31889 PyObject *resultobj;
31890 wxMenu *arg1 = (wxMenu *) 0 ;
31891 int arg2 ;
31892 wxString *arg3 = 0 ;
31893 wxString const &arg4_defvalue = wxPyEmptyString ;
31894 wxString *arg4 = (wxString *) &arg4_defvalue ;
31895 wxMenuItem *result;
31896 bool temp3 = false ;
31897 bool temp4 = false ;
31898 PyObject * obj0 = 0 ;
31899 PyObject * obj1 = 0 ;
31900 PyObject * obj2 = 0 ;
31901 PyObject * obj3 = 0 ;
31902 char *kwnames[] = {
31903 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31904 };
31905
31906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31908 if (SWIG_arg_fail(1)) SWIG_fail;
31909 {
31910 arg2 = (int)(SWIG_As_int(obj1));
31911 if (SWIG_arg_fail(2)) SWIG_fail;
31912 }
31913 {
31914 arg3 = wxString_in_helper(obj2);
31915 if (arg3 == NULL) SWIG_fail;
31916 temp3 = true;
31917 }
31918 if (obj3) {
31919 {
31920 arg4 = wxString_in_helper(obj3);
31921 if (arg4 == NULL) SWIG_fail;
31922 temp4 = true;
31923 }
31924 }
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31928
31929 wxPyEndAllowThreads(__tstate);
31930 if (PyErr_Occurred()) SWIG_fail;
31931 }
31932 {
31933 resultobj = wxPyMake_wxObject(result, 0);
31934 }
31935 {
31936 if (temp3)
31937 delete arg3;
31938 }
31939 {
31940 if (temp4)
31941 delete arg4;
31942 }
31943 return resultobj;
31944 fail:
31945 {
31946 if (temp3)
31947 delete arg3;
31948 }
31949 {
31950 if (temp4)
31951 delete arg4;
31952 }
31953 return NULL;
31954 }
31955
31956
31957 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
31958 PyObject *resultobj;
31959 wxMenu *arg1 = (wxMenu *) 0 ;
31960 int arg2 ;
31961 wxString *arg3 = 0 ;
31962 wxString const &arg4_defvalue = wxPyEmptyString ;
31963 wxString *arg4 = (wxString *) &arg4_defvalue ;
31964 wxMenuItem *result;
31965 bool temp3 = false ;
31966 bool temp4 = false ;
31967 PyObject * obj0 = 0 ;
31968 PyObject * obj1 = 0 ;
31969 PyObject * obj2 = 0 ;
31970 PyObject * obj3 = 0 ;
31971 char *kwnames[] = {
31972 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31973 };
31974
31975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31977 if (SWIG_arg_fail(1)) SWIG_fail;
31978 {
31979 arg2 = (int)(SWIG_As_int(obj1));
31980 if (SWIG_arg_fail(2)) SWIG_fail;
31981 }
31982 {
31983 arg3 = wxString_in_helper(obj2);
31984 if (arg3 == NULL) SWIG_fail;
31985 temp3 = true;
31986 }
31987 if (obj3) {
31988 {
31989 arg4 = wxString_in_helper(obj3);
31990 if (arg4 == NULL) SWIG_fail;
31991 temp4 = true;
31992 }
31993 }
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31997
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 {
32002 resultobj = wxPyMake_wxObject(result, 0);
32003 }
32004 {
32005 if (temp3)
32006 delete arg3;
32007 }
32008 {
32009 if (temp4)
32010 delete arg4;
32011 }
32012 return resultobj;
32013 fail:
32014 {
32015 if (temp3)
32016 delete arg3;
32017 }
32018 {
32019 if (temp4)
32020 delete arg4;
32021 }
32022 return NULL;
32023 }
32024
32025
32026 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32027 PyObject *resultobj;
32028 wxMenu *arg1 = (wxMenu *) 0 ;
32029 int arg2 ;
32030 wxString *arg3 = 0 ;
32031 wxMenu *arg4 = (wxMenu *) 0 ;
32032 wxString const &arg5_defvalue = wxPyEmptyString ;
32033 wxString *arg5 = (wxString *) &arg5_defvalue ;
32034 wxMenuItem *result;
32035 bool temp3 = false ;
32036 bool temp5 = false ;
32037 PyObject * obj0 = 0 ;
32038 PyObject * obj1 = 0 ;
32039 PyObject * obj2 = 0 ;
32040 PyObject * obj3 = 0 ;
32041 PyObject * obj4 = 0 ;
32042 char *kwnames[] = {
32043 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32044 };
32045
32046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32048 if (SWIG_arg_fail(1)) SWIG_fail;
32049 {
32050 arg2 = (int)(SWIG_As_int(obj1));
32051 if (SWIG_arg_fail(2)) SWIG_fail;
32052 }
32053 {
32054 arg3 = wxString_in_helper(obj2);
32055 if (arg3 == NULL) SWIG_fail;
32056 temp3 = true;
32057 }
32058 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32059 if (SWIG_arg_fail(4)) SWIG_fail;
32060 if (obj4) {
32061 {
32062 arg5 = wxString_in_helper(obj4);
32063 if (arg5 == NULL) SWIG_fail;
32064 temp5 = true;
32065 }
32066 }
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32070
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 {
32075 resultobj = wxPyMake_wxObject(result, 0);
32076 }
32077 {
32078 if (temp3)
32079 delete arg3;
32080 }
32081 {
32082 if (temp5)
32083 delete arg5;
32084 }
32085 return resultobj;
32086 fail:
32087 {
32088 if (temp3)
32089 delete arg3;
32090 }
32091 {
32092 if (temp5)
32093 delete arg5;
32094 }
32095 return NULL;
32096 }
32097
32098
32099 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj;
32101 wxMenu *arg1 = (wxMenu *) 0 ;
32102 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32103 wxMenuItem *result;
32104 PyObject * obj0 = 0 ;
32105 PyObject * obj1 = 0 ;
32106 char *kwnames[] = {
32107 (char *) "self",(char *) "item", NULL
32108 };
32109
32110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32112 if (SWIG_arg_fail(1)) SWIG_fail;
32113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32114 if (SWIG_arg_fail(2)) SWIG_fail;
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (wxMenuItem *)(arg1)->Append(arg2);
32118
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 {
32123 resultobj = wxPyMake_wxObject(result, 0);
32124 }
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32132 PyObject *resultobj;
32133 wxMenu *arg1 = (wxMenu *) 0 ;
32134 PyObject * obj0 = 0 ;
32135 char *kwnames[] = {
32136 (char *) "self", NULL
32137 };
32138
32139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32141 if (SWIG_arg_fail(1)) SWIG_fail;
32142 {
32143 PyThreadState* __tstate = wxPyBeginAllowThreads();
32144 (arg1)->Break();
32145
32146 wxPyEndAllowThreads(__tstate);
32147 if (PyErr_Occurred()) SWIG_fail;
32148 }
32149 Py_INCREF(Py_None); resultobj = Py_None;
32150 return resultobj;
32151 fail:
32152 return NULL;
32153 }
32154
32155
32156 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32157 PyObject *resultobj;
32158 wxMenu *arg1 = (wxMenu *) 0 ;
32159 size_t arg2 ;
32160 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32161 wxMenuItem *result;
32162 PyObject * obj0 = 0 ;
32163 PyObject * obj1 = 0 ;
32164 PyObject * obj2 = 0 ;
32165 char *kwnames[] = {
32166 (char *) "self",(char *) "pos",(char *) "item", NULL
32167 };
32168
32169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32171 if (SWIG_arg_fail(1)) SWIG_fail;
32172 {
32173 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32174 if (SWIG_arg_fail(2)) SWIG_fail;
32175 }
32176 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32177 if (SWIG_arg_fail(3)) SWIG_fail;
32178 {
32179 PyThreadState* __tstate = wxPyBeginAllowThreads();
32180 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32181
32182 wxPyEndAllowThreads(__tstate);
32183 if (PyErr_Occurred()) SWIG_fail;
32184 }
32185 {
32186 resultobj = wxPyMake_wxObject(result, 0);
32187 }
32188 return resultobj;
32189 fail:
32190 return NULL;
32191 }
32192
32193
32194 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32195 PyObject *resultobj;
32196 wxMenu *arg1 = (wxMenu *) 0 ;
32197 size_t arg2 ;
32198 int arg3 ;
32199 wxString *arg4 = 0 ;
32200 wxString const &arg5_defvalue = wxPyEmptyString ;
32201 wxString *arg5 = (wxString *) &arg5_defvalue ;
32202 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32203 wxMenuItem *result;
32204 bool temp4 = false ;
32205 bool temp5 = false ;
32206 PyObject * obj0 = 0 ;
32207 PyObject * obj1 = 0 ;
32208 PyObject * obj2 = 0 ;
32209 PyObject * obj3 = 0 ;
32210 PyObject * obj4 = 0 ;
32211 PyObject * obj5 = 0 ;
32212 char *kwnames[] = {
32213 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32214 };
32215
32216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32218 if (SWIG_arg_fail(1)) SWIG_fail;
32219 {
32220 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32221 if (SWIG_arg_fail(2)) SWIG_fail;
32222 }
32223 {
32224 arg3 = (int)(SWIG_As_int(obj2));
32225 if (SWIG_arg_fail(3)) SWIG_fail;
32226 }
32227 {
32228 arg4 = wxString_in_helper(obj3);
32229 if (arg4 == NULL) SWIG_fail;
32230 temp4 = true;
32231 }
32232 if (obj4) {
32233 {
32234 arg5 = wxString_in_helper(obj4);
32235 if (arg5 == NULL) SWIG_fail;
32236 temp5 = true;
32237 }
32238 }
32239 if (obj5) {
32240 {
32241 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32242 if (SWIG_arg_fail(6)) SWIG_fail;
32243 }
32244 }
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32248
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 {
32253 resultobj = wxPyMake_wxObject(result, 0);
32254 }
32255 {
32256 if (temp4)
32257 delete arg4;
32258 }
32259 {
32260 if (temp5)
32261 delete arg5;
32262 }
32263 return resultobj;
32264 fail:
32265 {
32266 if (temp4)
32267 delete arg4;
32268 }
32269 {
32270 if (temp5)
32271 delete arg5;
32272 }
32273 return NULL;
32274 }
32275
32276
32277 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32278 PyObject *resultobj;
32279 wxMenu *arg1 = (wxMenu *) 0 ;
32280 size_t arg2 ;
32281 wxMenuItem *result;
32282 PyObject * obj0 = 0 ;
32283 PyObject * obj1 = 0 ;
32284 char *kwnames[] = {
32285 (char *) "self",(char *) "pos", NULL
32286 };
32287
32288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32290 if (SWIG_arg_fail(1)) SWIG_fail;
32291 {
32292 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32293 if (SWIG_arg_fail(2)) SWIG_fail;
32294 }
32295 {
32296 PyThreadState* __tstate = wxPyBeginAllowThreads();
32297 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32298
32299 wxPyEndAllowThreads(__tstate);
32300 if (PyErr_Occurred()) SWIG_fail;
32301 }
32302 {
32303 resultobj = wxPyMake_wxObject(result, 0);
32304 }
32305 return resultobj;
32306 fail:
32307 return NULL;
32308 }
32309
32310
32311 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32312 PyObject *resultobj;
32313 wxMenu *arg1 = (wxMenu *) 0 ;
32314 size_t arg2 ;
32315 int arg3 ;
32316 wxString *arg4 = 0 ;
32317 wxString const &arg5_defvalue = wxPyEmptyString ;
32318 wxString *arg5 = (wxString *) &arg5_defvalue ;
32319 wxMenuItem *result;
32320 bool temp4 = false ;
32321 bool temp5 = false ;
32322 PyObject * obj0 = 0 ;
32323 PyObject * obj1 = 0 ;
32324 PyObject * obj2 = 0 ;
32325 PyObject * obj3 = 0 ;
32326 PyObject * obj4 = 0 ;
32327 char *kwnames[] = {
32328 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32329 };
32330
32331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32333 if (SWIG_arg_fail(1)) SWIG_fail;
32334 {
32335 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32336 if (SWIG_arg_fail(2)) SWIG_fail;
32337 }
32338 {
32339 arg3 = (int)(SWIG_As_int(obj2));
32340 if (SWIG_arg_fail(3)) SWIG_fail;
32341 }
32342 {
32343 arg4 = wxString_in_helper(obj3);
32344 if (arg4 == NULL) SWIG_fail;
32345 temp4 = true;
32346 }
32347 if (obj4) {
32348 {
32349 arg5 = wxString_in_helper(obj4);
32350 if (arg5 == NULL) SWIG_fail;
32351 temp5 = true;
32352 }
32353 }
32354 {
32355 PyThreadState* __tstate = wxPyBeginAllowThreads();
32356 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32357
32358 wxPyEndAllowThreads(__tstate);
32359 if (PyErr_Occurred()) SWIG_fail;
32360 }
32361 {
32362 resultobj = wxPyMake_wxObject(result, 0);
32363 }
32364 {
32365 if (temp4)
32366 delete arg4;
32367 }
32368 {
32369 if (temp5)
32370 delete arg5;
32371 }
32372 return resultobj;
32373 fail:
32374 {
32375 if (temp4)
32376 delete arg4;
32377 }
32378 {
32379 if (temp5)
32380 delete arg5;
32381 }
32382 return NULL;
32383 }
32384
32385
32386 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32387 PyObject *resultobj;
32388 wxMenu *arg1 = (wxMenu *) 0 ;
32389 size_t arg2 ;
32390 int arg3 ;
32391 wxString *arg4 = 0 ;
32392 wxString const &arg5_defvalue = wxPyEmptyString ;
32393 wxString *arg5 = (wxString *) &arg5_defvalue ;
32394 wxMenuItem *result;
32395 bool temp4 = false ;
32396 bool temp5 = false ;
32397 PyObject * obj0 = 0 ;
32398 PyObject * obj1 = 0 ;
32399 PyObject * obj2 = 0 ;
32400 PyObject * obj3 = 0 ;
32401 PyObject * obj4 = 0 ;
32402 char *kwnames[] = {
32403 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32404 };
32405
32406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32408 if (SWIG_arg_fail(1)) SWIG_fail;
32409 {
32410 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32411 if (SWIG_arg_fail(2)) SWIG_fail;
32412 }
32413 {
32414 arg3 = (int)(SWIG_As_int(obj2));
32415 if (SWIG_arg_fail(3)) SWIG_fail;
32416 }
32417 {
32418 arg4 = wxString_in_helper(obj3);
32419 if (arg4 == NULL) SWIG_fail;
32420 temp4 = true;
32421 }
32422 if (obj4) {
32423 {
32424 arg5 = wxString_in_helper(obj4);
32425 if (arg5 == NULL) SWIG_fail;
32426 temp5 = true;
32427 }
32428 }
32429 {
32430 PyThreadState* __tstate = wxPyBeginAllowThreads();
32431 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32432
32433 wxPyEndAllowThreads(__tstate);
32434 if (PyErr_Occurred()) SWIG_fail;
32435 }
32436 {
32437 resultobj = wxPyMake_wxObject(result, 0);
32438 }
32439 {
32440 if (temp4)
32441 delete arg4;
32442 }
32443 {
32444 if (temp5)
32445 delete arg5;
32446 }
32447 return resultobj;
32448 fail:
32449 {
32450 if (temp4)
32451 delete arg4;
32452 }
32453 {
32454 if (temp5)
32455 delete arg5;
32456 }
32457 return NULL;
32458 }
32459
32460
32461 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32462 PyObject *resultobj;
32463 wxMenu *arg1 = (wxMenu *) 0 ;
32464 size_t arg2 ;
32465 int arg3 ;
32466 wxString *arg4 = 0 ;
32467 wxMenu *arg5 = (wxMenu *) 0 ;
32468 wxString const &arg6_defvalue = wxPyEmptyString ;
32469 wxString *arg6 = (wxString *) &arg6_defvalue ;
32470 wxMenuItem *result;
32471 bool temp4 = false ;
32472 bool temp6 = false ;
32473 PyObject * obj0 = 0 ;
32474 PyObject * obj1 = 0 ;
32475 PyObject * obj2 = 0 ;
32476 PyObject * obj3 = 0 ;
32477 PyObject * obj4 = 0 ;
32478 PyObject * obj5 = 0 ;
32479 char *kwnames[] = {
32480 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32481 };
32482
32483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32485 if (SWIG_arg_fail(1)) SWIG_fail;
32486 {
32487 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32488 if (SWIG_arg_fail(2)) SWIG_fail;
32489 }
32490 {
32491 arg3 = (int)(SWIG_As_int(obj2));
32492 if (SWIG_arg_fail(3)) SWIG_fail;
32493 }
32494 {
32495 arg4 = wxString_in_helper(obj3);
32496 if (arg4 == NULL) SWIG_fail;
32497 temp4 = true;
32498 }
32499 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32500 if (SWIG_arg_fail(5)) SWIG_fail;
32501 if (obj5) {
32502 {
32503 arg6 = wxString_in_helper(obj5);
32504 if (arg6 == NULL) SWIG_fail;
32505 temp6 = true;
32506 }
32507 }
32508 {
32509 PyThreadState* __tstate = wxPyBeginAllowThreads();
32510 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32511
32512 wxPyEndAllowThreads(__tstate);
32513 if (PyErr_Occurred()) SWIG_fail;
32514 }
32515 {
32516 resultobj = wxPyMake_wxObject(result, 0);
32517 }
32518 {
32519 if (temp4)
32520 delete arg4;
32521 }
32522 {
32523 if (temp6)
32524 delete arg6;
32525 }
32526 return resultobj;
32527 fail:
32528 {
32529 if (temp4)
32530 delete arg4;
32531 }
32532 {
32533 if (temp6)
32534 delete arg6;
32535 }
32536 return NULL;
32537 }
32538
32539
32540 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32541 PyObject *resultobj;
32542 wxMenu *arg1 = (wxMenu *) 0 ;
32543 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32544 wxMenuItem *result;
32545 PyObject * obj0 = 0 ;
32546 PyObject * obj1 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "self",(char *) "item", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32553 if (SWIG_arg_fail(1)) SWIG_fail;
32554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32555 if (SWIG_arg_fail(2)) SWIG_fail;
32556 {
32557 PyThreadState* __tstate = wxPyBeginAllowThreads();
32558 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32559
32560 wxPyEndAllowThreads(__tstate);
32561 if (PyErr_Occurred()) SWIG_fail;
32562 }
32563 {
32564 resultobj = wxPyMake_wxObject(result, 0);
32565 }
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32573 PyObject *resultobj;
32574 wxMenu *arg1 = (wxMenu *) 0 ;
32575 int arg2 ;
32576 wxString *arg3 = 0 ;
32577 wxString const &arg4_defvalue = wxPyEmptyString ;
32578 wxString *arg4 = (wxString *) &arg4_defvalue ;
32579 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32580 wxMenuItem *result;
32581 bool temp3 = false ;
32582 bool temp4 = false ;
32583 PyObject * obj0 = 0 ;
32584 PyObject * obj1 = 0 ;
32585 PyObject * obj2 = 0 ;
32586 PyObject * obj3 = 0 ;
32587 PyObject * obj4 = 0 ;
32588 char *kwnames[] = {
32589 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32590 };
32591
32592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32594 if (SWIG_arg_fail(1)) SWIG_fail;
32595 {
32596 arg2 = (int)(SWIG_As_int(obj1));
32597 if (SWIG_arg_fail(2)) SWIG_fail;
32598 }
32599 {
32600 arg3 = wxString_in_helper(obj2);
32601 if (arg3 == NULL) SWIG_fail;
32602 temp3 = true;
32603 }
32604 if (obj3) {
32605 {
32606 arg4 = wxString_in_helper(obj3);
32607 if (arg4 == NULL) SWIG_fail;
32608 temp4 = true;
32609 }
32610 }
32611 if (obj4) {
32612 {
32613 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32614 if (SWIG_arg_fail(5)) SWIG_fail;
32615 }
32616 }
32617 {
32618 PyThreadState* __tstate = wxPyBeginAllowThreads();
32619 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32620
32621 wxPyEndAllowThreads(__tstate);
32622 if (PyErr_Occurred()) SWIG_fail;
32623 }
32624 {
32625 resultobj = wxPyMake_wxObject(result, 0);
32626 }
32627 {
32628 if (temp3)
32629 delete arg3;
32630 }
32631 {
32632 if (temp4)
32633 delete arg4;
32634 }
32635 return resultobj;
32636 fail:
32637 {
32638 if (temp3)
32639 delete arg3;
32640 }
32641 {
32642 if (temp4)
32643 delete arg4;
32644 }
32645 return NULL;
32646 }
32647
32648
32649 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32650 PyObject *resultobj;
32651 wxMenu *arg1 = (wxMenu *) 0 ;
32652 wxMenuItem *result;
32653 PyObject * obj0 = 0 ;
32654 char *kwnames[] = {
32655 (char *) "self", NULL
32656 };
32657
32658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32660 if (SWIG_arg_fail(1)) SWIG_fail;
32661 {
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 result = (wxMenuItem *)(arg1)->PrependSeparator();
32664
32665 wxPyEndAllowThreads(__tstate);
32666 if (PyErr_Occurred()) SWIG_fail;
32667 }
32668 {
32669 resultobj = wxPyMake_wxObject(result, 0);
32670 }
32671 return resultobj;
32672 fail:
32673 return NULL;
32674 }
32675
32676
32677 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32678 PyObject *resultobj;
32679 wxMenu *arg1 = (wxMenu *) 0 ;
32680 int arg2 ;
32681 wxString *arg3 = 0 ;
32682 wxString const &arg4_defvalue = wxPyEmptyString ;
32683 wxString *arg4 = (wxString *) &arg4_defvalue ;
32684 wxMenuItem *result;
32685 bool temp3 = false ;
32686 bool temp4 = false ;
32687 PyObject * obj0 = 0 ;
32688 PyObject * obj1 = 0 ;
32689 PyObject * obj2 = 0 ;
32690 PyObject * obj3 = 0 ;
32691 char *kwnames[] = {
32692 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32693 };
32694
32695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32697 if (SWIG_arg_fail(1)) SWIG_fail;
32698 {
32699 arg2 = (int)(SWIG_As_int(obj1));
32700 if (SWIG_arg_fail(2)) SWIG_fail;
32701 }
32702 {
32703 arg3 = wxString_in_helper(obj2);
32704 if (arg3 == NULL) SWIG_fail;
32705 temp3 = true;
32706 }
32707 if (obj3) {
32708 {
32709 arg4 = wxString_in_helper(obj3);
32710 if (arg4 == NULL) SWIG_fail;
32711 temp4 = true;
32712 }
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32717
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 {
32722 resultobj = wxPyMake_wxObject(result, 0);
32723 }
32724 {
32725 if (temp3)
32726 delete arg3;
32727 }
32728 {
32729 if (temp4)
32730 delete arg4;
32731 }
32732 return resultobj;
32733 fail:
32734 {
32735 if (temp3)
32736 delete arg3;
32737 }
32738 {
32739 if (temp4)
32740 delete arg4;
32741 }
32742 return NULL;
32743 }
32744
32745
32746 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32747 PyObject *resultobj;
32748 wxMenu *arg1 = (wxMenu *) 0 ;
32749 int arg2 ;
32750 wxString *arg3 = 0 ;
32751 wxString const &arg4_defvalue = wxPyEmptyString ;
32752 wxString *arg4 = (wxString *) &arg4_defvalue ;
32753 wxMenuItem *result;
32754 bool temp3 = false ;
32755 bool temp4 = false ;
32756 PyObject * obj0 = 0 ;
32757 PyObject * obj1 = 0 ;
32758 PyObject * obj2 = 0 ;
32759 PyObject * obj3 = 0 ;
32760 char *kwnames[] = {
32761 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32762 };
32763
32764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32766 if (SWIG_arg_fail(1)) SWIG_fail;
32767 {
32768 arg2 = (int)(SWIG_As_int(obj1));
32769 if (SWIG_arg_fail(2)) SWIG_fail;
32770 }
32771 {
32772 arg3 = wxString_in_helper(obj2);
32773 if (arg3 == NULL) SWIG_fail;
32774 temp3 = true;
32775 }
32776 if (obj3) {
32777 {
32778 arg4 = wxString_in_helper(obj3);
32779 if (arg4 == NULL) SWIG_fail;
32780 temp4 = true;
32781 }
32782 }
32783 {
32784 PyThreadState* __tstate = wxPyBeginAllowThreads();
32785 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32786
32787 wxPyEndAllowThreads(__tstate);
32788 if (PyErr_Occurred()) SWIG_fail;
32789 }
32790 {
32791 resultobj = wxPyMake_wxObject(result, 0);
32792 }
32793 {
32794 if (temp3)
32795 delete arg3;
32796 }
32797 {
32798 if (temp4)
32799 delete arg4;
32800 }
32801 return resultobj;
32802 fail:
32803 {
32804 if (temp3)
32805 delete arg3;
32806 }
32807 {
32808 if (temp4)
32809 delete arg4;
32810 }
32811 return NULL;
32812 }
32813
32814
32815 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32816 PyObject *resultobj;
32817 wxMenu *arg1 = (wxMenu *) 0 ;
32818 int arg2 ;
32819 wxString *arg3 = 0 ;
32820 wxMenu *arg4 = (wxMenu *) 0 ;
32821 wxString const &arg5_defvalue = wxPyEmptyString ;
32822 wxString *arg5 = (wxString *) &arg5_defvalue ;
32823 wxMenuItem *result;
32824 bool temp3 = false ;
32825 bool temp5 = false ;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 PyObject * obj2 = 0 ;
32829 PyObject * obj3 = 0 ;
32830 PyObject * obj4 = 0 ;
32831 char *kwnames[] = {
32832 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32833 };
32834
32835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32837 if (SWIG_arg_fail(1)) SWIG_fail;
32838 {
32839 arg2 = (int)(SWIG_As_int(obj1));
32840 if (SWIG_arg_fail(2)) SWIG_fail;
32841 }
32842 {
32843 arg3 = wxString_in_helper(obj2);
32844 if (arg3 == NULL) SWIG_fail;
32845 temp3 = true;
32846 }
32847 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32848 if (SWIG_arg_fail(4)) SWIG_fail;
32849 if (obj4) {
32850 {
32851 arg5 = wxString_in_helper(obj4);
32852 if (arg5 == NULL) SWIG_fail;
32853 temp5 = true;
32854 }
32855 }
32856 {
32857 PyThreadState* __tstate = wxPyBeginAllowThreads();
32858 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32859
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 {
32864 resultobj = wxPyMake_wxObject(result, 0);
32865 }
32866 {
32867 if (temp3)
32868 delete arg3;
32869 }
32870 {
32871 if (temp5)
32872 delete arg5;
32873 }
32874 return resultobj;
32875 fail:
32876 {
32877 if (temp3)
32878 delete arg3;
32879 }
32880 {
32881 if (temp5)
32882 delete arg5;
32883 }
32884 return NULL;
32885 }
32886
32887
32888 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32889 PyObject *resultobj;
32890 wxMenu *arg1 = (wxMenu *) 0 ;
32891 int arg2 ;
32892 wxMenuItem *result;
32893 PyObject * obj0 = 0 ;
32894 PyObject * obj1 = 0 ;
32895 char *kwnames[] = {
32896 (char *) "self",(char *) "id", NULL
32897 };
32898
32899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32901 if (SWIG_arg_fail(1)) SWIG_fail;
32902 {
32903 arg2 = (int)(SWIG_As_int(obj1));
32904 if (SWIG_arg_fail(2)) SWIG_fail;
32905 }
32906 {
32907 PyThreadState* __tstate = wxPyBeginAllowThreads();
32908 result = (wxMenuItem *)(arg1)->Remove(arg2);
32909
32910 wxPyEndAllowThreads(__tstate);
32911 if (PyErr_Occurred()) SWIG_fail;
32912 }
32913 {
32914 resultobj = wxPyMake_wxObject(result, 0);
32915 }
32916 return resultobj;
32917 fail:
32918 return NULL;
32919 }
32920
32921
32922 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32923 PyObject *resultobj;
32924 wxMenu *arg1 = (wxMenu *) 0 ;
32925 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32926 wxMenuItem *result;
32927 PyObject * obj0 = 0 ;
32928 PyObject * obj1 = 0 ;
32929 char *kwnames[] = {
32930 (char *) "self",(char *) "item", NULL
32931 };
32932
32933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32935 if (SWIG_arg_fail(1)) SWIG_fail;
32936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32937 if (SWIG_arg_fail(2)) SWIG_fail;
32938 {
32939 PyThreadState* __tstate = wxPyBeginAllowThreads();
32940 result = (wxMenuItem *)(arg1)->Remove(arg2);
32941
32942 wxPyEndAllowThreads(__tstate);
32943 if (PyErr_Occurred()) SWIG_fail;
32944 }
32945 {
32946 resultobj = wxPyMake_wxObject(result, 0);
32947 }
32948 return resultobj;
32949 fail:
32950 return NULL;
32951 }
32952
32953
32954 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
32955 PyObject *resultobj;
32956 wxMenu *arg1 = (wxMenu *) 0 ;
32957 int arg2 ;
32958 bool result;
32959 PyObject * obj0 = 0 ;
32960 PyObject * obj1 = 0 ;
32961 char *kwnames[] = {
32962 (char *) "self",(char *) "id", NULL
32963 };
32964
32965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
32966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32967 if (SWIG_arg_fail(1)) SWIG_fail;
32968 {
32969 arg2 = (int)(SWIG_As_int(obj1));
32970 if (SWIG_arg_fail(2)) SWIG_fail;
32971 }
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 result = (bool)(arg1)->Delete(arg2);
32975
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 {
32980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32981 }
32982 return resultobj;
32983 fail:
32984 return NULL;
32985 }
32986
32987
32988 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj;
32990 wxMenu *arg1 = (wxMenu *) 0 ;
32991 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32992 bool result;
32993 PyObject * obj0 = 0 ;
32994 PyObject * obj1 = 0 ;
32995 char *kwnames[] = {
32996 (char *) "self",(char *) "item", NULL
32997 };
32998
32999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33001 if (SWIG_arg_fail(1)) SWIG_fail;
33002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33003 if (SWIG_arg_fail(2)) SWIG_fail;
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (bool)(arg1)->Delete(arg2);
33007
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 {
33012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33013 }
33014 return resultobj;
33015 fail:
33016 return NULL;
33017 }
33018
33019
33020 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33021 PyObject *resultobj;
33022 wxMenu *arg1 = (wxMenu *) 0 ;
33023 PyObject * obj0 = 0 ;
33024 char *kwnames[] = {
33025 (char *) "self", NULL
33026 };
33027
33028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33030 if (SWIG_arg_fail(1)) SWIG_fail;
33031 {
33032 PyThreadState* __tstate = wxPyBeginAllowThreads();
33033 wxMenu_Destroy(arg1);
33034
33035 wxPyEndAllowThreads(__tstate);
33036 if (PyErr_Occurred()) SWIG_fail;
33037 }
33038 Py_INCREF(Py_None); resultobj = Py_None;
33039 return resultobj;
33040 fail:
33041 return NULL;
33042 }
33043
33044
33045 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33046 PyObject *resultobj;
33047 wxMenu *arg1 = (wxMenu *) 0 ;
33048 int arg2 ;
33049 bool result;
33050 PyObject * obj0 = 0 ;
33051 PyObject * obj1 = 0 ;
33052 char *kwnames[] = {
33053 (char *) "self",(char *) "id", NULL
33054 };
33055
33056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33058 if (SWIG_arg_fail(1)) SWIG_fail;
33059 {
33060 arg2 = (int)(SWIG_As_int(obj1));
33061 if (SWIG_arg_fail(2)) SWIG_fail;
33062 }
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (bool)(arg1)->Destroy(arg2);
33066
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 {
33071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33072 }
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj;
33081 wxMenu *arg1 = (wxMenu *) 0 ;
33082 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33083 bool result;
33084 PyObject * obj0 = 0 ;
33085 PyObject * obj1 = 0 ;
33086 char *kwnames[] = {
33087 (char *) "self",(char *) "item", NULL
33088 };
33089
33090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33092 if (SWIG_arg_fail(1)) SWIG_fail;
33093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33094 if (SWIG_arg_fail(2)) SWIG_fail;
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 result = (bool)(arg1)->Destroy(arg2);
33098
33099 wxPyEndAllowThreads(__tstate);
33100 if (PyErr_Occurred()) SWIG_fail;
33101 }
33102 {
33103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33104 }
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj;
33113 wxMenu *arg1 = (wxMenu *) 0 ;
33114 size_t result;
33115 PyObject * obj0 = 0 ;
33116 char *kwnames[] = {
33117 (char *) "self", NULL
33118 };
33119
33120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33122 if (SWIG_arg_fail(1)) SWIG_fail;
33123 {
33124 PyThreadState* __tstate = wxPyBeginAllowThreads();
33125 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33126
33127 wxPyEndAllowThreads(__tstate);
33128 if (PyErr_Occurred()) SWIG_fail;
33129 }
33130 {
33131 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33132 }
33133 return resultobj;
33134 fail:
33135 return NULL;
33136 }
33137
33138
33139 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33140 PyObject *resultobj;
33141 wxMenu *arg1 = (wxMenu *) 0 ;
33142 PyObject *result;
33143 PyObject * obj0 = 0 ;
33144 char *kwnames[] = {
33145 (char *) "self", NULL
33146 };
33147
33148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33150 if (SWIG_arg_fail(1)) SWIG_fail;
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33154
33155 wxPyEndAllowThreads(__tstate);
33156 if (PyErr_Occurred()) SWIG_fail;
33157 }
33158 resultobj = result;
33159 return resultobj;
33160 fail:
33161 return NULL;
33162 }
33163
33164
33165 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj;
33167 wxMenu *arg1 = (wxMenu *) 0 ;
33168 wxString *arg2 = 0 ;
33169 int result;
33170 bool temp2 = false ;
33171 PyObject * obj0 = 0 ;
33172 PyObject * obj1 = 0 ;
33173 char *kwnames[] = {
33174 (char *) "self",(char *) "item", NULL
33175 };
33176
33177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33179 if (SWIG_arg_fail(1)) SWIG_fail;
33180 {
33181 arg2 = wxString_in_helper(obj1);
33182 if (arg2 == NULL) SWIG_fail;
33183 temp2 = true;
33184 }
33185 {
33186 PyThreadState* __tstate = wxPyBeginAllowThreads();
33187 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33188
33189 wxPyEndAllowThreads(__tstate);
33190 if (PyErr_Occurred()) SWIG_fail;
33191 }
33192 {
33193 resultobj = SWIG_From_int((int)(result));
33194 }
33195 {
33196 if (temp2)
33197 delete arg2;
33198 }
33199 return resultobj;
33200 fail:
33201 {
33202 if (temp2)
33203 delete arg2;
33204 }
33205 return NULL;
33206 }
33207
33208
33209 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33210 PyObject *resultobj;
33211 wxMenu *arg1 = (wxMenu *) 0 ;
33212 int arg2 ;
33213 wxMenuItem *result;
33214 PyObject * obj0 = 0 ;
33215 PyObject * obj1 = 0 ;
33216 char *kwnames[] = {
33217 (char *) "self",(char *) "id", NULL
33218 };
33219
33220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33222 if (SWIG_arg_fail(1)) SWIG_fail;
33223 {
33224 arg2 = (int)(SWIG_As_int(obj1));
33225 if (SWIG_arg_fail(2)) SWIG_fail;
33226 }
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33230
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 {
33235 resultobj = wxPyMake_wxObject(result, 0);
33236 }
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33244 PyObject *resultobj;
33245 wxMenu *arg1 = (wxMenu *) 0 ;
33246 size_t arg2 ;
33247 wxMenuItem *result;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 char *kwnames[] = {
33251 (char *) "self",(char *) "position", NULL
33252 };
33253
33254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33256 if (SWIG_arg_fail(1)) SWIG_fail;
33257 {
33258 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33259 if (SWIG_arg_fail(2)) SWIG_fail;
33260 }
33261 {
33262 PyThreadState* __tstate = wxPyBeginAllowThreads();
33263 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33264
33265 wxPyEndAllowThreads(__tstate);
33266 if (PyErr_Occurred()) SWIG_fail;
33267 }
33268 {
33269 resultobj = wxPyMake_wxObject(result, 0);
33270 }
33271 return resultobj;
33272 fail:
33273 return NULL;
33274 }
33275
33276
33277 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33278 PyObject *resultobj;
33279 wxMenu *arg1 = (wxMenu *) 0 ;
33280 int arg2 ;
33281 bool arg3 ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 PyObject * obj2 = 0 ;
33285 char *kwnames[] = {
33286 (char *) "self",(char *) "id",(char *) "enable", NULL
33287 };
33288
33289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33291 if (SWIG_arg_fail(1)) SWIG_fail;
33292 {
33293 arg2 = (int)(SWIG_As_int(obj1));
33294 if (SWIG_arg_fail(2)) SWIG_fail;
33295 }
33296 {
33297 arg3 = (bool)(SWIG_As_bool(obj2));
33298 if (SWIG_arg_fail(3)) SWIG_fail;
33299 }
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 (arg1)->Enable(arg2,arg3);
33303
33304 wxPyEndAllowThreads(__tstate);
33305 if (PyErr_Occurred()) SWIG_fail;
33306 }
33307 Py_INCREF(Py_None); resultobj = Py_None;
33308 return resultobj;
33309 fail:
33310 return NULL;
33311 }
33312
33313
33314 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33315 PyObject *resultobj;
33316 wxMenu *arg1 = (wxMenu *) 0 ;
33317 int arg2 ;
33318 bool result;
33319 PyObject * obj0 = 0 ;
33320 PyObject * obj1 = 0 ;
33321 char *kwnames[] = {
33322 (char *) "self",(char *) "id", NULL
33323 };
33324
33325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33327 if (SWIG_arg_fail(1)) SWIG_fail;
33328 {
33329 arg2 = (int)(SWIG_As_int(obj1));
33330 if (SWIG_arg_fail(2)) SWIG_fail;
33331 }
33332 {
33333 PyThreadState* __tstate = wxPyBeginAllowThreads();
33334 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33335
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 {
33340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33341 }
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33349 PyObject *resultobj;
33350 wxMenu *arg1 = (wxMenu *) 0 ;
33351 int arg2 ;
33352 bool arg3 ;
33353 PyObject * obj0 = 0 ;
33354 PyObject * obj1 = 0 ;
33355 PyObject * obj2 = 0 ;
33356 char *kwnames[] = {
33357 (char *) "self",(char *) "id",(char *) "check", NULL
33358 };
33359
33360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33362 if (SWIG_arg_fail(1)) SWIG_fail;
33363 {
33364 arg2 = (int)(SWIG_As_int(obj1));
33365 if (SWIG_arg_fail(2)) SWIG_fail;
33366 }
33367 {
33368 arg3 = (bool)(SWIG_As_bool(obj2));
33369 if (SWIG_arg_fail(3)) SWIG_fail;
33370 }
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 (arg1)->Check(arg2,arg3);
33374
33375 wxPyEndAllowThreads(__tstate);
33376 if (PyErr_Occurred()) SWIG_fail;
33377 }
33378 Py_INCREF(Py_None); resultobj = Py_None;
33379 return resultobj;
33380 fail:
33381 return NULL;
33382 }
33383
33384
33385 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33386 PyObject *resultobj;
33387 wxMenu *arg1 = (wxMenu *) 0 ;
33388 int arg2 ;
33389 bool result;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char *kwnames[] = {
33393 (char *) "self",(char *) "id", NULL
33394 };
33395
33396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33398 if (SWIG_arg_fail(1)) SWIG_fail;
33399 {
33400 arg2 = (int)(SWIG_As_int(obj1));
33401 if (SWIG_arg_fail(2)) SWIG_fail;
33402 }
33403 {
33404 PyThreadState* __tstate = wxPyBeginAllowThreads();
33405 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33406
33407 wxPyEndAllowThreads(__tstate);
33408 if (PyErr_Occurred()) SWIG_fail;
33409 }
33410 {
33411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33412 }
33413 return resultobj;
33414 fail:
33415 return NULL;
33416 }
33417
33418
33419 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33420 PyObject *resultobj;
33421 wxMenu *arg1 = (wxMenu *) 0 ;
33422 int arg2 ;
33423 wxString *arg3 = 0 ;
33424 bool temp3 = false ;
33425 PyObject * obj0 = 0 ;
33426 PyObject * obj1 = 0 ;
33427 PyObject * obj2 = 0 ;
33428 char *kwnames[] = {
33429 (char *) "self",(char *) "id",(char *) "label", NULL
33430 };
33431
33432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33434 if (SWIG_arg_fail(1)) SWIG_fail;
33435 {
33436 arg2 = (int)(SWIG_As_int(obj1));
33437 if (SWIG_arg_fail(2)) SWIG_fail;
33438 }
33439 {
33440 arg3 = wxString_in_helper(obj2);
33441 if (arg3 == NULL) SWIG_fail;
33442 temp3 = true;
33443 }
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33447
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 Py_INCREF(Py_None); resultobj = Py_None;
33452 {
33453 if (temp3)
33454 delete arg3;
33455 }
33456 return resultobj;
33457 fail:
33458 {
33459 if (temp3)
33460 delete arg3;
33461 }
33462 return NULL;
33463 }
33464
33465
33466 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33467 PyObject *resultobj;
33468 wxMenu *arg1 = (wxMenu *) 0 ;
33469 int arg2 ;
33470 wxString result;
33471 PyObject * obj0 = 0 ;
33472 PyObject * obj1 = 0 ;
33473 char *kwnames[] = {
33474 (char *) "self",(char *) "id", NULL
33475 };
33476
33477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33479 if (SWIG_arg_fail(1)) SWIG_fail;
33480 {
33481 arg2 = (int)(SWIG_As_int(obj1));
33482 if (SWIG_arg_fail(2)) SWIG_fail;
33483 }
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33487
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 {
33492 #if wxUSE_UNICODE
33493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33494 #else
33495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33496 #endif
33497 }
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33505 PyObject *resultobj;
33506 wxMenu *arg1 = (wxMenu *) 0 ;
33507 int arg2 ;
33508 wxString *arg3 = 0 ;
33509 bool temp3 = false ;
33510 PyObject * obj0 = 0 ;
33511 PyObject * obj1 = 0 ;
33512 PyObject * obj2 = 0 ;
33513 char *kwnames[] = {
33514 (char *) "self",(char *) "id",(char *) "helpString", NULL
33515 };
33516
33517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33519 if (SWIG_arg_fail(1)) SWIG_fail;
33520 {
33521 arg2 = (int)(SWIG_As_int(obj1));
33522 if (SWIG_arg_fail(2)) SWIG_fail;
33523 }
33524 {
33525 arg3 = wxString_in_helper(obj2);
33526 if (arg3 == NULL) SWIG_fail;
33527 temp3 = true;
33528 }
33529 {
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33532
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 Py_INCREF(Py_None); resultobj = Py_None;
33537 {
33538 if (temp3)
33539 delete arg3;
33540 }
33541 return resultobj;
33542 fail:
33543 {
33544 if (temp3)
33545 delete arg3;
33546 }
33547 return NULL;
33548 }
33549
33550
33551 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33552 PyObject *resultobj;
33553 wxMenu *arg1 = (wxMenu *) 0 ;
33554 int arg2 ;
33555 wxString result;
33556 PyObject * obj0 = 0 ;
33557 PyObject * obj1 = 0 ;
33558 char *kwnames[] = {
33559 (char *) "self",(char *) "id", NULL
33560 };
33561
33562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33564 if (SWIG_arg_fail(1)) SWIG_fail;
33565 {
33566 arg2 = (int)(SWIG_As_int(obj1));
33567 if (SWIG_arg_fail(2)) SWIG_fail;
33568 }
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33572
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 {
33577 #if wxUSE_UNICODE
33578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33579 #else
33580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33581 #endif
33582 }
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33590 PyObject *resultobj;
33591 wxMenu *arg1 = (wxMenu *) 0 ;
33592 wxString *arg2 = 0 ;
33593 bool temp2 = false ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 char *kwnames[] = {
33597 (char *) "self",(char *) "title", NULL
33598 };
33599
33600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33602 if (SWIG_arg_fail(1)) SWIG_fail;
33603 {
33604 arg2 = wxString_in_helper(obj1);
33605 if (arg2 == NULL) SWIG_fail;
33606 temp2 = true;
33607 }
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 (arg1)->SetTitle((wxString const &)*arg2);
33611
33612 wxPyEndAllowThreads(__tstate);
33613 if (PyErr_Occurred()) SWIG_fail;
33614 }
33615 Py_INCREF(Py_None); resultobj = Py_None;
33616 {
33617 if (temp2)
33618 delete arg2;
33619 }
33620 return resultobj;
33621 fail:
33622 {
33623 if (temp2)
33624 delete arg2;
33625 }
33626 return NULL;
33627 }
33628
33629
33630 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj;
33632 wxMenu *arg1 = (wxMenu *) 0 ;
33633 wxString result;
33634 PyObject * obj0 = 0 ;
33635 char *kwnames[] = {
33636 (char *) "self", NULL
33637 };
33638
33639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33641 if (SWIG_arg_fail(1)) SWIG_fail;
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = ((wxMenu const *)arg1)->GetTitle();
33645
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 #if wxUSE_UNICODE
33651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33652 #else
33653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33654 #endif
33655 }
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33663 PyObject *resultobj;
33664 wxMenu *arg1 = (wxMenu *) 0 ;
33665 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33666 PyObject * obj0 = 0 ;
33667 PyObject * obj1 = 0 ;
33668 char *kwnames[] = {
33669 (char *) "self",(char *) "handler", NULL
33670 };
33671
33672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33674 if (SWIG_arg_fail(1)) SWIG_fail;
33675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33676 if (SWIG_arg_fail(2)) SWIG_fail;
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 (arg1)->SetEventHandler(arg2);
33680
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 Py_INCREF(Py_None); resultobj = Py_None;
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj;
33693 wxMenu *arg1 = (wxMenu *) 0 ;
33694 wxEvtHandler *result;
33695 PyObject * obj0 = 0 ;
33696 char *kwnames[] = {
33697 (char *) "self", NULL
33698 };
33699
33700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33702 if (SWIG_arg_fail(1)) SWIG_fail;
33703 {
33704 PyThreadState* __tstate = wxPyBeginAllowThreads();
33705 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33706
33707 wxPyEndAllowThreads(__tstate);
33708 if (PyErr_Occurred()) SWIG_fail;
33709 }
33710 {
33711 resultobj = wxPyMake_wxObject(result, 0);
33712 }
33713 return resultobj;
33714 fail:
33715 return NULL;
33716 }
33717
33718
33719 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33720 PyObject *resultobj;
33721 wxMenu *arg1 = (wxMenu *) 0 ;
33722 wxWindow *arg2 = (wxWindow *) 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 char *kwnames[] = {
33726 (char *) "self",(char *) "win", NULL
33727 };
33728
33729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33731 if (SWIG_arg_fail(1)) SWIG_fail;
33732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33733 if (SWIG_arg_fail(2)) SWIG_fail;
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 (arg1)->SetInvokingWindow(arg2);
33737
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 Py_INCREF(Py_None); resultobj = Py_None;
33742 return resultobj;
33743 fail:
33744 return NULL;
33745 }
33746
33747
33748 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33749 PyObject *resultobj;
33750 wxMenu *arg1 = (wxMenu *) 0 ;
33751 wxWindow *result;
33752 PyObject * obj0 = 0 ;
33753 char *kwnames[] = {
33754 (char *) "self", NULL
33755 };
33756
33757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33759 if (SWIG_arg_fail(1)) SWIG_fail;
33760 {
33761 PyThreadState* __tstate = wxPyBeginAllowThreads();
33762 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33763
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 {
33768 resultobj = wxPyMake_wxObject(result, 0);
33769 }
33770 return resultobj;
33771 fail:
33772 return NULL;
33773 }
33774
33775
33776 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33777 PyObject *resultobj;
33778 wxMenu *arg1 = (wxMenu *) 0 ;
33779 long result;
33780 PyObject * obj0 = 0 ;
33781 char *kwnames[] = {
33782 (char *) "self", NULL
33783 };
33784
33785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33787 if (SWIG_arg_fail(1)) SWIG_fail;
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 result = (long)((wxMenu const *)arg1)->GetStyle();
33791
33792 wxPyEndAllowThreads(__tstate);
33793 if (PyErr_Occurred()) SWIG_fail;
33794 }
33795 {
33796 resultobj = SWIG_From_long((long)(result));
33797 }
33798 return resultobj;
33799 fail:
33800 return NULL;
33801 }
33802
33803
33804 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33805 PyObject *resultobj;
33806 wxMenu *arg1 = (wxMenu *) 0 ;
33807 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33808 PyObject * obj0 = 0 ;
33809 PyObject * obj1 = 0 ;
33810 char *kwnames[] = {
33811 (char *) "self",(char *) "source", NULL
33812 };
33813
33814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33816 if (SWIG_arg_fail(1)) SWIG_fail;
33817 if (obj1) {
33818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33819 if (SWIG_arg_fail(2)) SWIG_fail;
33820 }
33821 {
33822 PyThreadState* __tstate = wxPyBeginAllowThreads();
33823 (arg1)->UpdateUI(arg2);
33824
33825 wxPyEndAllowThreads(__tstate);
33826 if (PyErr_Occurred()) SWIG_fail;
33827 }
33828 Py_INCREF(Py_None); resultobj = Py_None;
33829 return resultobj;
33830 fail:
33831 return NULL;
33832 }
33833
33834
33835 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33836 PyObject *resultobj;
33837 wxMenu *arg1 = (wxMenu *) 0 ;
33838 wxMenuBar *result;
33839 PyObject * obj0 = 0 ;
33840 char *kwnames[] = {
33841 (char *) "self", NULL
33842 };
33843
33844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33846 if (SWIG_arg_fail(1)) SWIG_fail;
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33850
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 {
33855 resultobj = wxPyMake_wxObject(result, 0);
33856 }
33857 return resultobj;
33858 fail:
33859 return NULL;
33860 }
33861
33862
33863 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj;
33865 wxMenu *arg1 = (wxMenu *) 0 ;
33866 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33867 PyObject * obj0 = 0 ;
33868 PyObject * obj1 = 0 ;
33869 char *kwnames[] = {
33870 (char *) "self",(char *) "menubar", NULL
33871 };
33872
33873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33875 if (SWIG_arg_fail(1)) SWIG_fail;
33876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33877 if (SWIG_arg_fail(2)) SWIG_fail;
33878 {
33879 PyThreadState* __tstate = wxPyBeginAllowThreads();
33880 (arg1)->Attach(arg2);
33881
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 Py_INCREF(Py_None); resultobj = Py_None;
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33893 PyObject *resultobj;
33894 wxMenu *arg1 = (wxMenu *) 0 ;
33895 PyObject * obj0 = 0 ;
33896 char *kwnames[] = {
33897 (char *) "self", NULL
33898 };
33899
33900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33902 if (SWIG_arg_fail(1)) SWIG_fail;
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 (arg1)->Detach();
33906
33907 wxPyEndAllowThreads(__tstate);
33908 if (PyErr_Occurred()) SWIG_fail;
33909 }
33910 Py_INCREF(Py_None); resultobj = Py_None;
33911 return resultobj;
33912 fail:
33913 return NULL;
33914 }
33915
33916
33917 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33918 PyObject *resultobj;
33919 wxMenu *arg1 = (wxMenu *) 0 ;
33920 bool result;
33921 PyObject * obj0 = 0 ;
33922 char *kwnames[] = {
33923 (char *) "self", NULL
33924 };
33925
33926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33928 if (SWIG_arg_fail(1)) SWIG_fail;
33929 {
33930 PyThreadState* __tstate = wxPyBeginAllowThreads();
33931 result = (bool)((wxMenu const *)arg1)->IsAttached();
33932
33933 wxPyEndAllowThreads(__tstate);
33934 if (PyErr_Occurred()) SWIG_fail;
33935 }
33936 {
33937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33938 }
33939 return resultobj;
33940 fail:
33941 return NULL;
33942 }
33943
33944
33945 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33946 PyObject *resultobj;
33947 wxMenu *arg1 = (wxMenu *) 0 ;
33948 wxMenu *arg2 = (wxMenu *) 0 ;
33949 PyObject * obj0 = 0 ;
33950 PyObject * obj1 = 0 ;
33951 char *kwnames[] = {
33952 (char *) "self",(char *) "parent", NULL
33953 };
33954
33955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
33956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33957 if (SWIG_arg_fail(1)) SWIG_fail;
33958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33959 if (SWIG_arg_fail(2)) SWIG_fail;
33960 {
33961 PyThreadState* __tstate = wxPyBeginAllowThreads();
33962 (arg1)->SetParent(arg2);
33963
33964 wxPyEndAllowThreads(__tstate);
33965 if (PyErr_Occurred()) SWIG_fail;
33966 }
33967 Py_INCREF(Py_None); resultobj = Py_None;
33968 return resultobj;
33969 fail:
33970 return NULL;
33971 }
33972
33973
33974 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33975 PyObject *resultobj;
33976 wxMenu *arg1 = (wxMenu *) 0 ;
33977 wxMenu *result;
33978 PyObject * obj0 = 0 ;
33979 char *kwnames[] = {
33980 (char *) "self", NULL
33981 };
33982
33983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
33984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33985 if (SWIG_arg_fail(1)) SWIG_fail;
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
33989
33990 wxPyEndAllowThreads(__tstate);
33991 if (PyErr_Occurred()) SWIG_fail;
33992 }
33993 {
33994 resultobj = wxPyMake_wxObject(result, 0);
33995 }
33996 return resultobj;
33997 fail:
33998 return NULL;
33999 }
34000
34001
34002 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34003 PyObject *obj;
34004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34005 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34006 Py_INCREF(obj);
34007 return Py_BuildValue((char *)"");
34008 }
34009 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj;
34011 long arg1 = (long) 0 ;
34012 wxMenuBar *result;
34013 PyObject * obj0 = 0 ;
34014 char *kwnames[] = {
34015 (char *) "style", NULL
34016 };
34017
34018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34019 if (obj0) {
34020 {
34021 arg1 = (long)(SWIG_As_long(obj0));
34022 if (SWIG_arg_fail(1)) SWIG_fail;
34023 }
34024 }
34025 {
34026 if (!wxPyCheckForApp()) SWIG_fail;
34027 PyThreadState* __tstate = wxPyBeginAllowThreads();
34028 result = (wxMenuBar *)new wxMenuBar(arg1);
34029
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj;
34042 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34043 wxMenu *arg2 = (wxMenu *) 0 ;
34044 wxString *arg3 = 0 ;
34045 bool result;
34046 bool temp3 = false ;
34047 PyObject * obj0 = 0 ;
34048 PyObject * obj1 = 0 ;
34049 PyObject * obj2 = 0 ;
34050 char *kwnames[] = {
34051 (char *) "self",(char *) "menu",(char *) "title", NULL
34052 };
34053
34054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34056 if (SWIG_arg_fail(1)) SWIG_fail;
34057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34058 if (SWIG_arg_fail(2)) SWIG_fail;
34059 {
34060 arg3 = wxString_in_helper(obj2);
34061 if (arg3 == NULL) SWIG_fail;
34062 temp3 = true;
34063 }
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34067
34068 wxPyEndAllowThreads(__tstate);
34069 if (PyErr_Occurred()) SWIG_fail;
34070 }
34071 {
34072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34073 }
34074 {
34075 if (temp3)
34076 delete arg3;
34077 }
34078 return resultobj;
34079 fail:
34080 {
34081 if (temp3)
34082 delete arg3;
34083 }
34084 return NULL;
34085 }
34086
34087
34088 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34089 PyObject *resultobj;
34090 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34091 size_t arg2 ;
34092 wxMenu *arg3 = (wxMenu *) 0 ;
34093 wxString *arg4 = 0 ;
34094 bool result;
34095 bool temp4 = false ;
34096 PyObject * obj0 = 0 ;
34097 PyObject * obj1 = 0 ;
34098 PyObject * obj2 = 0 ;
34099 PyObject * obj3 = 0 ;
34100 char *kwnames[] = {
34101 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34102 };
34103
34104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34106 if (SWIG_arg_fail(1)) SWIG_fail;
34107 {
34108 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34109 if (SWIG_arg_fail(2)) SWIG_fail;
34110 }
34111 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34112 if (SWIG_arg_fail(3)) SWIG_fail;
34113 {
34114 arg4 = wxString_in_helper(obj3);
34115 if (arg4 == NULL) SWIG_fail;
34116 temp4 = true;
34117 }
34118 {
34119 PyThreadState* __tstate = wxPyBeginAllowThreads();
34120 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34121
34122 wxPyEndAllowThreads(__tstate);
34123 if (PyErr_Occurred()) SWIG_fail;
34124 }
34125 {
34126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34127 }
34128 {
34129 if (temp4)
34130 delete arg4;
34131 }
34132 return resultobj;
34133 fail:
34134 {
34135 if (temp4)
34136 delete arg4;
34137 }
34138 return NULL;
34139 }
34140
34141
34142 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj;
34144 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34145 size_t result;
34146 PyObject * obj0 = 0 ;
34147 char *kwnames[] = {
34148 (char *) "self", NULL
34149 };
34150
34151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34153 if (SWIG_arg_fail(1)) SWIG_fail;
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34157
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 {
34162 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34163 }
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj;
34172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34173 size_t arg2 ;
34174 wxMenu *result;
34175 PyObject * obj0 = 0 ;
34176 PyObject * obj1 = 0 ;
34177 char *kwnames[] = {
34178 (char *) "self",(char *) "pos", NULL
34179 };
34180
34181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34183 if (SWIG_arg_fail(1)) SWIG_fail;
34184 {
34185 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34186 if (SWIG_arg_fail(2)) SWIG_fail;
34187 }
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34191
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 {
34196 resultobj = wxPyMake_wxObject(result, 0);
34197 }
34198 return resultobj;
34199 fail:
34200 return NULL;
34201 }
34202
34203
34204 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34205 PyObject *resultobj;
34206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34207 size_t arg2 ;
34208 wxMenu *arg3 = (wxMenu *) 0 ;
34209 wxString *arg4 = 0 ;
34210 wxMenu *result;
34211 bool temp4 = false ;
34212 PyObject * obj0 = 0 ;
34213 PyObject * obj1 = 0 ;
34214 PyObject * obj2 = 0 ;
34215 PyObject * obj3 = 0 ;
34216 char *kwnames[] = {
34217 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34218 };
34219
34220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34222 if (SWIG_arg_fail(1)) SWIG_fail;
34223 {
34224 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34225 if (SWIG_arg_fail(2)) SWIG_fail;
34226 }
34227 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34228 if (SWIG_arg_fail(3)) SWIG_fail;
34229 {
34230 arg4 = wxString_in_helper(obj3);
34231 if (arg4 == NULL) SWIG_fail;
34232 temp4 = true;
34233 }
34234 {
34235 PyThreadState* __tstate = wxPyBeginAllowThreads();
34236 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34237
34238 wxPyEndAllowThreads(__tstate);
34239 if (PyErr_Occurred()) SWIG_fail;
34240 }
34241 {
34242 resultobj = wxPyMake_wxObject(result, 0);
34243 }
34244 {
34245 if (temp4)
34246 delete arg4;
34247 }
34248 return resultobj;
34249 fail:
34250 {
34251 if (temp4)
34252 delete arg4;
34253 }
34254 return NULL;
34255 }
34256
34257
34258 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34259 PyObject *resultobj;
34260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34261 size_t arg2 ;
34262 wxMenu *result;
34263 PyObject * obj0 = 0 ;
34264 PyObject * obj1 = 0 ;
34265 char *kwnames[] = {
34266 (char *) "self",(char *) "pos", NULL
34267 };
34268
34269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34271 if (SWIG_arg_fail(1)) SWIG_fail;
34272 {
34273 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34274 if (SWIG_arg_fail(2)) SWIG_fail;
34275 }
34276 {
34277 PyThreadState* __tstate = wxPyBeginAllowThreads();
34278 result = (wxMenu *)(arg1)->Remove(arg2);
34279
34280 wxPyEndAllowThreads(__tstate);
34281 if (PyErr_Occurred()) SWIG_fail;
34282 }
34283 {
34284 resultobj = wxPyMake_wxObject(result, 0);
34285 }
34286 return resultobj;
34287 fail:
34288 return NULL;
34289 }
34290
34291
34292 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34293 PyObject *resultobj;
34294 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34295 size_t arg2 ;
34296 bool arg3 ;
34297 PyObject * obj0 = 0 ;
34298 PyObject * obj1 = 0 ;
34299 PyObject * obj2 = 0 ;
34300 char *kwnames[] = {
34301 (char *) "self",(char *) "pos",(char *) "enable", NULL
34302 };
34303
34304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34306 if (SWIG_arg_fail(1)) SWIG_fail;
34307 {
34308 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34309 if (SWIG_arg_fail(2)) SWIG_fail;
34310 }
34311 {
34312 arg3 = (bool)(SWIG_As_bool(obj2));
34313 if (SWIG_arg_fail(3)) SWIG_fail;
34314 }
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 (arg1)->EnableTop(arg2,arg3);
34318
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 Py_INCREF(Py_None); resultobj = Py_None;
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34330 PyObject *resultobj;
34331 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34332 size_t arg2 ;
34333 bool result;
34334 PyObject * obj0 = 0 ;
34335 PyObject * obj1 = 0 ;
34336 char *kwnames[] = {
34337 (char *) "self",(char *) "pos", NULL
34338 };
34339
34340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34342 if (SWIG_arg_fail(1)) SWIG_fail;
34343 {
34344 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34345 if (SWIG_arg_fail(2)) SWIG_fail;
34346 }
34347 {
34348 PyThreadState* __tstate = wxPyBeginAllowThreads();
34349 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34350
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 {
34355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34356 }
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34364 PyObject *resultobj;
34365 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34366 size_t arg2 ;
34367 wxString *arg3 = 0 ;
34368 bool temp3 = false ;
34369 PyObject * obj0 = 0 ;
34370 PyObject * obj1 = 0 ;
34371 PyObject * obj2 = 0 ;
34372 char *kwnames[] = {
34373 (char *) "self",(char *) "pos",(char *) "label", NULL
34374 };
34375
34376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34378 if (SWIG_arg_fail(1)) SWIG_fail;
34379 {
34380 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34381 if (SWIG_arg_fail(2)) SWIG_fail;
34382 }
34383 {
34384 arg3 = wxString_in_helper(obj2);
34385 if (arg3 == NULL) SWIG_fail;
34386 temp3 = true;
34387 }
34388 {
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34391
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 Py_INCREF(Py_None); resultobj = Py_None;
34396 {
34397 if (temp3)
34398 delete arg3;
34399 }
34400 return resultobj;
34401 fail:
34402 {
34403 if (temp3)
34404 delete arg3;
34405 }
34406 return NULL;
34407 }
34408
34409
34410 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34411 PyObject *resultobj;
34412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34413 size_t arg2 ;
34414 wxString result;
34415 PyObject * obj0 = 0 ;
34416 PyObject * obj1 = 0 ;
34417 char *kwnames[] = {
34418 (char *) "self",(char *) "pos", NULL
34419 };
34420
34421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34423 if (SWIG_arg_fail(1)) SWIG_fail;
34424 {
34425 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34426 if (SWIG_arg_fail(2)) SWIG_fail;
34427 }
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34431
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 {
34436 #if wxUSE_UNICODE
34437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34438 #else
34439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34440 #endif
34441 }
34442 return resultobj;
34443 fail:
34444 return NULL;
34445 }
34446
34447
34448 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34449 PyObject *resultobj;
34450 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34451 wxString *arg2 = 0 ;
34452 wxString *arg3 = 0 ;
34453 int result;
34454 bool temp2 = false ;
34455 bool temp3 = false ;
34456 PyObject * obj0 = 0 ;
34457 PyObject * obj1 = 0 ;
34458 PyObject * obj2 = 0 ;
34459 char *kwnames[] = {
34460 (char *) "self",(char *) "menu",(char *) "item", NULL
34461 };
34462
34463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34465 if (SWIG_arg_fail(1)) SWIG_fail;
34466 {
34467 arg2 = wxString_in_helper(obj1);
34468 if (arg2 == NULL) SWIG_fail;
34469 temp2 = true;
34470 }
34471 {
34472 arg3 = wxString_in_helper(obj2);
34473 if (arg3 == NULL) SWIG_fail;
34474 temp3 = true;
34475 }
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34479
34480 wxPyEndAllowThreads(__tstate);
34481 if (PyErr_Occurred()) SWIG_fail;
34482 }
34483 {
34484 resultobj = SWIG_From_int((int)(result));
34485 }
34486 {
34487 if (temp2)
34488 delete arg2;
34489 }
34490 {
34491 if (temp3)
34492 delete arg3;
34493 }
34494 return resultobj;
34495 fail:
34496 {
34497 if (temp2)
34498 delete arg2;
34499 }
34500 {
34501 if (temp3)
34502 delete arg3;
34503 }
34504 return NULL;
34505 }
34506
34507
34508 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34509 PyObject *resultobj;
34510 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34511 int arg2 ;
34512 wxMenuItem *result;
34513 PyObject * obj0 = 0 ;
34514 PyObject * obj1 = 0 ;
34515 char *kwnames[] = {
34516 (char *) "self",(char *) "id", NULL
34517 };
34518
34519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34521 if (SWIG_arg_fail(1)) SWIG_fail;
34522 {
34523 arg2 = (int)(SWIG_As_int(obj1));
34524 if (SWIG_arg_fail(2)) SWIG_fail;
34525 }
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34529
34530 wxPyEndAllowThreads(__tstate);
34531 if (PyErr_Occurred()) SWIG_fail;
34532 }
34533 {
34534 resultobj = wxPyMake_wxObject(result, 0);
34535 }
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj;
34544 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34545 wxString *arg2 = 0 ;
34546 int result;
34547 bool temp2 = false ;
34548 PyObject * obj0 = 0 ;
34549 PyObject * obj1 = 0 ;
34550 char *kwnames[] = {
34551 (char *) "self",(char *) "title", NULL
34552 };
34553
34554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34556 if (SWIG_arg_fail(1)) SWIG_fail;
34557 {
34558 arg2 = wxString_in_helper(obj1);
34559 if (arg2 == NULL) SWIG_fail;
34560 temp2 = true;
34561 }
34562 {
34563 PyThreadState* __tstate = wxPyBeginAllowThreads();
34564 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34565
34566 wxPyEndAllowThreads(__tstate);
34567 if (PyErr_Occurred()) SWIG_fail;
34568 }
34569 {
34570 resultobj = SWIG_From_int((int)(result));
34571 }
34572 {
34573 if (temp2)
34574 delete arg2;
34575 }
34576 return resultobj;
34577 fail:
34578 {
34579 if (temp2)
34580 delete arg2;
34581 }
34582 return NULL;
34583 }
34584
34585
34586 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34587 PyObject *resultobj;
34588 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34589 int arg2 ;
34590 bool arg3 ;
34591 PyObject * obj0 = 0 ;
34592 PyObject * obj1 = 0 ;
34593 PyObject * obj2 = 0 ;
34594 char *kwnames[] = {
34595 (char *) "self",(char *) "id",(char *) "enable", NULL
34596 };
34597
34598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34600 if (SWIG_arg_fail(1)) SWIG_fail;
34601 {
34602 arg2 = (int)(SWIG_As_int(obj1));
34603 if (SWIG_arg_fail(2)) SWIG_fail;
34604 }
34605 {
34606 arg3 = (bool)(SWIG_As_bool(obj2));
34607 if (SWIG_arg_fail(3)) SWIG_fail;
34608 }
34609 {
34610 PyThreadState* __tstate = wxPyBeginAllowThreads();
34611 (arg1)->Enable(arg2,arg3);
34612
34613 wxPyEndAllowThreads(__tstate);
34614 if (PyErr_Occurred()) SWIG_fail;
34615 }
34616 Py_INCREF(Py_None); resultobj = Py_None;
34617 return resultobj;
34618 fail:
34619 return NULL;
34620 }
34621
34622
34623 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj;
34625 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34626 int arg2 ;
34627 bool arg3 ;
34628 PyObject * obj0 = 0 ;
34629 PyObject * obj1 = 0 ;
34630 PyObject * obj2 = 0 ;
34631 char *kwnames[] = {
34632 (char *) "self",(char *) "id",(char *) "check", NULL
34633 };
34634
34635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34637 if (SWIG_arg_fail(1)) SWIG_fail;
34638 {
34639 arg2 = (int)(SWIG_As_int(obj1));
34640 if (SWIG_arg_fail(2)) SWIG_fail;
34641 }
34642 {
34643 arg3 = (bool)(SWIG_As_bool(obj2));
34644 if (SWIG_arg_fail(3)) SWIG_fail;
34645 }
34646 {
34647 PyThreadState* __tstate = wxPyBeginAllowThreads();
34648 (arg1)->Check(arg2,arg3);
34649
34650 wxPyEndAllowThreads(__tstate);
34651 if (PyErr_Occurred()) SWIG_fail;
34652 }
34653 Py_INCREF(Py_None); resultobj = Py_None;
34654 return resultobj;
34655 fail:
34656 return NULL;
34657 }
34658
34659
34660 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34661 PyObject *resultobj;
34662 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34663 int arg2 ;
34664 bool result;
34665 PyObject * obj0 = 0 ;
34666 PyObject * obj1 = 0 ;
34667 char *kwnames[] = {
34668 (char *) "self",(char *) "id", NULL
34669 };
34670
34671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34673 if (SWIG_arg_fail(1)) SWIG_fail;
34674 {
34675 arg2 = (int)(SWIG_As_int(obj1));
34676 if (SWIG_arg_fail(2)) SWIG_fail;
34677 }
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34681
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj;
34696 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34697 int arg2 ;
34698 bool result;
34699 PyObject * obj0 = 0 ;
34700 PyObject * obj1 = 0 ;
34701 char *kwnames[] = {
34702 (char *) "self",(char *) "id", NULL
34703 };
34704
34705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34707 if (SWIG_arg_fail(1)) SWIG_fail;
34708 {
34709 arg2 = (int)(SWIG_As_int(obj1));
34710 if (SWIG_arg_fail(2)) SWIG_fail;
34711 }
34712 {
34713 PyThreadState* __tstate = wxPyBeginAllowThreads();
34714 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34715
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 {
34720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34721 }
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34729 PyObject *resultobj;
34730 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34731 int arg2 ;
34732 wxString *arg3 = 0 ;
34733 bool temp3 = false ;
34734 PyObject * obj0 = 0 ;
34735 PyObject * obj1 = 0 ;
34736 PyObject * obj2 = 0 ;
34737 char *kwnames[] = {
34738 (char *) "self",(char *) "id",(char *) "label", NULL
34739 };
34740
34741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
34746 if (SWIG_arg_fail(2)) SWIG_fail;
34747 }
34748 {
34749 arg3 = wxString_in_helper(obj2);
34750 if (arg3 == NULL) SWIG_fail;
34751 temp3 = true;
34752 }
34753 {
34754 PyThreadState* __tstate = wxPyBeginAllowThreads();
34755 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34756
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 Py_INCREF(Py_None); resultobj = Py_None;
34761 {
34762 if (temp3)
34763 delete arg3;
34764 }
34765 return resultobj;
34766 fail:
34767 {
34768 if (temp3)
34769 delete arg3;
34770 }
34771 return NULL;
34772 }
34773
34774
34775 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34776 PyObject *resultobj;
34777 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34778 int arg2 ;
34779 wxString result;
34780 PyObject * obj0 = 0 ;
34781 PyObject * obj1 = 0 ;
34782 char *kwnames[] = {
34783 (char *) "self",(char *) "id", NULL
34784 };
34785
34786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34788 if (SWIG_arg_fail(1)) SWIG_fail;
34789 {
34790 arg2 = (int)(SWIG_As_int(obj1));
34791 if (SWIG_arg_fail(2)) SWIG_fail;
34792 }
34793 {
34794 PyThreadState* __tstate = wxPyBeginAllowThreads();
34795 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34796
34797 wxPyEndAllowThreads(__tstate);
34798 if (PyErr_Occurred()) SWIG_fail;
34799 }
34800 {
34801 #if wxUSE_UNICODE
34802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34803 #else
34804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34805 #endif
34806 }
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34814 PyObject *resultobj;
34815 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34816 int arg2 ;
34817 wxString *arg3 = 0 ;
34818 bool temp3 = false ;
34819 PyObject * obj0 = 0 ;
34820 PyObject * obj1 = 0 ;
34821 PyObject * obj2 = 0 ;
34822 char *kwnames[] = {
34823 (char *) "self",(char *) "id",(char *) "helpString", NULL
34824 };
34825
34826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34828 if (SWIG_arg_fail(1)) SWIG_fail;
34829 {
34830 arg2 = (int)(SWIG_As_int(obj1));
34831 if (SWIG_arg_fail(2)) SWIG_fail;
34832 }
34833 {
34834 arg3 = wxString_in_helper(obj2);
34835 if (arg3 == NULL) SWIG_fail;
34836 temp3 = true;
34837 }
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34841
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 Py_INCREF(Py_None); resultobj = Py_None;
34846 {
34847 if (temp3)
34848 delete arg3;
34849 }
34850 return resultobj;
34851 fail:
34852 {
34853 if (temp3)
34854 delete arg3;
34855 }
34856 return NULL;
34857 }
34858
34859
34860 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34861 PyObject *resultobj;
34862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34863 int arg2 ;
34864 wxString result;
34865 PyObject * obj0 = 0 ;
34866 PyObject * obj1 = 0 ;
34867 char *kwnames[] = {
34868 (char *) "self",(char *) "id", NULL
34869 };
34870
34871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34873 if (SWIG_arg_fail(1)) SWIG_fail;
34874 {
34875 arg2 = (int)(SWIG_As_int(obj1));
34876 if (SWIG_arg_fail(2)) SWIG_fail;
34877 }
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34881
34882 wxPyEndAllowThreads(__tstate);
34883 if (PyErr_Occurred()) SWIG_fail;
34884 }
34885 {
34886 #if wxUSE_UNICODE
34887 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34888 #else
34889 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34890 #endif
34891 }
34892 return resultobj;
34893 fail:
34894 return NULL;
34895 }
34896
34897
34898 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34899 PyObject *resultobj;
34900 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34901 wxFrame *result;
34902 PyObject * obj0 = 0 ;
34903 char *kwnames[] = {
34904 (char *) "self", NULL
34905 };
34906
34907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34909 if (SWIG_arg_fail(1)) SWIG_fail;
34910 {
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34913
34914 wxPyEndAllowThreads(__tstate);
34915 if (PyErr_Occurred()) SWIG_fail;
34916 }
34917 {
34918 resultobj = wxPyMake_wxObject(result, 0);
34919 }
34920 return resultobj;
34921 fail:
34922 return NULL;
34923 }
34924
34925
34926 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34927 PyObject *resultobj;
34928 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34929 bool result;
34930 PyObject * obj0 = 0 ;
34931 char *kwnames[] = {
34932 (char *) "self", NULL
34933 };
34934
34935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
34936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34937 if (SWIG_arg_fail(1)) SWIG_fail;
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
34941
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 {
34946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34947 }
34948 return resultobj;
34949 fail:
34950 return NULL;
34951 }
34952
34953
34954 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34955 PyObject *resultobj;
34956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34957 wxFrame *arg2 = (wxFrame *) 0 ;
34958 PyObject * obj0 = 0 ;
34959 PyObject * obj1 = 0 ;
34960 char *kwnames[] = {
34961 (char *) "self",(char *) "frame", NULL
34962 };
34963
34964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
34965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34966 if (SWIG_arg_fail(1)) SWIG_fail;
34967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
34968 if (SWIG_arg_fail(2)) SWIG_fail;
34969 {
34970 PyThreadState* __tstate = wxPyBeginAllowThreads();
34971 (arg1)->Attach(arg2);
34972
34973 wxPyEndAllowThreads(__tstate);
34974 if (PyErr_Occurred()) SWIG_fail;
34975 }
34976 Py_INCREF(Py_None); resultobj = Py_None;
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34984 PyObject *resultobj;
34985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34986 PyObject * obj0 = 0 ;
34987 char *kwnames[] = {
34988 (char *) "self", NULL
34989 };
34990
34991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
34996 (arg1)->Detach();
34997
34998 wxPyEndAllowThreads(__tstate);
34999 if (PyErr_Occurred()) SWIG_fail;
35000 }
35001 Py_INCREF(Py_None); resultobj = Py_None;
35002 return resultobj;
35003 fail:
35004 return NULL;
35005 }
35006
35007
35008 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35009 PyObject *obj;
35010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35011 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35012 Py_INCREF(obj);
35013 return Py_BuildValue((char *)"");
35014 }
35015 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35016 PyObject *resultobj;
35017 wxMenu *arg1 = (wxMenu *) NULL ;
35018 int arg2 = (int) wxID_ANY ;
35019 wxString const &arg3_defvalue = wxPyEmptyString ;
35020 wxString *arg3 = (wxString *) &arg3_defvalue ;
35021 wxString const &arg4_defvalue = wxPyEmptyString ;
35022 wxString *arg4 = (wxString *) &arg4_defvalue ;
35023 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35024 wxMenu *arg6 = (wxMenu *) NULL ;
35025 wxMenuItem *result;
35026 bool temp3 = false ;
35027 bool temp4 = false ;
35028 PyObject * obj0 = 0 ;
35029 PyObject * obj1 = 0 ;
35030 PyObject * obj2 = 0 ;
35031 PyObject * obj3 = 0 ;
35032 PyObject * obj4 = 0 ;
35033 PyObject * obj5 = 0 ;
35034 char *kwnames[] = {
35035 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35036 };
35037
35038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35039 if (obj0) {
35040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35041 if (SWIG_arg_fail(1)) SWIG_fail;
35042 }
35043 if (obj1) {
35044 {
35045 arg2 = (int)(SWIG_As_int(obj1));
35046 if (SWIG_arg_fail(2)) SWIG_fail;
35047 }
35048 }
35049 if (obj2) {
35050 {
35051 arg3 = wxString_in_helper(obj2);
35052 if (arg3 == NULL) SWIG_fail;
35053 temp3 = true;
35054 }
35055 }
35056 if (obj3) {
35057 {
35058 arg4 = wxString_in_helper(obj3);
35059 if (arg4 == NULL) SWIG_fail;
35060 temp4 = true;
35061 }
35062 }
35063 if (obj4) {
35064 {
35065 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35066 if (SWIG_arg_fail(5)) SWIG_fail;
35067 }
35068 }
35069 if (obj5) {
35070 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35071 if (SWIG_arg_fail(6)) SWIG_fail;
35072 }
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35076
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 {
35081 resultobj = wxPyMake_wxObject(result, 1);
35082 }
35083 {
35084 if (temp3)
35085 delete arg3;
35086 }
35087 {
35088 if (temp4)
35089 delete arg4;
35090 }
35091 return resultobj;
35092 fail:
35093 {
35094 if (temp3)
35095 delete arg3;
35096 }
35097 {
35098 if (temp4)
35099 delete arg4;
35100 }
35101 return NULL;
35102 }
35103
35104
35105 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35106 PyObject *resultobj;
35107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35108 wxMenu *result;
35109 PyObject * obj0 = 0 ;
35110 char *kwnames[] = {
35111 (char *) "self", NULL
35112 };
35113
35114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35116 if (SWIG_arg_fail(1)) SWIG_fail;
35117 {
35118 PyThreadState* __tstate = wxPyBeginAllowThreads();
35119 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35120
35121 wxPyEndAllowThreads(__tstate);
35122 if (PyErr_Occurred()) SWIG_fail;
35123 }
35124 {
35125 resultobj = wxPyMake_wxObject(result, 0);
35126 }
35127 return resultobj;
35128 fail:
35129 return NULL;
35130 }
35131
35132
35133 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35134 PyObject *resultobj;
35135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35136 wxMenu *arg2 = (wxMenu *) 0 ;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char *kwnames[] = {
35140 (char *) "self",(char *) "menu", NULL
35141 };
35142
35143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35145 if (SWIG_arg_fail(1)) SWIG_fail;
35146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35147 if (SWIG_arg_fail(2)) SWIG_fail;
35148 {
35149 PyThreadState* __tstate = wxPyBeginAllowThreads();
35150 (arg1)->SetMenu(arg2);
35151
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 Py_INCREF(Py_None); resultobj = Py_None;
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj;
35164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35165 int arg2 ;
35166 PyObject * obj0 = 0 ;
35167 PyObject * obj1 = 0 ;
35168 char *kwnames[] = {
35169 (char *) "self",(char *) "id", NULL
35170 };
35171
35172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35174 if (SWIG_arg_fail(1)) SWIG_fail;
35175 {
35176 arg2 = (int)(SWIG_As_int(obj1));
35177 if (SWIG_arg_fail(2)) SWIG_fail;
35178 }
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 (arg1)->SetId(arg2);
35182
35183 wxPyEndAllowThreads(__tstate);
35184 if (PyErr_Occurred()) SWIG_fail;
35185 }
35186 Py_INCREF(Py_None); resultobj = Py_None;
35187 return resultobj;
35188 fail:
35189 return NULL;
35190 }
35191
35192
35193 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj;
35195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35196 int result;
35197 PyObject * obj0 = 0 ;
35198 char *kwnames[] = {
35199 (char *) "self", NULL
35200 };
35201
35202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35204 if (SWIG_arg_fail(1)) SWIG_fail;
35205 {
35206 PyThreadState* __tstate = wxPyBeginAllowThreads();
35207 result = (int)((wxMenuItem const *)arg1)->GetId();
35208
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 {
35213 resultobj = SWIG_From_int((int)(result));
35214 }
35215 return resultobj;
35216 fail:
35217 return NULL;
35218 }
35219
35220
35221 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35222 PyObject *resultobj;
35223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35224 bool result;
35225 PyObject * obj0 = 0 ;
35226 char *kwnames[] = {
35227 (char *) "self", NULL
35228 };
35229
35230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35232 if (SWIG_arg_fail(1)) SWIG_fail;
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35236
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 {
35241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35242 }
35243 return resultobj;
35244 fail:
35245 return NULL;
35246 }
35247
35248
35249 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35250 PyObject *resultobj;
35251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35252 wxString *arg2 = 0 ;
35253 bool temp2 = false ;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 char *kwnames[] = {
35257 (char *) "self",(char *) "str", NULL
35258 };
35259
35260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35262 if (SWIG_arg_fail(1)) SWIG_fail;
35263 {
35264 arg2 = wxString_in_helper(obj1);
35265 if (arg2 == NULL) SWIG_fail;
35266 temp2 = true;
35267 }
35268 {
35269 PyThreadState* __tstate = wxPyBeginAllowThreads();
35270 (arg1)->SetText((wxString const &)*arg2);
35271
35272 wxPyEndAllowThreads(__tstate);
35273 if (PyErr_Occurred()) SWIG_fail;
35274 }
35275 Py_INCREF(Py_None); resultobj = Py_None;
35276 {
35277 if (temp2)
35278 delete arg2;
35279 }
35280 return resultobj;
35281 fail:
35282 {
35283 if (temp2)
35284 delete arg2;
35285 }
35286 return NULL;
35287 }
35288
35289
35290 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35291 PyObject *resultobj;
35292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35293 wxString result;
35294 PyObject * obj0 = 0 ;
35295 char *kwnames[] = {
35296 (char *) "self", NULL
35297 };
35298
35299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35301 if (SWIG_arg_fail(1)) SWIG_fail;
35302 {
35303 PyThreadState* __tstate = wxPyBeginAllowThreads();
35304 result = ((wxMenuItem const *)arg1)->GetLabel();
35305
35306 wxPyEndAllowThreads(__tstate);
35307 if (PyErr_Occurred()) SWIG_fail;
35308 }
35309 {
35310 #if wxUSE_UNICODE
35311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35312 #else
35313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35314 #endif
35315 }
35316 return resultobj;
35317 fail:
35318 return NULL;
35319 }
35320
35321
35322 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35323 PyObject *resultobj;
35324 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35325 wxString *result;
35326 PyObject * obj0 = 0 ;
35327 char *kwnames[] = {
35328 (char *) "self", NULL
35329 };
35330
35331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35333 if (SWIG_arg_fail(1)) SWIG_fail;
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 {
35337 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35338 result = (wxString *) &_result_ref;
35339 }
35340
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 {
35345 #if wxUSE_UNICODE
35346 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35347 #else
35348 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35349 #endif
35350 }
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35358 PyObject *resultobj;
35359 wxString *arg1 = 0 ;
35360 wxString result;
35361 bool temp1 = false ;
35362 PyObject * obj0 = 0 ;
35363 char *kwnames[] = {
35364 (char *) "text", NULL
35365 };
35366
35367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35368 {
35369 arg1 = wxString_in_helper(obj0);
35370 if (arg1 == NULL) SWIG_fail;
35371 temp1 = true;
35372 }
35373 {
35374 PyThreadState* __tstate = wxPyBeginAllowThreads();
35375 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35376
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 {
35381 #if wxUSE_UNICODE
35382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35383 #else
35384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35385 #endif
35386 }
35387 {
35388 if (temp1)
35389 delete arg1;
35390 }
35391 return resultobj;
35392 fail:
35393 {
35394 if (temp1)
35395 delete arg1;
35396 }
35397 return NULL;
35398 }
35399
35400
35401 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35402 PyObject *resultobj;
35403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35404 wxItemKind result;
35405 PyObject * obj0 = 0 ;
35406 char *kwnames[] = {
35407 (char *) "self", NULL
35408 };
35409
35410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35412 if (SWIG_arg_fail(1)) SWIG_fail;
35413 {
35414 PyThreadState* __tstate = wxPyBeginAllowThreads();
35415 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35416
35417 wxPyEndAllowThreads(__tstate);
35418 if (PyErr_Occurred()) SWIG_fail;
35419 }
35420 resultobj = SWIG_From_int((result));
35421 return resultobj;
35422 fail:
35423 return NULL;
35424 }
35425
35426
35427 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35428 PyObject *resultobj;
35429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35430 wxItemKind arg2 ;
35431 PyObject * obj0 = 0 ;
35432 PyObject * obj1 = 0 ;
35433 char *kwnames[] = {
35434 (char *) "self",(char *) "kind", NULL
35435 };
35436
35437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35439 if (SWIG_arg_fail(1)) SWIG_fail;
35440 {
35441 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35442 if (SWIG_arg_fail(2)) SWIG_fail;
35443 }
35444 {
35445 PyThreadState* __tstate = wxPyBeginAllowThreads();
35446 (arg1)->SetKind((wxItemKind )arg2);
35447
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 Py_INCREF(Py_None); resultobj = Py_None;
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj;
35460 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35461 bool arg2 ;
35462 PyObject * obj0 = 0 ;
35463 PyObject * obj1 = 0 ;
35464 char *kwnames[] = {
35465 (char *) "self",(char *) "checkable", NULL
35466 };
35467
35468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35470 if (SWIG_arg_fail(1)) SWIG_fail;
35471 {
35472 arg2 = (bool)(SWIG_As_bool(obj1));
35473 if (SWIG_arg_fail(2)) SWIG_fail;
35474 }
35475 {
35476 PyThreadState* __tstate = wxPyBeginAllowThreads();
35477 (arg1)->SetCheckable(arg2);
35478
35479 wxPyEndAllowThreads(__tstate);
35480 if (PyErr_Occurred()) SWIG_fail;
35481 }
35482 Py_INCREF(Py_None); resultobj = Py_None;
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35490 PyObject *resultobj;
35491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35492 bool result;
35493 PyObject * obj0 = 0 ;
35494 char *kwnames[] = {
35495 (char *) "self", NULL
35496 };
35497
35498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35500 if (SWIG_arg_fail(1)) SWIG_fail;
35501 {
35502 PyThreadState* __tstate = wxPyBeginAllowThreads();
35503 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35504
35505 wxPyEndAllowThreads(__tstate);
35506 if (PyErr_Occurred()) SWIG_fail;
35507 }
35508 {
35509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35510 }
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj;
35519 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35520 bool result;
35521 PyObject * obj0 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35532
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 {
35537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35538 }
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj;
35547 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35548 wxMenu *arg2 = (wxMenu *) 0 ;
35549 PyObject * obj0 = 0 ;
35550 PyObject * obj1 = 0 ;
35551 char *kwnames[] = {
35552 (char *) "self",(char *) "menu", NULL
35553 };
35554
35555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35557 if (SWIG_arg_fail(1)) SWIG_fail;
35558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35559 if (SWIG_arg_fail(2)) SWIG_fail;
35560 {
35561 PyThreadState* __tstate = wxPyBeginAllowThreads();
35562 (arg1)->SetSubMenu(arg2);
35563
35564 wxPyEndAllowThreads(__tstate);
35565 if (PyErr_Occurred()) SWIG_fail;
35566 }
35567 Py_INCREF(Py_None); resultobj = Py_None;
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35575 PyObject *resultobj;
35576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35577 wxMenu *result;
35578 PyObject * obj0 = 0 ;
35579 char *kwnames[] = {
35580 (char *) "self", NULL
35581 };
35582
35583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35585 if (SWIG_arg_fail(1)) SWIG_fail;
35586 {
35587 PyThreadState* __tstate = wxPyBeginAllowThreads();
35588 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35589
35590 wxPyEndAllowThreads(__tstate);
35591 if (PyErr_Occurred()) SWIG_fail;
35592 }
35593 {
35594 resultobj = wxPyMake_wxObject(result, 0);
35595 }
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj;
35604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35605 bool arg2 = (bool) true ;
35606 PyObject * obj0 = 0 ;
35607 PyObject * obj1 = 0 ;
35608 char *kwnames[] = {
35609 (char *) "self",(char *) "enable", NULL
35610 };
35611
35612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35614 if (SWIG_arg_fail(1)) SWIG_fail;
35615 if (obj1) {
35616 {
35617 arg2 = (bool)(SWIG_As_bool(obj1));
35618 if (SWIG_arg_fail(2)) SWIG_fail;
35619 }
35620 }
35621 {
35622 PyThreadState* __tstate = wxPyBeginAllowThreads();
35623 (arg1)->Enable(arg2);
35624
35625 wxPyEndAllowThreads(__tstate);
35626 if (PyErr_Occurred()) SWIG_fail;
35627 }
35628 Py_INCREF(Py_None); resultobj = Py_None;
35629 return resultobj;
35630 fail:
35631 return NULL;
35632 }
35633
35634
35635 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35636 PyObject *resultobj;
35637 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35638 bool result;
35639 PyObject * obj0 = 0 ;
35640 char *kwnames[] = {
35641 (char *) "self", NULL
35642 };
35643
35644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35646 if (SWIG_arg_fail(1)) SWIG_fail;
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35650
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 {
35655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35656 }
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35664 PyObject *resultobj;
35665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35666 bool arg2 = (bool) true ;
35667 PyObject * obj0 = 0 ;
35668 PyObject * obj1 = 0 ;
35669 char *kwnames[] = {
35670 (char *) "self",(char *) "check", NULL
35671 };
35672
35673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35675 if (SWIG_arg_fail(1)) SWIG_fail;
35676 if (obj1) {
35677 {
35678 arg2 = (bool)(SWIG_As_bool(obj1));
35679 if (SWIG_arg_fail(2)) SWIG_fail;
35680 }
35681 }
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 (arg1)->Check(arg2);
35685
35686 wxPyEndAllowThreads(__tstate);
35687 if (PyErr_Occurred()) SWIG_fail;
35688 }
35689 Py_INCREF(Py_None); resultobj = Py_None;
35690 return resultobj;
35691 fail:
35692 return NULL;
35693 }
35694
35695
35696 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35697 PyObject *resultobj;
35698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35699 bool result;
35700 PyObject * obj0 = 0 ;
35701 char *kwnames[] = {
35702 (char *) "self", NULL
35703 };
35704
35705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35707 if (SWIG_arg_fail(1)) SWIG_fail;
35708 {
35709 PyThreadState* __tstate = wxPyBeginAllowThreads();
35710 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35711
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 {
35716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35717 }
35718 return resultobj;
35719 fail:
35720 return NULL;
35721 }
35722
35723
35724 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35725 PyObject *resultobj;
35726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35727 PyObject * obj0 = 0 ;
35728 char *kwnames[] = {
35729 (char *) "self", NULL
35730 };
35731
35732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35734 if (SWIG_arg_fail(1)) SWIG_fail;
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 (arg1)->Toggle();
35738
35739 wxPyEndAllowThreads(__tstate);
35740 if (PyErr_Occurred()) SWIG_fail;
35741 }
35742 Py_INCREF(Py_None); resultobj = Py_None;
35743 return resultobj;
35744 fail:
35745 return NULL;
35746 }
35747
35748
35749 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35750 PyObject *resultobj;
35751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35752 wxString *arg2 = 0 ;
35753 bool temp2 = false ;
35754 PyObject * obj0 = 0 ;
35755 PyObject * obj1 = 0 ;
35756 char *kwnames[] = {
35757 (char *) "self",(char *) "str", NULL
35758 };
35759
35760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35762 if (SWIG_arg_fail(1)) SWIG_fail;
35763 {
35764 arg2 = wxString_in_helper(obj1);
35765 if (arg2 == NULL) SWIG_fail;
35766 temp2 = true;
35767 }
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 (arg1)->SetHelp((wxString const &)*arg2);
35771
35772 wxPyEndAllowThreads(__tstate);
35773 if (PyErr_Occurred()) SWIG_fail;
35774 }
35775 Py_INCREF(Py_None); resultobj = Py_None;
35776 {
35777 if (temp2)
35778 delete arg2;
35779 }
35780 return resultobj;
35781 fail:
35782 {
35783 if (temp2)
35784 delete arg2;
35785 }
35786 return NULL;
35787 }
35788
35789
35790 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35791 PyObject *resultobj;
35792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35793 wxString *result;
35794 PyObject * obj0 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 {
35805 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35806 result = (wxString *) &_result_ref;
35807 }
35808
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 {
35813 #if wxUSE_UNICODE
35814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35815 #else
35816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35817 #endif
35818 }
35819 return resultobj;
35820 fail:
35821 return NULL;
35822 }
35823
35824
35825 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35826 PyObject *resultobj;
35827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35828 wxAcceleratorEntry *result;
35829 PyObject * obj0 = 0 ;
35830 char *kwnames[] = {
35831 (char *) "self", NULL
35832 };
35833
35834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35836 if (SWIG_arg_fail(1)) SWIG_fail;
35837 {
35838 PyThreadState* __tstate = wxPyBeginAllowThreads();
35839 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35840
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35852 PyObject *resultobj;
35853 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35854 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35855 PyObject * obj0 = 0 ;
35856 PyObject * obj1 = 0 ;
35857 char *kwnames[] = {
35858 (char *) "self",(char *) "accel", NULL
35859 };
35860
35861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35863 if (SWIG_arg_fail(1)) SWIG_fail;
35864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35865 if (SWIG_arg_fail(2)) SWIG_fail;
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 (arg1)->SetAccel(arg2);
35869
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 Py_INCREF(Py_None); resultobj = Py_None;
35874 return resultobj;
35875 fail:
35876 return NULL;
35877 }
35878
35879
35880 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
35881 PyObject *resultobj;
35882 int result;
35883 char *kwnames[] = {
35884 NULL
35885 };
35886
35887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
35888 {
35889 PyThreadState* __tstate = wxPyBeginAllowThreads();
35890 result = (int)MenuItem_GetDefaultMarginWidth();
35891
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 {
35896 resultobj = SWIG_From_int((int)(result));
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj;
35906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35907 wxBitmap *arg2 = 0 ;
35908 PyObject * obj0 = 0 ;
35909 PyObject * obj1 = 0 ;
35910 char *kwnames[] = {
35911 (char *) "self",(char *) "bitmap", NULL
35912 };
35913
35914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
35915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35916 if (SWIG_arg_fail(1)) SWIG_fail;
35917 {
35918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
35919 if (SWIG_arg_fail(2)) SWIG_fail;
35920 if (arg2 == NULL) {
35921 SWIG_null_ref("wxBitmap");
35922 }
35923 if (SWIG_arg_fail(2)) SWIG_fail;
35924 }
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 (arg1)->SetBitmap((wxBitmap const &)*arg2);
35928
35929 wxPyEndAllowThreads(__tstate);
35930 if (PyErr_Occurred()) SWIG_fail;
35931 }
35932 Py_INCREF(Py_None); resultobj = Py_None;
35933 return resultobj;
35934 fail:
35935 return NULL;
35936 }
35937
35938
35939 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35940 PyObject *resultobj;
35941 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35942 wxBitmap *result;
35943 PyObject * obj0 = 0 ;
35944 char *kwnames[] = {
35945 (char *) "self", NULL
35946 };
35947
35948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
35949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35950 if (SWIG_arg_fail(1)) SWIG_fail;
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 {
35954 wxBitmap const &_result_ref = (arg1)->GetBitmap();
35955 result = (wxBitmap *) &_result_ref;
35956 }
35957
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 {
35962 wxBitmap* resultptr = new wxBitmap(*result);
35963 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
35964 }
35965 return resultobj;
35966 fail:
35967 return NULL;
35968 }
35969
35970
35971 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
35972 PyObject *obj;
35973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35974 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
35975 Py_INCREF(obj);
35976 return Py_BuildValue((char *)"");
35977 }
35978 static int _wrap_ControlNameStr_set(PyObject *) {
35979 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
35980 return 1;
35981 }
35982
35983
35984 static PyObject *_wrap_ControlNameStr_get(void) {
35985 PyObject *pyobj;
35986
35987 {
35988 #if wxUSE_UNICODE
35989 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35990 #else
35991 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35992 #endif
35993 }
35994 return pyobj;
35995 }
35996
35997
35998 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
35999 PyObject *resultobj;
36000 wxWindow *arg1 = (wxWindow *) 0 ;
36001 int arg2 = (int) -1 ;
36002 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36003 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36004 wxSize const &arg4_defvalue = wxDefaultSize ;
36005 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36006 long arg5 = (long) 0 ;
36007 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36008 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36009 wxString const &arg7_defvalue = wxPyControlNameStr ;
36010 wxString *arg7 = (wxString *) &arg7_defvalue ;
36011 wxControl *result;
36012 wxPoint temp3 ;
36013 wxSize temp4 ;
36014 bool temp7 = false ;
36015 PyObject * obj0 = 0 ;
36016 PyObject * obj1 = 0 ;
36017 PyObject * obj2 = 0 ;
36018 PyObject * obj3 = 0 ;
36019 PyObject * obj4 = 0 ;
36020 PyObject * obj5 = 0 ;
36021 PyObject * obj6 = 0 ;
36022 char *kwnames[] = {
36023 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36024 };
36025
36026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36028 if (SWIG_arg_fail(1)) SWIG_fail;
36029 if (obj1) {
36030 {
36031 arg2 = (int)(SWIG_As_int(obj1));
36032 if (SWIG_arg_fail(2)) SWIG_fail;
36033 }
36034 }
36035 if (obj2) {
36036 {
36037 arg3 = &temp3;
36038 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36039 }
36040 }
36041 if (obj3) {
36042 {
36043 arg4 = &temp4;
36044 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36045 }
36046 }
36047 if (obj4) {
36048 {
36049 arg5 = (long)(SWIG_As_long(obj4));
36050 if (SWIG_arg_fail(5)) SWIG_fail;
36051 }
36052 }
36053 if (obj5) {
36054 {
36055 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36056 if (SWIG_arg_fail(6)) SWIG_fail;
36057 if (arg6 == NULL) {
36058 SWIG_null_ref("wxValidator");
36059 }
36060 if (SWIG_arg_fail(6)) SWIG_fail;
36061 }
36062 }
36063 if (obj6) {
36064 {
36065 arg7 = wxString_in_helper(obj6);
36066 if (arg7 == NULL) SWIG_fail;
36067 temp7 = true;
36068 }
36069 }
36070 {
36071 if (!wxPyCheckForApp()) SWIG_fail;
36072 PyThreadState* __tstate = wxPyBeginAllowThreads();
36073 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36074
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36079 {
36080 if (temp7)
36081 delete arg7;
36082 }
36083 return resultobj;
36084 fail:
36085 {
36086 if (temp7)
36087 delete arg7;
36088 }
36089 return NULL;
36090 }
36091
36092
36093 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36094 PyObject *resultobj;
36095 wxControl *result;
36096 char *kwnames[] = {
36097 NULL
36098 };
36099
36100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36101 {
36102 if (!wxPyCheckForApp()) SWIG_fail;
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 result = (wxControl *)new wxControl();
36105
36106 wxPyEndAllowThreads(__tstate);
36107 if (PyErr_Occurred()) SWIG_fail;
36108 }
36109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36110 return resultobj;
36111 fail:
36112 return NULL;
36113 }
36114
36115
36116 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36117 PyObject *resultobj;
36118 wxControl *arg1 = (wxControl *) 0 ;
36119 wxWindow *arg2 = (wxWindow *) 0 ;
36120 int arg3 = (int) -1 ;
36121 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36122 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36123 wxSize const &arg5_defvalue = wxDefaultSize ;
36124 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36125 long arg6 = (long) 0 ;
36126 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36127 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36128 wxString const &arg8_defvalue = wxPyControlNameStr ;
36129 wxString *arg8 = (wxString *) &arg8_defvalue ;
36130 bool result;
36131 wxPoint temp4 ;
36132 wxSize temp5 ;
36133 bool temp8 = false ;
36134 PyObject * obj0 = 0 ;
36135 PyObject * obj1 = 0 ;
36136 PyObject * obj2 = 0 ;
36137 PyObject * obj3 = 0 ;
36138 PyObject * obj4 = 0 ;
36139 PyObject * obj5 = 0 ;
36140 PyObject * obj6 = 0 ;
36141 PyObject * obj7 = 0 ;
36142 char *kwnames[] = {
36143 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36144 };
36145
36146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36148 if (SWIG_arg_fail(1)) SWIG_fail;
36149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(2)) SWIG_fail;
36151 if (obj2) {
36152 {
36153 arg3 = (int)(SWIG_As_int(obj2));
36154 if (SWIG_arg_fail(3)) SWIG_fail;
36155 }
36156 }
36157 if (obj3) {
36158 {
36159 arg4 = &temp4;
36160 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36161 }
36162 }
36163 if (obj4) {
36164 {
36165 arg5 = &temp5;
36166 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36167 }
36168 }
36169 if (obj5) {
36170 {
36171 arg6 = (long)(SWIG_As_long(obj5));
36172 if (SWIG_arg_fail(6)) SWIG_fail;
36173 }
36174 }
36175 if (obj6) {
36176 {
36177 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36178 if (SWIG_arg_fail(7)) SWIG_fail;
36179 if (arg7 == NULL) {
36180 SWIG_null_ref("wxValidator");
36181 }
36182 if (SWIG_arg_fail(7)) SWIG_fail;
36183 }
36184 }
36185 if (obj7) {
36186 {
36187 arg8 = wxString_in_helper(obj7);
36188 if (arg8 == NULL) SWIG_fail;
36189 temp8 = true;
36190 }
36191 }
36192 {
36193 PyThreadState* __tstate = wxPyBeginAllowThreads();
36194 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36195
36196 wxPyEndAllowThreads(__tstate);
36197 if (PyErr_Occurred()) SWIG_fail;
36198 }
36199 {
36200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36201 }
36202 {
36203 if (temp8)
36204 delete arg8;
36205 }
36206 return resultobj;
36207 fail:
36208 {
36209 if (temp8)
36210 delete arg8;
36211 }
36212 return NULL;
36213 }
36214
36215
36216 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36217 PyObject *resultobj;
36218 wxControl *arg1 = (wxControl *) 0 ;
36219 wxCommandEvent *arg2 = 0 ;
36220 PyObject * obj0 = 0 ;
36221 PyObject * obj1 = 0 ;
36222 char *kwnames[] = {
36223 (char *) "self",(char *) "event", NULL
36224 };
36225
36226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36228 if (SWIG_arg_fail(1)) SWIG_fail;
36229 {
36230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36231 if (SWIG_arg_fail(2)) SWIG_fail;
36232 if (arg2 == NULL) {
36233 SWIG_null_ref("wxCommandEvent");
36234 }
36235 if (SWIG_arg_fail(2)) SWIG_fail;
36236 }
36237 {
36238 PyThreadState* __tstate = wxPyBeginAllowThreads();
36239 (arg1)->Command(*arg2);
36240
36241 wxPyEndAllowThreads(__tstate);
36242 if (PyErr_Occurred()) SWIG_fail;
36243 }
36244 Py_INCREF(Py_None); resultobj = Py_None;
36245 return resultobj;
36246 fail:
36247 return NULL;
36248 }
36249
36250
36251 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36252 PyObject *resultobj;
36253 wxControl *arg1 = (wxControl *) 0 ;
36254 wxString result;
36255 PyObject * obj0 = 0 ;
36256 char *kwnames[] = {
36257 (char *) "self", NULL
36258 };
36259
36260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36262 if (SWIG_arg_fail(1)) SWIG_fail;
36263 {
36264 PyThreadState* __tstate = wxPyBeginAllowThreads();
36265 result = (arg1)->GetLabel();
36266
36267 wxPyEndAllowThreads(__tstate);
36268 if (PyErr_Occurred()) SWIG_fail;
36269 }
36270 {
36271 #if wxUSE_UNICODE
36272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36273 #else
36274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36275 #endif
36276 }
36277 return resultobj;
36278 fail:
36279 return NULL;
36280 }
36281
36282
36283 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36284 PyObject *resultobj;
36285 wxControl *arg1 = (wxControl *) 0 ;
36286 wxString *arg2 = 0 ;
36287 bool temp2 = false ;
36288 PyObject * obj0 = 0 ;
36289 PyObject * obj1 = 0 ;
36290 char *kwnames[] = {
36291 (char *) "self",(char *) "label", NULL
36292 };
36293
36294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36296 if (SWIG_arg_fail(1)) SWIG_fail;
36297 {
36298 arg2 = wxString_in_helper(obj1);
36299 if (arg2 == NULL) SWIG_fail;
36300 temp2 = true;
36301 }
36302 {
36303 PyThreadState* __tstate = wxPyBeginAllowThreads();
36304 (arg1)->SetLabel((wxString const &)*arg2);
36305
36306 wxPyEndAllowThreads(__tstate);
36307 if (PyErr_Occurred()) SWIG_fail;
36308 }
36309 Py_INCREF(Py_None); resultobj = Py_None;
36310 {
36311 if (temp2)
36312 delete arg2;
36313 }
36314 return resultobj;
36315 fail:
36316 {
36317 if (temp2)
36318 delete arg2;
36319 }
36320 return NULL;
36321 }
36322
36323
36324 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36325 PyObject *resultobj;
36326 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36327 wxVisualAttributes result;
36328 PyObject * obj0 = 0 ;
36329 char *kwnames[] = {
36330 (char *) "variant", NULL
36331 };
36332
36333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36334 if (obj0) {
36335 {
36336 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36337 if (SWIG_arg_fail(1)) SWIG_fail;
36338 }
36339 }
36340 {
36341 if (!wxPyCheckForApp()) SWIG_fail;
36342 PyThreadState* __tstate = wxPyBeginAllowThreads();
36343 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36344
36345 wxPyEndAllowThreads(__tstate);
36346 if (PyErr_Occurred()) SWIG_fail;
36347 }
36348 {
36349 wxVisualAttributes * resultptr;
36350 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36352 }
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36360 PyObject *obj;
36361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36362 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36363 Py_INCREF(obj);
36364 return Py_BuildValue((char *)"");
36365 }
36366 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36367 PyObject *resultobj;
36368 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36369 wxString *arg2 = 0 ;
36370 PyObject *arg3 = (PyObject *) NULL ;
36371 int result;
36372 bool temp2 = false ;
36373 PyObject * obj0 = 0 ;
36374 PyObject * obj1 = 0 ;
36375 PyObject * obj2 = 0 ;
36376 char *kwnames[] = {
36377 (char *) "self",(char *) "item",(char *) "clientData", NULL
36378 };
36379
36380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36382 if (SWIG_arg_fail(1)) SWIG_fail;
36383 {
36384 arg2 = wxString_in_helper(obj1);
36385 if (arg2 == NULL) SWIG_fail;
36386 temp2 = true;
36387 }
36388 if (obj2) {
36389 arg3 = obj2;
36390 }
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36394
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 {
36399 resultobj = SWIG_From_int((int)(result));
36400 }
36401 {
36402 if (temp2)
36403 delete arg2;
36404 }
36405 return resultobj;
36406 fail:
36407 {
36408 if (temp2)
36409 delete arg2;
36410 }
36411 return NULL;
36412 }
36413
36414
36415 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36416 PyObject *resultobj;
36417 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36418 wxArrayString *arg2 = 0 ;
36419 bool temp2 = false ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self",(char *) "strings", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 if (! PySequence_Check(obj1)) {
36431 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36432 SWIG_fail;
36433 }
36434 arg2 = new wxArrayString;
36435 temp2 = true;
36436 int i, len=PySequence_Length(obj1);
36437 for (i=0; i<len; i++) {
36438 PyObject* item = PySequence_GetItem(obj1, i);
36439 #if wxUSE_UNICODE
36440 PyObject* str = PyObject_Unicode(item);
36441 #else
36442 PyObject* str = PyObject_Str(item);
36443 #endif
36444 if (PyErr_Occurred()) SWIG_fail;
36445 arg2->Add(Py2wxString(str));
36446 Py_DECREF(item);
36447 Py_DECREF(str);
36448 }
36449 }
36450 {
36451 PyThreadState* __tstate = wxPyBeginAllowThreads();
36452 (arg1)->Append((wxArrayString const &)*arg2);
36453
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 Py_INCREF(Py_None); resultobj = Py_None;
36458 {
36459 if (temp2) delete arg2;
36460 }
36461 return resultobj;
36462 fail:
36463 {
36464 if (temp2) delete arg2;
36465 }
36466 return NULL;
36467 }
36468
36469
36470 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36471 PyObject *resultobj;
36472 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36473 wxString *arg2 = 0 ;
36474 int arg3 ;
36475 PyObject *arg4 = (PyObject *) NULL ;
36476 int result;
36477 bool temp2 = false ;
36478 PyObject * obj0 = 0 ;
36479 PyObject * obj1 = 0 ;
36480 PyObject * obj2 = 0 ;
36481 PyObject * obj3 = 0 ;
36482 char *kwnames[] = {
36483 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36484 };
36485
36486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36488 if (SWIG_arg_fail(1)) SWIG_fail;
36489 {
36490 arg2 = wxString_in_helper(obj1);
36491 if (arg2 == NULL) SWIG_fail;
36492 temp2 = true;
36493 }
36494 {
36495 arg3 = (int)(SWIG_As_int(obj2));
36496 if (SWIG_arg_fail(3)) SWIG_fail;
36497 }
36498 if (obj3) {
36499 arg4 = obj3;
36500 }
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36504
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 {
36509 resultobj = SWIG_From_int((int)(result));
36510 }
36511 {
36512 if (temp2)
36513 delete arg2;
36514 }
36515 return resultobj;
36516 fail:
36517 {
36518 if (temp2)
36519 delete arg2;
36520 }
36521 return NULL;
36522 }
36523
36524
36525 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36526 PyObject *resultobj;
36527 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36528 PyObject * obj0 = 0 ;
36529 char *kwnames[] = {
36530 (char *) "self", NULL
36531 };
36532
36533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36535 if (SWIG_arg_fail(1)) SWIG_fail;
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 (arg1)->Clear();
36539
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 Py_INCREF(Py_None); resultobj = Py_None;
36544 return resultobj;
36545 fail:
36546 return NULL;
36547 }
36548
36549
36550 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36551 PyObject *resultobj;
36552 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36553 int arg2 ;
36554 PyObject * obj0 = 0 ;
36555 PyObject * obj1 = 0 ;
36556 char *kwnames[] = {
36557 (char *) "self",(char *) "n", NULL
36558 };
36559
36560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36562 if (SWIG_arg_fail(1)) SWIG_fail;
36563 {
36564 arg2 = (int)(SWIG_As_int(obj1));
36565 if (SWIG_arg_fail(2)) SWIG_fail;
36566 }
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 (arg1)->Delete(arg2);
36570
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 Py_INCREF(Py_None); resultobj = Py_None;
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj;
36583 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36584 int result;
36585 PyObject * obj0 = 0 ;
36586 char *kwnames[] = {
36587 (char *) "self", NULL
36588 };
36589
36590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36592 if (SWIG_arg_fail(1)) SWIG_fail;
36593 {
36594 PyThreadState* __tstate = wxPyBeginAllowThreads();
36595 result = (int)((wxItemContainer const *)arg1)->GetCount();
36596
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 {
36601 resultobj = SWIG_From_int((int)(result));
36602 }
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36610 PyObject *resultobj;
36611 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36612 bool result;
36613 PyObject * obj0 = 0 ;
36614 char *kwnames[] = {
36615 (char *) "self", NULL
36616 };
36617
36618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36620 if (SWIG_arg_fail(1)) SWIG_fail;
36621 {
36622 PyThreadState* __tstate = wxPyBeginAllowThreads();
36623 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36624
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 {
36629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36630 }
36631 return resultobj;
36632 fail:
36633 return NULL;
36634 }
36635
36636
36637 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36638 PyObject *resultobj;
36639 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36640 int arg2 ;
36641 wxString result;
36642 PyObject * obj0 = 0 ;
36643 PyObject * obj1 = 0 ;
36644 char *kwnames[] = {
36645 (char *) "self",(char *) "n", NULL
36646 };
36647
36648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36650 if (SWIG_arg_fail(1)) SWIG_fail;
36651 {
36652 arg2 = (int)(SWIG_As_int(obj1));
36653 if (SWIG_arg_fail(2)) SWIG_fail;
36654 }
36655 {
36656 PyThreadState* __tstate = wxPyBeginAllowThreads();
36657 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36658
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 {
36663 #if wxUSE_UNICODE
36664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36665 #else
36666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36667 #endif
36668 }
36669 return resultobj;
36670 fail:
36671 return NULL;
36672 }
36673
36674
36675 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36676 PyObject *resultobj;
36677 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36678 wxArrayString result;
36679 PyObject * obj0 = 0 ;
36680 char *kwnames[] = {
36681 (char *) "self", NULL
36682 };
36683
36684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36686 if (SWIG_arg_fail(1)) SWIG_fail;
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 result = ((wxItemContainer const *)arg1)->GetStrings();
36690
36691 wxPyEndAllowThreads(__tstate);
36692 if (PyErr_Occurred()) SWIG_fail;
36693 }
36694 {
36695 resultobj = wxArrayString2PyList_helper(result);
36696 }
36697 return resultobj;
36698 fail:
36699 return NULL;
36700 }
36701
36702
36703 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36704 PyObject *resultobj;
36705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36706 int arg2 ;
36707 wxString *arg3 = 0 ;
36708 bool temp3 = false ;
36709 PyObject * obj0 = 0 ;
36710 PyObject * obj1 = 0 ;
36711 PyObject * obj2 = 0 ;
36712 char *kwnames[] = {
36713 (char *) "self",(char *) "n",(char *) "s", NULL
36714 };
36715
36716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36718 if (SWIG_arg_fail(1)) SWIG_fail;
36719 {
36720 arg2 = (int)(SWIG_As_int(obj1));
36721 if (SWIG_arg_fail(2)) SWIG_fail;
36722 }
36723 {
36724 arg3 = wxString_in_helper(obj2);
36725 if (arg3 == NULL) SWIG_fail;
36726 temp3 = true;
36727 }
36728 {
36729 PyThreadState* __tstate = wxPyBeginAllowThreads();
36730 (arg1)->SetString(arg2,(wxString const &)*arg3);
36731
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 Py_INCREF(Py_None); resultobj = Py_None;
36736 {
36737 if (temp3)
36738 delete arg3;
36739 }
36740 return resultobj;
36741 fail:
36742 {
36743 if (temp3)
36744 delete arg3;
36745 }
36746 return NULL;
36747 }
36748
36749
36750 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
36751 PyObject *resultobj;
36752 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36753 wxString *arg2 = 0 ;
36754 int result;
36755 bool temp2 = false ;
36756 PyObject * obj0 = 0 ;
36757 PyObject * obj1 = 0 ;
36758 char *kwnames[] = {
36759 (char *) "self",(char *) "s", NULL
36760 };
36761
36762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
36763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36764 if (SWIG_arg_fail(1)) SWIG_fail;
36765 {
36766 arg2 = wxString_in_helper(obj1);
36767 if (arg2 == NULL) SWIG_fail;
36768 temp2 = true;
36769 }
36770 {
36771 PyThreadState* __tstate = wxPyBeginAllowThreads();
36772 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
36773
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 {
36778 resultobj = SWIG_From_int((int)(result));
36779 }
36780 {
36781 if (temp2)
36782 delete arg2;
36783 }
36784 return resultobj;
36785 fail:
36786 {
36787 if (temp2)
36788 delete arg2;
36789 }
36790 return NULL;
36791 }
36792
36793
36794 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
36795 PyObject *resultobj;
36796 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36797 int arg2 ;
36798 PyObject * obj0 = 0 ;
36799 PyObject * obj1 = 0 ;
36800 char *kwnames[] = {
36801 (char *) "self",(char *) "n", NULL
36802 };
36803
36804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
36805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36806 if (SWIG_arg_fail(1)) SWIG_fail;
36807 {
36808 arg2 = (int)(SWIG_As_int(obj1));
36809 if (SWIG_arg_fail(2)) SWIG_fail;
36810 }
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 (arg1)->Select(arg2);
36814
36815 wxPyEndAllowThreads(__tstate);
36816 if (PyErr_Occurred()) SWIG_fail;
36817 }
36818 Py_INCREF(Py_None); resultobj = Py_None;
36819 return resultobj;
36820 fail:
36821 return NULL;
36822 }
36823
36824
36825 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36826 PyObject *resultobj;
36827 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36828 int result;
36829 PyObject * obj0 = 0 ;
36830 char *kwnames[] = {
36831 (char *) "self", NULL
36832 };
36833
36834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
36835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36836 if (SWIG_arg_fail(1)) SWIG_fail;
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = (int)((wxItemContainer const *)arg1)->GetSelection();
36840
36841 wxPyEndAllowThreads(__tstate);
36842 if (PyErr_Occurred()) SWIG_fail;
36843 }
36844 {
36845 resultobj = SWIG_From_int((int)(result));
36846 }
36847 return resultobj;
36848 fail:
36849 return NULL;
36850 }
36851
36852
36853 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36854 PyObject *resultobj;
36855 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36856 wxString result;
36857 PyObject * obj0 = 0 ;
36858 char *kwnames[] = {
36859 (char *) "self", NULL
36860 };
36861
36862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
36863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36864 if (SWIG_arg_fail(1)) SWIG_fail;
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 result = ((wxItemContainer const *)arg1)->GetStringSelection();
36868
36869 wxPyEndAllowThreads(__tstate);
36870 if (PyErr_Occurred()) SWIG_fail;
36871 }
36872 {
36873 #if wxUSE_UNICODE
36874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36875 #else
36876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36877 #endif
36878 }
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj;
36887 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36888 int arg2 ;
36889 PyObject *result;
36890 PyObject * obj0 = 0 ;
36891 PyObject * obj1 = 0 ;
36892 char *kwnames[] = {
36893 (char *) "self",(char *) "n", NULL
36894 };
36895
36896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36898 if (SWIG_arg_fail(1)) SWIG_fail;
36899 {
36900 arg2 = (int)(SWIG_As_int(obj1));
36901 if (SWIG_arg_fail(2)) SWIG_fail;
36902 }
36903 {
36904 PyThreadState* __tstate = wxPyBeginAllowThreads();
36905 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36906
36907 wxPyEndAllowThreads(__tstate);
36908 if (PyErr_Occurred()) SWIG_fail;
36909 }
36910 resultobj = result;
36911 return resultobj;
36912 fail:
36913 return NULL;
36914 }
36915
36916
36917 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36918 PyObject *resultobj;
36919 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36920 int arg2 ;
36921 PyObject *arg3 = (PyObject *) 0 ;
36922 PyObject * obj0 = 0 ;
36923 PyObject * obj1 = 0 ;
36924 PyObject * obj2 = 0 ;
36925 char *kwnames[] = {
36926 (char *) "self",(char *) "n",(char *) "clientData", NULL
36927 };
36928
36929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36931 if (SWIG_arg_fail(1)) SWIG_fail;
36932 {
36933 arg2 = (int)(SWIG_As_int(obj1));
36934 if (SWIG_arg_fail(2)) SWIG_fail;
36935 }
36936 arg3 = obj2;
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 wxItemContainer_SetClientData(arg1,arg2,arg3);
36940
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 Py_INCREF(Py_None); resultobj = Py_None;
36945 return resultobj;
36946 fail:
36947 return NULL;
36948 }
36949
36950
36951 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
36952 PyObject *obj;
36953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36954 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
36955 Py_INCREF(obj);
36956 return Py_BuildValue((char *)"");
36957 }
36958 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
36959 PyObject *obj;
36960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36961 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
36962 Py_INCREF(obj);
36963 return Py_BuildValue((char *)"");
36964 }
36965 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
36966 PyObject *resultobj;
36967 wxSizerItem *result;
36968 char *kwnames[] = {
36969 NULL
36970 };
36971
36972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 result = (wxSizerItem *)new wxSizerItem();
36976
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
36988 PyObject *resultobj;
36989 wxWindow *arg1 = (wxWindow *) 0 ;
36990 int arg2 ;
36991 int arg3 ;
36992 int arg4 ;
36993 PyObject *arg5 = (PyObject *) NULL ;
36994 wxSizerItem *result;
36995 PyObject * obj0 = 0 ;
36996 PyObject * obj1 = 0 ;
36997 PyObject * obj2 = 0 ;
36998 PyObject * obj3 = 0 ;
36999 PyObject * obj4 = 0 ;
37000 char *kwnames[] = {
37001 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37002 };
37003
37004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37006 if (SWIG_arg_fail(1)) SWIG_fail;
37007 {
37008 arg2 = (int)(SWIG_As_int(obj1));
37009 if (SWIG_arg_fail(2)) SWIG_fail;
37010 }
37011 {
37012 arg3 = (int)(SWIG_As_int(obj2));
37013 if (SWIG_arg_fail(3)) SWIG_fail;
37014 }
37015 {
37016 arg4 = (int)(SWIG_As_int(obj3));
37017 if (SWIG_arg_fail(4)) SWIG_fail;
37018 }
37019 if (obj4) {
37020 arg5 = obj4;
37021 }
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37025
37026 wxPyEndAllowThreads(__tstate);
37027 if (PyErr_Occurred()) SWIG_fail;
37028 }
37029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37030 return resultobj;
37031 fail:
37032 return NULL;
37033 }
37034
37035
37036 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37037 PyObject *resultobj;
37038 int arg1 ;
37039 int arg2 ;
37040 int arg3 ;
37041 int arg4 ;
37042 int arg5 ;
37043 PyObject *arg6 = (PyObject *) NULL ;
37044 wxSizerItem *result;
37045 PyObject * obj0 = 0 ;
37046 PyObject * obj1 = 0 ;
37047 PyObject * obj2 = 0 ;
37048 PyObject * obj3 = 0 ;
37049 PyObject * obj4 = 0 ;
37050 PyObject * obj5 = 0 ;
37051 char *kwnames[] = {
37052 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37053 };
37054
37055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37056 {
37057 arg1 = (int)(SWIG_As_int(obj0));
37058 if (SWIG_arg_fail(1)) SWIG_fail;
37059 }
37060 {
37061 arg2 = (int)(SWIG_As_int(obj1));
37062 if (SWIG_arg_fail(2)) SWIG_fail;
37063 }
37064 {
37065 arg3 = (int)(SWIG_As_int(obj2));
37066 if (SWIG_arg_fail(3)) SWIG_fail;
37067 }
37068 {
37069 arg4 = (int)(SWIG_As_int(obj3));
37070 if (SWIG_arg_fail(4)) SWIG_fail;
37071 }
37072 {
37073 arg5 = (int)(SWIG_As_int(obj4));
37074 if (SWIG_arg_fail(5)) SWIG_fail;
37075 }
37076 if (obj5) {
37077 arg6 = obj5;
37078 }
37079 {
37080 PyThreadState* __tstate = wxPyBeginAllowThreads();
37081 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37082
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37087 return resultobj;
37088 fail:
37089 return NULL;
37090 }
37091
37092
37093 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37094 PyObject *resultobj;
37095 wxSizer *arg1 = (wxSizer *) 0 ;
37096 int arg2 ;
37097 int arg3 ;
37098 int arg4 ;
37099 PyObject *arg5 = (PyObject *) NULL ;
37100 wxSizerItem *result;
37101 PyObject * obj0 = 0 ;
37102 PyObject * obj1 = 0 ;
37103 PyObject * obj2 = 0 ;
37104 PyObject * obj3 = 0 ;
37105 PyObject * obj4 = 0 ;
37106 char *kwnames[] = {
37107 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37108 };
37109
37110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37112 if (SWIG_arg_fail(1)) SWIG_fail;
37113 {
37114 arg2 = (int)(SWIG_As_int(obj1));
37115 if (SWIG_arg_fail(2)) SWIG_fail;
37116 }
37117 {
37118 arg3 = (int)(SWIG_As_int(obj2));
37119 if (SWIG_arg_fail(3)) SWIG_fail;
37120 }
37121 {
37122 arg4 = (int)(SWIG_As_int(obj3));
37123 if (SWIG_arg_fail(4)) SWIG_fail;
37124 }
37125 if (obj4) {
37126 arg5 = obj4;
37127 }
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37131
37132 wxPyEndAllowThreads(__tstate);
37133 if (PyErr_Occurred()) SWIG_fail;
37134 }
37135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37143 PyObject *resultobj;
37144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37145 PyObject * obj0 = 0 ;
37146 char *kwnames[] = {
37147 (char *) "self", NULL
37148 };
37149
37150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37152 if (SWIG_arg_fail(1)) SWIG_fail;
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 (arg1)->DeleteWindows();
37156
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 Py_INCREF(Py_None); resultobj = Py_None;
37161 return resultobj;
37162 fail:
37163 return NULL;
37164 }
37165
37166
37167 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37168 PyObject *resultobj;
37169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37170 PyObject * obj0 = 0 ;
37171 char *kwnames[] = {
37172 (char *) "self", NULL
37173 };
37174
37175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37177 if (SWIG_arg_fail(1)) SWIG_fail;
37178 {
37179 PyThreadState* __tstate = wxPyBeginAllowThreads();
37180 (arg1)->DetachSizer();
37181
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 Py_INCREF(Py_None); resultobj = Py_None;
37186 return resultobj;
37187 fail:
37188 return NULL;
37189 }
37190
37191
37192 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37193 PyObject *resultobj;
37194 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37195 wxSize result;
37196 PyObject * obj0 = 0 ;
37197 char *kwnames[] = {
37198 (char *) "self", NULL
37199 };
37200
37201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37203 if (SWIG_arg_fail(1)) SWIG_fail;
37204 {
37205 PyThreadState* __tstate = wxPyBeginAllowThreads();
37206 result = (arg1)->GetSize();
37207
37208 wxPyEndAllowThreads(__tstate);
37209 if (PyErr_Occurred()) SWIG_fail;
37210 }
37211 {
37212 wxSize * resultptr;
37213 resultptr = new wxSize((wxSize &)(result));
37214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37215 }
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37223 PyObject *resultobj;
37224 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37225 wxSize result;
37226 PyObject * obj0 = 0 ;
37227 char *kwnames[] = {
37228 (char *) "self", NULL
37229 };
37230
37231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37233 if (SWIG_arg_fail(1)) SWIG_fail;
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 result = (arg1)->CalcMin();
37237
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 {
37242 wxSize * resultptr;
37243 resultptr = new wxSize((wxSize &)(result));
37244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37245 }
37246 return resultobj;
37247 fail:
37248 return NULL;
37249 }
37250
37251
37252 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37253 PyObject *resultobj;
37254 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37255 wxPoint arg2 ;
37256 wxSize arg3 ;
37257 PyObject * obj0 = 0 ;
37258 PyObject * obj1 = 0 ;
37259 PyObject * obj2 = 0 ;
37260 char *kwnames[] = {
37261 (char *) "self",(char *) "pos",(char *) "size", NULL
37262 };
37263
37264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37266 if (SWIG_arg_fail(1)) SWIG_fail;
37267 {
37268 wxPoint * argp;
37269 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37270 if (SWIG_arg_fail(2)) SWIG_fail;
37271 if (argp == NULL) {
37272 SWIG_null_ref("wxPoint");
37273 }
37274 if (SWIG_arg_fail(2)) SWIG_fail;
37275 arg2 = *argp;
37276 }
37277 {
37278 wxSize * argp;
37279 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37280 if (SWIG_arg_fail(3)) SWIG_fail;
37281 if (argp == NULL) {
37282 SWIG_null_ref("wxSize");
37283 }
37284 if (SWIG_arg_fail(3)) SWIG_fail;
37285 arg3 = *argp;
37286 }
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 (arg1)->SetDimension(arg2,arg3);
37290
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 Py_INCREF(Py_None); resultobj = Py_None;
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj;
37303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37304 wxSize result;
37305 PyObject * obj0 = 0 ;
37306 char *kwnames[] = {
37307 (char *) "self", NULL
37308 };
37309
37310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37312 if (SWIG_arg_fail(1)) SWIG_fail;
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 result = (arg1)->GetMinSize();
37316
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 {
37321 wxSize * resultptr;
37322 resultptr = new wxSize((wxSize &)(result));
37323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37324 }
37325 return resultobj;
37326 fail:
37327 return NULL;
37328 }
37329
37330
37331 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj;
37333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37334 wxSize result;
37335 PyObject * obj0 = 0 ;
37336 char *kwnames[] = {
37337 (char *) "self", NULL
37338 };
37339
37340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37342 if (SWIG_arg_fail(1)) SWIG_fail;
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37346
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 {
37351 wxSize * resultptr;
37352 resultptr = new wxSize((wxSize &)(result));
37353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37354 }
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37362 PyObject *resultobj;
37363 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37364 int arg2 ;
37365 int arg3 ;
37366 PyObject * obj0 = 0 ;
37367 PyObject * obj1 = 0 ;
37368 PyObject * obj2 = 0 ;
37369 char *kwnames[] = {
37370 (char *) "self",(char *) "x",(char *) "y", NULL
37371 };
37372
37373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37375 if (SWIG_arg_fail(1)) SWIG_fail;
37376 {
37377 arg2 = (int)(SWIG_As_int(obj1));
37378 if (SWIG_arg_fail(2)) SWIG_fail;
37379 }
37380 {
37381 arg3 = (int)(SWIG_As_int(obj2));
37382 if (SWIG_arg_fail(3)) SWIG_fail;
37383 }
37384 {
37385 PyThreadState* __tstate = wxPyBeginAllowThreads();
37386 (arg1)->SetInitSize(arg2,arg3);
37387
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 Py_INCREF(Py_None); resultobj = Py_None;
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37399 PyObject *resultobj;
37400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37401 int arg2 ;
37402 int arg3 ;
37403 PyObject * obj0 = 0 ;
37404 PyObject * obj1 = 0 ;
37405 PyObject * obj2 = 0 ;
37406 char *kwnames[] = {
37407 (char *) "self",(char *) "width",(char *) "height", NULL
37408 };
37409
37410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37412 if (SWIG_arg_fail(1)) SWIG_fail;
37413 {
37414 arg2 = (int)(SWIG_As_int(obj1));
37415 if (SWIG_arg_fail(2)) SWIG_fail;
37416 }
37417 {
37418 arg3 = (int)(SWIG_As_int(obj2));
37419 if (SWIG_arg_fail(3)) SWIG_fail;
37420 }
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 (arg1)->SetRatio(arg2,arg3);
37424
37425 wxPyEndAllowThreads(__tstate);
37426 if (PyErr_Occurred()) SWIG_fail;
37427 }
37428 Py_INCREF(Py_None); resultobj = Py_None;
37429 return resultobj;
37430 fail:
37431 return NULL;
37432 }
37433
37434
37435 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37436 PyObject *resultobj;
37437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37438 wxSize arg2 ;
37439 PyObject * obj0 = 0 ;
37440 PyObject * obj1 = 0 ;
37441 char *kwnames[] = {
37442 (char *) "self",(char *) "size", NULL
37443 };
37444
37445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37447 if (SWIG_arg_fail(1)) SWIG_fail;
37448 {
37449 wxSize * argp;
37450 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37451 if (SWIG_arg_fail(2)) SWIG_fail;
37452 if (argp == NULL) {
37453 SWIG_null_ref("wxSize");
37454 }
37455 if (SWIG_arg_fail(2)) SWIG_fail;
37456 arg2 = *argp;
37457 }
37458 {
37459 PyThreadState* __tstate = wxPyBeginAllowThreads();
37460 (arg1)->SetRatio(arg2);
37461
37462 wxPyEndAllowThreads(__tstate);
37463 if (PyErr_Occurred()) SWIG_fail;
37464 }
37465 Py_INCREF(Py_None); resultobj = Py_None;
37466 return resultobj;
37467 fail:
37468 return NULL;
37469 }
37470
37471
37472 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37473 PyObject *resultobj;
37474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37475 float arg2 ;
37476 PyObject * obj0 = 0 ;
37477 PyObject * obj1 = 0 ;
37478 char *kwnames[] = {
37479 (char *) "self",(char *) "ratio", NULL
37480 };
37481
37482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37484 if (SWIG_arg_fail(1)) SWIG_fail;
37485 {
37486 arg2 = (float)(SWIG_As_float(obj1));
37487 if (SWIG_arg_fail(2)) SWIG_fail;
37488 }
37489 {
37490 PyThreadState* __tstate = wxPyBeginAllowThreads();
37491 (arg1)->SetRatio(arg2);
37492
37493 wxPyEndAllowThreads(__tstate);
37494 if (PyErr_Occurred()) SWIG_fail;
37495 }
37496 Py_INCREF(Py_None); resultobj = Py_None;
37497 return resultobj;
37498 fail:
37499 return NULL;
37500 }
37501
37502
37503 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37504 PyObject *resultobj;
37505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37506 float result;
37507 PyObject * obj0 = 0 ;
37508 char *kwnames[] = {
37509 (char *) "self", NULL
37510 };
37511
37512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37514 if (SWIG_arg_fail(1)) SWIG_fail;
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 result = (float)(arg1)->GetRatio();
37518
37519 wxPyEndAllowThreads(__tstate);
37520 if (PyErr_Occurred()) SWIG_fail;
37521 }
37522 {
37523 resultobj = SWIG_From_float((float)(result));
37524 }
37525 return resultobj;
37526 fail:
37527 return NULL;
37528 }
37529
37530
37531 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37532 PyObject *resultobj;
37533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37534 wxRect result;
37535 PyObject * obj0 = 0 ;
37536 char *kwnames[] = {
37537 (char *) "self", NULL
37538 };
37539
37540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37542 if (SWIG_arg_fail(1)) SWIG_fail;
37543 {
37544 PyThreadState* __tstate = wxPyBeginAllowThreads();
37545 result = (arg1)->GetRect();
37546
37547 wxPyEndAllowThreads(__tstate);
37548 if (PyErr_Occurred()) SWIG_fail;
37549 }
37550 {
37551 wxRect * resultptr;
37552 resultptr = new wxRect((wxRect &)(result));
37553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37554 }
37555 return resultobj;
37556 fail:
37557 return NULL;
37558 }
37559
37560
37561 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37562 PyObject *resultobj;
37563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37564 bool result;
37565 PyObject * obj0 = 0 ;
37566 char *kwnames[] = {
37567 (char *) "self", NULL
37568 };
37569
37570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37572 if (SWIG_arg_fail(1)) SWIG_fail;
37573 {
37574 PyThreadState* __tstate = wxPyBeginAllowThreads();
37575 result = (bool)(arg1)->IsWindow();
37576
37577 wxPyEndAllowThreads(__tstate);
37578 if (PyErr_Occurred()) SWIG_fail;
37579 }
37580 {
37581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37582 }
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj;
37591 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37592 bool result;
37593 PyObject * obj0 = 0 ;
37594 char *kwnames[] = {
37595 (char *) "self", NULL
37596 };
37597
37598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37600 if (SWIG_arg_fail(1)) SWIG_fail;
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 result = (bool)(arg1)->IsSizer();
37604
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 {
37609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37610 }
37611 return resultobj;
37612 fail:
37613 return NULL;
37614 }
37615
37616
37617 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37618 PyObject *resultobj;
37619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37620 bool result;
37621 PyObject * obj0 = 0 ;
37622 char *kwnames[] = {
37623 (char *) "self", NULL
37624 };
37625
37626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37628 if (SWIG_arg_fail(1)) SWIG_fail;
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 result = (bool)(arg1)->IsSpacer();
37632
37633 wxPyEndAllowThreads(__tstate);
37634 if (PyErr_Occurred()) SWIG_fail;
37635 }
37636 {
37637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37638 }
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37646 PyObject *resultobj;
37647 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37648 int arg2 ;
37649 PyObject * obj0 = 0 ;
37650 PyObject * obj1 = 0 ;
37651 char *kwnames[] = {
37652 (char *) "self",(char *) "proportion", NULL
37653 };
37654
37655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37657 if (SWIG_arg_fail(1)) SWIG_fail;
37658 {
37659 arg2 = (int)(SWIG_As_int(obj1));
37660 if (SWIG_arg_fail(2)) SWIG_fail;
37661 }
37662 {
37663 PyThreadState* __tstate = wxPyBeginAllowThreads();
37664 (arg1)->SetProportion(arg2);
37665
37666 wxPyEndAllowThreads(__tstate);
37667 if (PyErr_Occurred()) SWIG_fail;
37668 }
37669 Py_INCREF(Py_None); resultobj = Py_None;
37670 return resultobj;
37671 fail:
37672 return NULL;
37673 }
37674
37675
37676 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37677 PyObject *resultobj;
37678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37679 int result;
37680 PyObject * obj0 = 0 ;
37681 char *kwnames[] = {
37682 (char *) "self", NULL
37683 };
37684
37685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37687 if (SWIG_arg_fail(1)) SWIG_fail;
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 result = (int)(arg1)->GetProportion();
37691
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 {
37696 resultobj = SWIG_From_int((int)(result));
37697 }
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj;
37706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37707 int arg2 ;
37708 PyObject * obj0 = 0 ;
37709 PyObject * obj1 = 0 ;
37710 char *kwnames[] = {
37711 (char *) "self",(char *) "flag", NULL
37712 };
37713
37714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37716 if (SWIG_arg_fail(1)) SWIG_fail;
37717 {
37718 arg2 = (int)(SWIG_As_int(obj1));
37719 if (SWIG_arg_fail(2)) SWIG_fail;
37720 }
37721 {
37722 PyThreadState* __tstate = wxPyBeginAllowThreads();
37723 (arg1)->SetFlag(arg2);
37724
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 Py_INCREF(Py_None); resultobj = Py_None;
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37736 PyObject *resultobj;
37737 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37738 int result;
37739 PyObject * obj0 = 0 ;
37740 char *kwnames[] = {
37741 (char *) "self", NULL
37742 };
37743
37744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
37745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37746 if (SWIG_arg_fail(1)) SWIG_fail;
37747 {
37748 PyThreadState* __tstate = wxPyBeginAllowThreads();
37749 result = (int)(arg1)->GetFlag();
37750
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 {
37755 resultobj = SWIG_From_int((int)(result));
37756 }
37757 return resultobj;
37758 fail:
37759 return NULL;
37760 }
37761
37762
37763 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37764 PyObject *resultobj;
37765 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37766 int arg2 ;
37767 PyObject * obj0 = 0 ;
37768 PyObject * obj1 = 0 ;
37769 char *kwnames[] = {
37770 (char *) "self",(char *) "border", NULL
37771 };
37772
37773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
37774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37775 if (SWIG_arg_fail(1)) SWIG_fail;
37776 {
37777 arg2 = (int)(SWIG_As_int(obj1));
37778 if (SWIG_arg_fail(2)) SWIG_fail;
37779 }
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->SetBorder(arg2);
37783
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 Py_INCREF(Py_None); resultobj = Py_None;
37788 return resultobj;
37789 fail:
37790 return NULL;
37791 }
37792
37793
37794 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37795 PyObject *resultobj;
37796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37797 int result;
37798 PyObject * obj0 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (int)(arg1)->GetBorder();
37809
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 {
37814 resultobj = SWIG_From_int((int)(result));
37815 }
37816 return resultobj;
37817 fail:
37818 return NULL;
37819 }
37820
37821
37822 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37823 PyObject *resultobj;
37824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37825 wxWindow *result;
37826 PyObject * obj0 = 0 ;
37827 char *kwnames[] = {
37828 (char *) "self", NULL
37829 };
37830
37831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
37832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37833 if (SWIG_arg_fail(1)) SWIG_fail;
37834 {
37835 PyThreadState* __tstate = wxPyBeginAllowThreads();
37836 result = (wxWindow *)(arg1)->GetWindow();
37837
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 {
37842 resultobj = wxPyMake_wxObject(result, 0);
37843 }
37844 return resultobj;
37845 fail:
37846 return NULL;
37847 }
37848
37849
37850 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37851 PyObject *resultobj;
37852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37853 wxWindow *arg2 = (wxWindow *) 0 ;
37854 PyObject * obj0 = 0 ;
37855 PyObject * obj1 = 0 ;
37856 char *kwnames[] = {
37857 (char *) "self",(char *) "window", NULL
37858 };
37859
37860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
37861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37862 if (SWIG_arg_fail(1)) SWIG_fail;
37863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37864 if (SWIG_arg_fail(2)) SWIG_fail;
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 (arg1)->SetWindow(arg2);
37868
37869 wxPyEndAllowThreads(__tstate);
37870 if (PyErr_Occurred()) SWIG_fail;
37871 }
37872 Py_INCREF(Py_None); resultobj = Py_None;
37873 return resultobj;
37874 fail:
37875 return NULL;
37876 }
37877
37878
37879 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37880 PyObject *resultobj;
37881 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37882 wxSizer *result;
37883 PyObject * obj0 = 0 ;
37884 char *kwnames[] = {
37885 (char *) "self", NULL
37886 };
37887
37888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
37889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37890 if (SWIG_arg_fail(1)) SWIG_fail;
37891 {
37892 PyThreadState* __tstate = wxPyBeginAllowThreads();
37893 result = (wxSizer *)(arg1)->GetSizer();
37894
37895 wxPyEndAllowThreads(__tstate);
37896 if (PyErr_Occurred()) SWIG_fail;
37897 }
37898 {
37899 resultobj = wxPyMake_wxSizer(result, 0);
37900 }
37901 return resultobj;
37902 fail:
37903 return NULL;
37904 }
37905
37906
37907 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37908 PyObject *resultobj;
37909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37910 wxSizer *arg2 = (wxSizer *) 0 ;
37911 PyObject * obj0 = 0 ;
37912 PyObject * obj1 = 0 ;
37913 char *kwnames[] = {
37914 (char *) "self",(char *) "sizer", NULL
37915 };
37916
37917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
37918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37919 if (SWIG_arg_fail(1)) SWIG_fail;
37920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37921 if (SWIG_arg_fail(2)) SWIG_fail;
37922 {
37923 PyThreadState* __tstate = wxPyBeginAllowThreads();
37924 (arg1)->SetSizer(arg2);
37925
37926 wxPyEndAllowThreads(__tstate);
37927 if (PyErr_Occurred()) SWIG_fail;
37928 }
37929 Py_INCREF(Py_None); resultobj = Py_None;
37930 return resultobj;
37931 fail:
37932 return NULL;
37933 }
37934
37935
37936 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37937 PyObject *resultobj;
37938 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37939 wxSize *result;
37940 PyObject * obj0 = 0 ;
37941 char *kwnames[] = {
37942 (char *) "self", NULL
37943 };
37944
37945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
37946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37947 if (SWIG_arg_fail(1)) SWIG_fail;
37948 {
37949 PyThreadState* __tstate = wxPyBeginAllowThreads();
37950 {
37951 wxSize const &_result_ref = (arg1)->GetSpacer();
37952 result = (wxSize *) &_result_ref;
37953 }
37954
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
37959 return resultobj;
37960 fail:
37961 return NULL;
37962 }
37963
37964
37965 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37966 PyObject *resultobj;
37967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37968 wxSize *arg2 = 0 ;
37969 wxSize temp2 ;
37970 PyObject * obj0 = 0 ;
37971 PyObject * obj1 = 0 ;
37972 char *kwnames[] = {
37973 (char *) "self",(char *) "size", NULL
37974 };
37975
37976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
37977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37978 if (SWIG_arg_fail(1)) SWIG_fail;
37979 {
37980 arg2 = &temp2;
37981 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37982 }
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 (arg1)->SetSpacer((wxSize const &)*arg2);
37986
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 Py_INCREF(Py_None); resultobj = Py_None;
37991 return resultobj;
37992 fail:
37993 return NULL;
37994 }
37995
37996
37997 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
37998 PyObject *resultobj;
37999 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38000 bool arg2 ;
38001 PyObject * obj0 = 0 ;
38002 PyObject * obj1 = 0 ;
38003 char *kwnames[] = {
38004 (char *) "self",(char *) "show", NULL
38005 };
38006
38007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38009 if (SWIG_arg_fail(1)) SWIG_fail;
38010 {
38011 arg2 = (bool)(SWIG_As_bool(obj1));
38012 if (SWIG_arg_fail(2)) SWIG_fail;
38013 }
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 (arg1)->Show(arg2);
38017
38018 wxPyEndAllowThreads(__tstate);
38019 if (PyErr_Occurred()) SWIG_fail;
38020 }
38021 Py_INCREF(Py_None); resultobj = Py_None;
38022 return resultobj;
38023 fail:
38024 return NULL;
38025 }
38026
38027
38028 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38029 PyObject *resultobj;
38030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38031 bool result;
38032 PyObject * obj0 = 0 ;
38033 char *kwnames[] = {
38034 (char *) "self", NULL
38035 };
38036
38037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38039 if (SWIG_arg_fail(1)) SWIG_fail;
38040 {
38041 PyThreadState* __tstate = wxPyBeginAllowThreads();
38042 result = (bool)(arg1)->IsShown();
38043
38044 wxPyEndAllowThreads(__tstate);
38045 if (PyErr_Occurred()) SWIG_fail;
38046 }
38047 {
38048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38049 }
38050 return resultobj;
38051 fail:
38052 return NULL;
38053 }
38054
38055
38056 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38057 PyObject *resultobj;
38058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38059 wxPoint result;
38060 PyObject * obj0 = 0 ;
38061 char *kwnames[] = {
38062 (char *) "self", NULL
38063 };
38064
38065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38067 if (SWIG_arg_fail(1)) SWIG_fail;
38068 {
38069 PyThreadState* __tstate = wxPyBeginAllowThreads();
38070 result = (arg1)->GetPosition();
38071
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 {
38076 wxPoint * resultptr;
38077 resultptr = new wxPoint((wxPoint &)(result));
38078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38079 }
38080 return resultobj;
38081 fail:
38082 return NULL;
38083 }
38084
38085
38086 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38087 PyObject *resultobj;
38088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38089 PyObject *result;
38090 PyObject * obj0 = 0 ;
38091 char *kwnames[] = {
38092 (char *) "self", NULL
38093 };
38094
38095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38097 if (SWIG_arg_fail(1)) SWIG_fail;
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38101
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 resultobj = result;
38106 return resultobj;
38107 fail:
38108 return NULL;
38109 }
38110
38111
38112 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38113 PyObject *obj;
38114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38115 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38116 Py_INCREF(obj);
38117 return Py_BuildValue((char *)"");
38118 }
38119 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38120 PyObject *resultobj;
38121 wxSizer *arg1 = (wxSizer *) 0 ;
38122 PyObject *arg2 = (PyObject *) 0 ;
38123 PyObject * obj0 = 0 ;
38124 PyObject * obj1 = 0 ;
38125 char *kwnames[] = {
38126 (char *) "self",(char *) "_self", NULL
38127 };
38128
38129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38131 if (SWIG_arg_fail(1)) SWIG_fail;
38132 arg2 = obj1;
38133 {
38134 PyThreadState* __tstate = wxPyBeginAllowThreads();
38135 wxSizer__setOORInfo(arg1,arg2);
38136
38137 wxPyEndAllowThreads(__tstate);
38138 if (PyErr_Occurred()) SWIG_fail;
38139 }
38140 Py_INCREF(Py_None); resultobj = Py_None;
38141 return resultobj;
38142 fail:
38143 return NULL;
38144 }
38145
38146
38147 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38148 PyObject *resultobj;
38149 wxSizer *arg1 = (wxSizer *) 0 ;
38150 PyObject *arg2 = (PyObject *) 0 ;
38151 int arg3 = (int) 0 ;
38152 int arg4 = (int) 0 ;
38153 int arg5 = (int) 0 ;
38154 PyObject *arg6 = (PyObject *) NULL ;
38155 wxSizerItem *result;
38156 PyObject * obj0 = 0 ;
38157 PyObject * obj1 = 0 ;
38158 PyObject * obj2 = 0 ;
38159 PyObject * obj3 = 0 ;
38160 PyObject * obj4 = 0 ;
38161 PyObject * obj5 = 0 ;
38162 char *kwnames[] = {
38163 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38164 };
38165
38166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38168 if (SWIG_arg_fail(1)) SWIG_fail;
38169 arg2 = obj1;
38170 if (obj2) {
38171 {
38172 arg3 = (int)(SWIG_As_int(obj2));
38173 if (SWIG_arg_fail(3)) SWIG_fail;
38174 }
38175 }
38176 if (obj3) {
38177 {
38178 arg4 = (int)(SWIG_As_int(obj3));
38179 if (SWIG_arg_fail(4)) SWIG_fail;
38180 }
38181 }
38182 if (obj4) {
38183 {
38184 arg5 = (int)(SWIG_As_int(obj4));
38185 if (SWIG_arg_fail(5)) SWIG_fail;
38186 }
38187 }
38188 if (obj5) {
38189 arg6 = obj5;
38190 }
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38194
38195 wxPyEndAllowThreads(__tstate);
38196 if (PyErr_Occurred()) SWIG_fail;
38197 }
38198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38199 return resultobj;
38200 fail:
38201 return NULL;
38202 }
38203
38204
38205 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38206 PyObject *resultobj;
38207 wxSizer *arg1 = (wxSizer *) 0 ;
38208 int arg2 ;
38209 PyObject *arg3 = (PyObject *) 0 ;
38210 int arg4 = (int) 0 ;
38211 int arg5 = (int) 0 ;
38212 int arg6 = (int) 0 ;
38213 PyObject *arg7 = (PyObject *) NULL ;
38214 wxSizerItem *result;
38215 PyObject * obj0 = 0 ;
38216 PyObject * obj1 = 0 ;
38217 PyObject * obj2 = 0 ;
38218 PyObject * obj3 = 0 ;
38219 PyObject * obj4 = 0 ;
38220 PyObject * obj5 = 0 ;
38221 PyObject * obj6 = 0 ;
38222 char *kwnames[] = {
38223 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38224 };
38225
38226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38228 if (SWIG_arg_fail(1)) SWIG_fail;
38229 {
38230 arg2 = (int)(SWIG_As_int(obj1));
38231 if (SWIG_arg_fail(2)) SWIG_fail;
38232 }
38233 arg3 = obj2;
38234 if (obj3) {
38235 {
38236 arg4 = (int)(SWIG_As_int(obj3));
38237 if (SWIG_arg_fail(4)) SWIG_fail;
38238 }
38239 }
38240 if (obj4) {
38241 {
38242 arg5 = (int)(SWIG_As_int(obj4));
38243 if (SWIG_arg_fail(5)) SWIG_fail;
38244 }
38245 }
38246 if (obj5) {
38247 {
38248 arg6 = (int)(SWIG_As_int(obj5));
38249 if (SWIG_arg_fail(6)) SWIG_fail;
38250 }
38251 }
38252 if (obj6) {
38253 arg7 = obj6;
38254 }
38255 {
38256 PyThreadState* __tstate = wxPyBeginAllowThreads();
38257 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38258
38259 wxPyEndAllowThreads(__tstate);
38260 if (PyErr_Occurred()) SWIG_fail;
38261 }
38262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38263 return resultobj;
38264 fail:
38265 return NULL;
38266 }
38267
38268
38269 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38270 PyObject *resultobj;
38271 wxSizer *arg1 = (wxSizer *) 0 ;
38272 PyObject *arg2 = (PyObject *) 0 ;
38273 int arg3 = (int) 0 ;
38274 int arg4 = (int) 0 ;
38275 int arg5 = (int) 0 ;
38276 PyObject *arg6 = (PyObject *) NULL ;
38277 wxSizerItem *result;
38278 PyObject * obj0 = 0 ;
38279 PyObject * obj1 = 0 ;
38280 PyObject * obj2 = 0 ;
38281 PyObject * obj3 = 0 ;
38282 PyObject * obj4 = 0 ;
38283 PyObject * obj5 = 0 ;
38284 char *kwnames[] = {
38285 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38286 };
38287
38288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38290 if (SWIG_arg_fail(1)) SWIG_fail;
38291 arg2 = obj1;
38292 if (obj2) {
38293 {
38294 arg3 = (int)(SWIG_As_int(obj2));
38295 if (SWIG_arg_fail(3)) SWIG_fail;
38296 }
38297 }
38298 if (obj3) {
38299 {
38300 arg4 = (int)(SWIG_As_int(obj3));
38301 if (SWIG_arg_fail(4)) SWIG_fail;
38302 }
38303 }
38304 if (obj4) {
38305 {
38306 arg5 = (int)(SWIG_As_int(obj4));
38307 if (SWIG_arg_fail(5)) SWIG_fail;
38308 }
38309 }
38310 if (obj5) {
38311 arg6 = obj5;
38312 }
38313 {
38314 PyThreadState* __tstate = wxPyBeginAllowThreads();
38315 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38316
38317 wxPyEndAllowThreads(__tstate);
38318 if (PyErr_Occurred()) SWIG_fail;
38319 }
38320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38321 return resultobj;
38322 fail:
38323 return NULL;
38324 }
38325
38326
38327 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38328 PyObject *resultobj;
38329 wxSizer *arg1 = (wxSizer *) 0 ;
38330 PyObject *arg2 = (PyObject *) 0 ;
38331 bool result;
38332 PyObject * obj0 = 0 ;
38333 PyObject * obj1 = 0 ;
38334 char *kwnames[] = {
38335 (char *) "self",(char *) "item", NULL
38336 };
38337
38338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38340 if (SWIG_arg_fail(1)) SWIG_fail;
38341 arg2 = obj1;
38342 {
38343 PyThreadState* __tstate = wxPyBeginAllowThreads();
38344 result = (bool)wxSizer_Remove(arg1,arg2);
38345
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 {
38350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38351 }
38352 return resultobj;
38353 fail:
38354 return NULL;
38355 }
38356
38357
38358 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38359 PyObject *resultobj;
38360 wxSizer *arg1 = (wxSizer *) 0 ;
38361 PyObject *arg2 = (PyObject *) 0 ;
38362 bool result;
38363 PyObject * obj0 = 0 ;
38364 PyObject * obj1 = 0 ;
38365 char *kwnames[] = {
38366 (char *) "self",(char *) "item", NULL
38367 };
38368
38369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38371 if (SWIG_arg_fail(1)) SWIG_fail;
38372 arg2 = obj1;
38373 {
38374 PyThreadState* __tstate = wxPyBeginAllowThreads();
38375 result = (bool)wxSizer_Detach(arg1,arg2);
38376
38377 wxPyEndAllowThreads(__tstate);
38378 if (PyErr_Occurred()) SWIG_fail;
38379 }
38380 {
38381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38382 }
38383 return resultobj;
38384 fail:
38385 return NULL;
38386 }
38387
38388
38389 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38390 PyObject *resultobj;
38391 wxSizer *arg1 = (wxSizer *) 0 ;
38392 PyObject *arg2 = (PyObject *) 0 ;
38393 wxSizerItem *result;
38394 PyObject * obj0 = 0 ;
38395 PyObject * obj1 = 0 ;
38396 char *kwnames[] = {
38397 (char *) "self",(char *) "item", NULL
38398 };
38399
38400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38402 if (SWIG_arg_fail(1)) SWIG_fail;
38403 arg2 = obj1;
38404 {
38405 PyThreadState* __tstate = wxPyBeginAllowThreads();
38406 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38407
38408 wxPyEndAllowThreads(__tstate);
38409 if (PyErr_Occurred()) SWIG_fail;
38410 }
38411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38419 PyObject *resultobj;
38420 wxSizer *arg1 = (wxSizer *) 0 ;
38421 PyObject *arg2 = (PyObject *) 0 ;
38422 wxSize *arg3 = 0 ;
38423 wxSize temp3 ;
38424 PyObject * obj0 = 0 ;
38425 PyObject * obj1 = 0 ;
38426 PyObject * obj2 = 0 ;
38427 char *kwnames[] = {
38428 (char *) "self",(char *) "item",(char *) "size", NULL
38429 };
38430
38431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38433 if (SWIG_arg_fail(1)) SWIG_fail;
38434 arg2 = obj1;
38435 {
38436 arg3 = &temp3;
38437 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38438 }
38439 {
38440 PyThreadState* __tstate = wxPyBeginAllowThreads();
38441 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38442
38443 wxPyEndAllowThreads(__tstate);
38444 if (PyErr_Occurred()) SWIG_fail;
38445 }
38446 Py_INCREF(Py_None); resultobj = Py_None;
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj;
38455 wxSizer *arg1 = (wxSizer *) 0 ;
38456 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38457 wxSizerItem *result;
38458 PyObject * obj0 = 0 ;
38459 PyObject * obj1 = 0 ;
38460 char *kwnames[] = {
38461 (char *) "self",(char *) "item", NULL
38462 };
38463
38464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38466 if (SWIG_arg_fail(1)) SWIG_fail;
38467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38468 if (SWIG_arg_fail(2)) SWIG_fail;
38469 {
38470 PyThreadState* __tstate = wxPyBeginAllowThreads();
38471 result = (wxSizerItem *)(arg1)->Add(arg2);
38472
38473 wxPyEndAllowThreads(__tstate);
38474 if (PyErr_Occurred()) SWIG_fail;
38475 }
38476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38484 PyObject *resultobj;
38485 wxSizer *arg1 = (wxSizer *) 0 ;
38486 size_t arg2 ;
38487 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38488 wxSizerItem *result;
38489 PyObject * obj0 = 0 ;
38490 PyObject * obj1 = 0 ;
38491 PyObject * obj2 = 0 ;
38492 char *kwnames[] = {
38493 (char *) "self",(char *) "index",(char *) "item", NULL
38494 };
38495
38496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38498 if (SWIG_arg_fail(1)) SWIG_fail;
38499 {
38500 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38501 if (SWIG_arg_fail(2)) SWIG_fail;
38502 }
38503 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38504 if (SWIG_arg_fail(3)) SWIG_fail;
38505 {
38506 PyThreadState* __tstate = wxPyBeginAllowThreads();
38507 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38508
38509 wxPyEndAllowThreads(__tstate);
38510 if (PyErr_Occurred()) SWIG_fail;
38511 }
38512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38513 return resultobj;
38514 fail:
38515 return NULL;
38516 }
38517
38518
38519 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38520 PyObject *resultobj;
38521 wxSizer *arg1 = (wxSizer *) 0 ;
38522 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38523 wxSizerItem *result;
38524 PyObject * obj0 = 0 ;
38525 PyObject * obj1 = 0 ;
38526 char *kwnames[] = {
38527 (char *) "self",(char *) "item", NULL
38528 };
38529
38530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38532 if (SWIG_arg_fail(1)) SWIG_fail;
38533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38534 if (SWIG_arg_fail(2)) SWIG_fail;
38535 {
38536 PyThreadState* __tstate = wxPyBeginAllowThreads();
38537 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38538
38539 wxPyEndAllowThreads(__tstate);
38540 if (PyErr_Occurred()) SWIG_fail;
38541 }
38542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38543 return resultobj;
38544 fail:
38545 return NULL;
38546 }
38547
38548
38549 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38550 PyObject *resultobj;
38551 wxSizer *arg1 = (wxSizer *) 0 ;
38552 int arg2 ;
38553 int arg3 ;
38554 int arg4 ;
38555 int arg5 ;
38556 PyObject * obj0 = 0 ;
38557 PyObject * obj1 = 0 ;
38558 PyObject * obj2 = 0 ;
38559 PyObject * obj3 = 0 ;
38560 PyObject * obj4 = 0 ;
38561 char *kwnames[] = {
38562 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38563 };
38564
38565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38567 if (SWIG_arg_fail(1)) SWIG_fail;
38568 {
38569 arg2 = (int)(SWIG_As_int(obj1));
38570 if (SWIG_arg_fail(2)) SWIG_fail;
38571 }
38572 {
38573 arg3 = (int)(SWIG_As_int(obj2));
38574 if (SWIG_arg_fail(3)) SWIG_fail;
38575 }
38576 {
38577 arg4 = (int)(SWIG_As_int(obj3));
38578 if (SWIG_arg_fail(4)) SWIG_fail;
38579 }
38580 {
38581 arg5 = (int)(SWIG_As_int(obj4));
38582 if (SWIG_arg_fail(5)) SWIG_fail;
38583 }
38584 {
38585 PyThreadState* __tstate = wxPyBeginAllowThreads();
38586 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38587
38588 wxPyEndAllowThreads(__tstate);
38589 if (PyErr_Occurred()) SWIG_fail;
38590 }
38591 Py_INCREF(Py_None); resultobj = Py_None;
38592 return resultobj;
38593 fail:
38594 return NULL;
38595 }
38596
38597
38598 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38599 PyObject *resultobj;
38600 wxSizer *arg1 = (wxSizer *) 0 ;
38601 wxSize *arg2 = 0 ;
38602 wxSize temp2 ;
38603 PyObject * obj0 = 0 ;
38604 PyObject * obj1 = 0 ;
38605 char *kwnames[] = {
38606 (char *) "self",(char *) "size", NULL
38607 };
38608
38609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38611 if (SWIG_arg_fail(1)) SWIG_fail;
38612 {
38613 arg2 = &temp2;
38614 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38615 }
38616 {
38617 PyThreadState* __tstate = wxPyBeginAllowThreads();
38618 (arg1)->SetMinSize((wxSize const &)*arg2);
38619
38620 wxPyEndAllowThreads(__tstate);
38621 if (PyErr_Occurred()) SWIG_fail;
38622 }
38623 Py_INCREF(Py_None); resultobj = Py_None;
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38631 PyObject *resultobj;
38632 wxSizer *arg1 = (wxSizer *) 0 ;
38633 wxSize result;
38634 PyObject * obj0 = 0 ;
38635 char *kwnames[] = {
38636 (char *) "self", NULL
38637 };
38638
38639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38641 if (SWIG_arg_fail(1)) SWIG_fail;
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 result = (arg1)->GetSize();
38645
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 {
38650 wxSize * resultptr;
38651 resultptr = new wxSize((wxSize &)(result));
38652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38653 }
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj;
38662 wxSizer *arg1 = (wxSizer *) 0 ;
38663 wxPoint result;
38664 PyObject * obj0 = 0 ;
38665 char *kwnames[] = {
38666 (char *) "self", NULL
38667 };
38668
38669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38671 if (SWIG_arg_fail(1)) SWIG_fail;
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 result = (arg1)->GetPosition();
38675
38676 wxPyEndAllowThreads(__tstate);
38677 if (PyErr_Occurred()) SWIG_fail;
38678 }
38679 {
38680 wxPoint * resultptr;
38681 resultptr = new wxPoint((wxPoint &)(result));
38682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38683 }
38684 return resultobj;
38685 fail:
38686 return NULL;
38687 }
38688
38689
38690 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38691 PyObject *resultobj;
38692 wxSizer *arg1 = (wxSizer *) 0 ;
38693 wxSize result;
38694 PyObject * obj0 = 0 ;
38695 char *kwnames[] = {
38696 (char *) "self", NULL
38697 };
38698
38699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38701 if (SWIG_arg_fail(1)) SWIG_fail;
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 result = (arg1)->GetMinSize();
38705
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 {
38710 wxSize * resultptr;
38711 resultptr = new wxSize((wxSize &)(result));
38712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38713 }
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj;
38722 wxSizer *arg1 = (wxSizer *) 0 ;
38723 PyObject * obj0 = 0 ;
38724 char *kwnames[] = {
38725 (char *) "self", NULL
38726 };
38727
38728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
38729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38730 if (SWIG_arg_fail(1)) SWIG_fail;
38731 {
38732 PyThreadState* __tstate = wxPyBeginAllowThreads();
38733 (arg1)->RecalcSizes();
38734
38735 wxPyEndAllowThreads(__tstate);
38736 if (PyErr_Occurred()) SWIG_fail;
38737 }
38738 Py_INCREF(Py_None); resultobj = Py_None;
38739 return resultobj;
38740 fail:
38741 return NULL;
38742 }
38743
38744
38745 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38746 PyObject *resultobj;
38747 wxSizer *arg1 = (wxSizer *) 0 ;
38748 wxSize result;
38749 PyObject * obj0 = 0 ;
38750 char *kwnames[] = {
38751 (char *) "self", NULL
38752 };
38753
38754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
38755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38756 if (SWIG_arg_fail(1)) SWIG_fail;
38757 {
38758 PyThreadState* __tstate = wxPyBeginAllowThreads();
38759 result = (arg1)->CalcMin();
38760
38761 wxPyEndAllowThreads(__tstate);
38762 if (PyErr_Occurred()) SWIG_fail;
38763 }
38764 {
38765 wxSize * resultptr;
38766 resultptr = new wxSize((wxSize &)(result));
38767 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38768 }
38769 return resultobj;
38770 fail:
38771 return NULL;
38772 }
38773
38774
38775 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
38776 PyObject *resultobj;
38777 wxSizer *arg1 = (wxSizer *) 0 ;
38778 PyObject * obj0 = 0 ;
38779 char *kwnames[] = {
38780 (char *) "self", NULL
38781 };
38782
38783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
38784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38785 if (SWIG_arg_fail(1)) SWIG_fail;
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 (arg1)->Layout();
38789
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 Py_INCREF(Py_None); resultobj = Py_None;
38794 return resultobj;
38795 fail:
38796 return NULL;
38797 }
38798
38799
38800 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
38801 PyObject *resultobj;
38802 wxSizer *arg1 = (wxSizer *) 0 ;
38803 wxWindow *arg2 = (wxWindow *) 0 ;
38804 wxSize result;
38805 PyObject * obj0 = 0 ;
38806 PyObject * obj1 = 0 ;
38807 char *kwnames[] = {
38808 (char *) "self",(char *) "window", NULL
38809 };
38810
38811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
38812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38813 if (SWIG_arg_fail(1)) SWIG_fail;
38814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38815 if (SWIG_arg_fail(2)) SWIG_fail;
38816 {
38817 PyThreadState* __tstate = wxPyBeginAllowThreads();
38818 result = (arg1)->Fit(arg2);
38819
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 {
38824 wxSize * resultptr;
38825 resultptr = new wxSize((wxSize &)(result));
38826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38827 }
38828 return resultobj;
38829 fail:
38830 return NULL;
38831 }
38832
38833
38834 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
38835 PyObject *resultobj;
38836 wxSizer *arg1 = (wxSizer *) 0 ;
38837 wxWindow *arg2 = (wxWindow *) 0 ;
38838 PyObject * obj0 = 0 ;
38839 PyObject * obj1 = 0 ;
38840 char *kwnames[] = {
38841 (char *) "self",(char *) "window", NULL
38842 };
38843
38844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
38845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38846 if (SWIG_arg_fail(1)) SWIG_fail;
38847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38848 if (SWIG_arg_fail(2)) SWIG_fail;
38849 {
38850 PyThreadState* __tstate = wxPyBeginAllowThreads();
38851 (arg1)->FitInside(arg2);
38852
38853 wxPyEndAllowThreads(__tstate);
38854 if (PyErr_Occurred()) SWIG_fail;
38855 }
38856 Py_INCREF(Py_None); resultobj = Py_None;
38857 return resultobj;
38858 fail:
38859 return NULL;
38860 }
38861
38862
38863 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38864 PyObject *resultobj;
38865 wxSizer *arg1 = (wxSizer *) 0 ;
38866 wxWindow *arg2 = (wxWindow *) 0 ;
38867 PyObject * obj0 = 0 ;
38868 PyObject * obj1 = 0 ;
38869 char *kwnames[] = {
38870 (char *) "self",(char *) "window", NULL
38871 };
38872
38873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
38874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38875 if (SWIG_arg_fail(1)) SWIG_fail;
38876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38877 if (SWIG_arg_fail(2)) SWIG_fail;
38878 {
38879 PyThreadState* __tstate = wxPyBeginAllowThreads();
38880 (arg1)->SetSizeHints(arg2);
38881
38882 wxPyEndAllowThreads(__tstate);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 }
38885 Py_INCREF(Py_None); resultobj = Py_None;
38886 return resultobj;
38887 fail:
38888 return NULL;
38889 }
38890
38891
38892 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38893 PyObject *resultobj;
38894 wxSizer *arg1 = (wxSizer *) 0 ;
38895 wxWindow *arg2 = (wxWindow *) 0 ;
38896 PyObject * obj0 = 0 ;
38897 PyObject * obj1 = 0 ;
38898 char *kwnames[] = {
38899 (char *) "self",(char *) "window", NULL
38900 };
38901
38902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
38903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38904 if (SWIG_arg_fail(1)) SWIG_fail;
38905 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38906 if (SWIG_arg_fail(2)) SWIG_fail;
38907 {
38908 PyThreadState* __tstate = wxPyBeginAllowThreads();
38909 (arg1)->SetVirtualSizeHints(arg2);
38910
38911 wxPyEndAllowThreads(__tstate);
38912 if (PyErr_Occurred()) SWIG_fail;
38913 }
38914 Py_INCREF(Py_None); resultobj = Py_None;
38915 return resultobj;
38916 fail:
38917 return NULL;
38918 }
38919
38920
38921 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38922 PyObject *resultobj;
38923 wxSizer *arg1 = (wxSizer *) 0 ;
38924 bool arg2 = (bool) false ;
38925 PyObject * obj0 = 0 ;
38926 PyObject * obj1 = 0 ;
38927 char *kwnames[] = {
38928 (char *) "self",(char *) "deleteWindows", NULL
38929 };
38930
38931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
38932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38933 if (SWIG_arg_fail(1)) SWIG_fail;
38934 if (obj1) {
38935 {
38936 arg2 = (bool)(SWIG_As_bool(obj1));
38937 if (SWIG_arg_fail(2)) SWIG_fail;
38938 }
38939 }
38940 {
38941 PyThreadState* __tstate = wxPyBeginAllowThreads();
38942 (arg1)->Clear(arg2);
38943
38944 wxPyEndAllowThreads(__tstate);
38945 if (PyErr_Occurred()) SWIG_fail;
38946 }
38947 Py_INCREF(Py_None); resultobj = Py_None;
38948 return resultobj;
38949 fail:
38950 return NULL;
38951 }
38952
38953
38954 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38955 PyObject *resultobj;
38956 wxSizer *arg1 = (wxSizer *) 0 ;
38957 PyObject * obj0 = 0 ;
38958 char *kwnames[] = {
38959 (char *) "self", NULL
38960 };
38961
38962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
38963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38964 if (SWIG_arg_fail(1)) SWIG_fail;
38965 {
38966 PyThreadState* __tstate = wxPyBeginAllowThreads();
38967 (arg1)->DeleteWindows();
38968
38969 wxPyEndAllowThreads(__tstate);
38970 if (PyErr_Occurred()) SWIG_fail;
38971 }
38972 Py_INCREF(Py_None); resultobj = Py_None;
38973 return resultobj;
38974 fail:
38975 return NULL;
38976 }
38977
38978
38979 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
38980 PyObject *resultobj;
38981 wxSizer *arg1 = (wxSizer *) 0 ;
38982 PyObject *result;
38983 PyObject * obj0 = 0 ;
38984 char *kwnames[] = {
38985 (char *) "self", NULL
38986 };
38987
38988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
38989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38990 if (SWIG_arg_fail(1)) SWIG_fail;
38991 {
38992 PyThreadState* __tstate = wxPyBeginAllowThreads();
38993 result = (PyObject *)wxSizer_GetChildren(arg1);
38994
38995 wxPyEndAllowThreads(__tstate);
38996 if (PyErr_Occurred()) SWIG_fail;
38997 }
38998 resultobj = result;
38999 return resultobj;
39000 fail:
39001 return NULL;
39002 }
39003
39004
39005 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39006 PyObject *resultobj;
39007 wxSizer *arg1 = (wxSizer *) 0 ;
39008 PyObject *arg2 = (PyObject *) 0 ;
39009 bool arg3 = (bool) true ;
39010 bool arg4 = (bool) false ;
39011 bool result;
39012 PyObject * obj0 = 0 ;
39013 PyObject * obj1 = 0 ;
39014 PyObject * obj2 = 0 ;
39015 PyObject * obj3 = 0 ;
39016 char *kwnames[] = {
39017 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39018 };
39019
39020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39022 if (SWIG_arg_fail(1)) SWIG_fail;
39023 arg2 = obj1;
39024 if (obj2) {
39025 {
39026 arg3 = (bool)(SWIG_As_bool(obj2));
39027 if (SWIG_arg_fail(3)) SWIG_fail;
39028 }
39029 }
39030 if (obj3) {
39031 {
39032 arg4 = (bool)(SWIG_As_bool(obj3));
39033 if (SWIG_arg_fail(4)) SWIG_fail;
39034 }
39035 }
39036 {
39037 PyThreadState* __tstate = wxPyBeginAllowThreads();
39038 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39039
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 {
39044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39045 }
39046 return resultobj;
39047 fail:
39048 return NULL;
39049 }
39050
39051
39052 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39053 PyObject *resultobj;
39054 wxSizer *arg1 = (wxSizer *) 0 ;
39055 PyObject *arg2 = (PyObject *) 0 ;
39056 bool result;
39057 PyObject * obj0 = 0 ;
39058 PyObject * obj1 = 0 ;
39059 char *kwnames[] = {
39060 (char *) "self",(char *) "item", NULL
39061 };
39062
39063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39065 if (SWIG_arg_fail(1)) SWIG_fail;
39066 arg2 = obj1;
39067 {
39068 PyThreadState* __tstate = wxPyBeginAllowThreads();
39069 result = (bool)wxSizer_IsShown(arg1,arg2);
39070
39071 wxPyEndAllowThreads(__tstate);
39072 if (PyErr_Occurred()) SWIG_fail;
39073 }
39074 {
39075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39076 }
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj;
39085 wxSizer *arg1 = (wxSizer *) 0 ;
39086 bool arg2 ;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 char *kwnames[] = {
39090 (char *) "self",(char *) "show", NULL
39091 };
39092
39093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39095 if (SWIG_arg_fail(1)) SWIG_fail;
39096 {
39097 arg2 = (bool)(SWIG_As_bool(obj1));
39098 if (SWIG_arg_fail(2)) SWIG_fail;
39099 }
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 (arg1)->ShowItems(arg2);
39103
39104 wxPyEndAllowThreads(__tstate);
39105 if (PyErr_Occurred()) SWIG_fail;
39106 }
39107 Py_INCREF(Py_None); resultobj = Py_None;
39108 return resultobj;
39109 fail:
39110 return NULL;
39111 }
39112
39113
39114 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39115 PyObject *obj;
39116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39117 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39118 Py_INCREF(obj);
39119 return Py_BuildValue((char *)"");
39120 }
39121 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj;
39123 wxPySizer *result;
39124 char *kwnames[] = {
39125 NULL
39126 };
39127
39128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 result = (wxPySizer *)new wxPySizer();
39132
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj;
39145 wxPySizer *arg1 = (wxPySizer *) 0 ;
39146 PyObject *arg2 = (PyObject *) 0 ;
39147 PyObject *arg3 = (PyObject *) 0 ;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 PyObject * obj2 = 0 ;
39151 char *kwnames[] = {
39152 (char *) "self",(char *) "self",(char *) "_class", NULL
39153 };
39154
39155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39157 if (SWIG_arg_fail(1)) SWIG_fail;
39158 arg2 = obj1;
39159 arg3 = obj2;
39160 {
39161 PyThreadState* __tstate = wxPyBeginAllowThreads();
39162 (arg1)->_setCallbackInfo(arg2,arg3);
39163
39164 wxPyEndAllowThreads(__tstate);
39165 if (PyErr_Occurred()) SWIG_fail;
39166 }
39167 Py_INCREF(Py_None); resultobj = Py_None;
39168 return resultobj;
39169 fail:
39170 return NULL;
39171 }
39172
39173
39174 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39175 PyObject *obj;
39176 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39177 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39178 Py_INCREF(obj);
39179 return Py_BuildValue((char *)"");
39180 }
39181 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39182 PyObject *resultobj;
39183 int arg1 = (int) wxHORIZONTAL ;
39184 wxBoxSizer *result;
39185 PyObject * obj0 = 0 ;
39186 char *kwnames[] = {
39187 (char *) "orient", NULL
39188 };
39189
39190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39191 if (obj0) {
39192 {
39193 arg1 = (int)(SWIG_As_int(obj0));
39194 if (SWIG_arg_fail(1)) SWIG_fail;
39195 }
39196 }
39197 {
39198 PyThreadState* __tstate = wxPyBeginAllowThreads();
39199 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39200
39201 wxPyEndAllowThreads(__tstate);
39202 if (PyErr_Occurred()) SWIG_fail;
39203 }
39204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39205 return resultobj;
39206 fail:
39207 return NULL;
39208 }
39209
39210
39211 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39212 PyObject *resultobj;
39213 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39214 int result;
39215 PyObject * obj0 = 0 ;
39216 char *kwnames[] = {
39217 (char *) "self", NULL
39218 };
39219
39220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39222 if (SWIG_arg_fail(1)) SWIG_fail;
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 result = (int)(arg1)->GetOrientation();
39226
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 {
39231 resultobj = SWIG_From_int((int)(result));
39232 }
39233 return resultobj;
39234 fail:
39235 return NULL;
39236 }
39237
39238
39239 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39240 PyObject *resultobj;
39241 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39242 int arg2 ;
39243 PyObject * obj0 = 0 ;
39244 PyObject * obj1 = 0 ;
39245 char *kwnames[] = {
39246 (char *) "self",(char *) "orient", NULL
39247 };
39248
39249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39251 if (SWIG_arg_fail(1)) SWIG_fail;
39252 {
39253 arg2 = (int)(SWIG_As_int(obj1));
39254 if (SWIG_arg_fail(2)) SWIG_fail;
39255 }
39256 {
39257 PyThreadState* __tstate = wxPyBeginAllowThreads();
39258 (arg1)->SetOrientation(arg2);
39259
39260 wxPyEndAllowThreads(__tstate);
39261 if (PyErr_Occurred()) SWIG_fail;
39262 }
39263 Py_INCREF(Py_None); resultobj = Py_None;
39264 return resultobj;
39265 fail:
39266 return NULL;
39267 }
39268
39269
39270 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39271 PyObject *obj;
39272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39273 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39274 Py_INCREF(obj);
39275 return Py_BuildValue((char *)"");
39276 }
39277 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39278 PyObject *resultobj;
39279 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39280 int arg2 = (int) wxHORIZONTAL ;
39281 wxStaticBoxSizer *result;
39282 PyObject * obj0 = 0 ;
39283 PyObject * obj1 = 0 ;
39284 char *kwnames[] = {
39285 (char *) "box",(char *) "orient", NULL
39286 };
39287
39288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39290 if (SWIG_arg_fail(1)) SWIG_fail;
39291 if (obj1) {
39292 {
39293 arg2 = (int)(SWIG_As_int(obj1));
39294 if (SWIG_arg_fail(2)) SWIG_fail;
39295 }
39296 }
39297 {
39298 PyThreadState* __tstate = wxPyBeginAllowThreads();
39299 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39300
39301 wxPyEndAllowThreads(__tstate);
39302 if (PyErr_Occurred()) SWIG_fail;
39303 }
39304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39305 return resultobj;
39306 fail:
39307 return NULL;
39308 }
39309
39310
39311 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39312 PyObject *resultobj;
39313 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39314 wxStaticBox *result;
39315 PyObject * obj0 = 0 ;
39316 char *kwnames[] = {
39317 (char *) "self", NULL
39318 };
39319
39320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39322 if (SWIG_arg_fail(1)) SWIG_fail;
39323 {
39324 PyThreadState* __tstate = wxPyBeginAllowThreads();
39325 result = (wxStaticBox *)(arg1)->GetStaticBox();
39326
39327 wxPyEndAllowThreads(__tstate);
39328 if (PyErr_Occurred()) SWIG_fail;
39329 }
39330 {
39331 resultobj = wxPyMake_wxObject(result, 0);
39332 }
39333 return resultobj;
39334 fail:
39335 return NULL;
39336 }
39337
39338
39339 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39340 PyObject *obj;
39341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39342 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39343 Py_INCREF(obj);
39344 return Py_BuildValue((char *)"");
39345 }
39346 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39347 PyObject *resultobj;
39348 int arg1 = (int) 1 ;
39349 int arg2 = (int) 0 ;
39350 int arg3 = (int) 0 ;
39351 int arg4 = (int) 0 ;
39352 wxGridSizer *result;
39353 PyObject * obj0 = 0 ;
39354 PyObject * obj1 = 0 ;
39355 PyObject * obj2 = 0 ;
39356 PyObject * obj3 = 0 ;
39357 char *kwnames[] = {
39358 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39359 };
39360
39361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39362 if (obj0) {
39363 {
39364 arg1 = (int)(SWIG_As_int(obj0));
39365 if (SWIG_arg_fail(1)) SWIG_fail;
39366 }
39367 }
39368 if (obj1) {
39369 {
39370 arg2 = (int)(SWIG_As_int(obj1));
39371 if (SWIG_arg_fail(2)) SWIG_fail;
39372 }
39373 }
39374 if (obj2) {
39375 {
39376 arg3 = (int)(SWIG_As_int(obj2));
39377 if (SWIG_arg_fail(3)) SWIG_fail;
39378 }
39379 }
39380 if (obj3) {
39381 {
39382 arg4 = (int)(SWIG_As_int(obj3));
39383 if (SWIG_arg_fail(4)) SWIG_fail;
39384 }
39385 }
39386 {
39387 PyThreadState* __tstate = wxPyBeginAllowThreads();
39388 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39389
39390 wxPyEndAllowThreads(__tstate);
39391 if (PyErr_Occurred()) SWIG_fail;
39392 }
39393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39394 return resultobj;
39395 fail:
39396 return NULL;
39397 }
39398
39399
39400 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39401 PyObject *resultobj;
39402 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39403 int arg2 ;
39404 PyObject * obj0 = 0 ;
39405 PyObject * obj1 = 0 ;
39406 char *kwnames[] = {
39407 (char *) "self",(char *) "cols", NULL
39408 };
39409
39410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39412 if (SWIG_arg_fail(1)) SWIG_fail;
39413 {
39414 arg2 = (int)(SWIG_As_int(obj1));
39415 if (SWIG_arg_fail(2)) SWIG_fail;
39416 }
39417 {
39418 PyThreadState* __tstate = wxPyBeginAllowThreads();
39419 (arg1)->SetCols(arg2);
39420
39421 wxPyEndAllowThreads(__tstate);
39422 if (PyErr_Occurred()) SWIG_fail;
39423 }
39424 Py_INCREF(Py_None); resultobj = Py_None;
39425 return resultobj;
39426 fail:
39427 return NULL;
39428 }
39429
39430
39431 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39432 PyObject *resultobj;
39433 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39434 int arg2 ;
39435 PyObject * obj0 = 0 ;
39436 PyObject * obj1 = 0 ;
39437 char *kwnames[] = {
39438 (char *) "self",(char *) "rows", NULL
39439 };
39440
39441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39443 if (SWIG_arg_fail(1)) SWIG_fail;
39444 {
39445 arg2 = (int)(SWIG_As_int(obj1));
39446 if (SWIG_arg_fail(2)) SWIG_fail;
39447 }
39448 {
39449 PyThreadState* __tstate = wxPyBeginAllowThreads();
39450 (arg1)->SetRows(arg2);
39451
39452 wxPyEndAllowThreads(__tstate);
39453 if (PyErr_Occurred()) SWIG_fail;
39454 }
39455 Py_INCREF(Py_None); resultobj = Py_None;
39456 return resultobj;
39457 fail:
39458 return NULL;
39459 }
39460
39461
39462 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj;
39464 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39465 int arg2 ;
39466 PyObject * obj0 = 0 ;
39467 PyObject * obj1 = 0 ;
39468 char *kwnames[] = {
39469 (char *) "self",(char *) "gap", NULL
39470 };
39471
39472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39474 if (SWIG_arg_fail(1)) SWIG_fail;
39475 {
39476 arg2 = (int)(SWIG_As_int(obj1));
39477 if (SWIG_arg_fail(2)) SWIG_fail;
39478 }
39479 {
39480 PyThreadState* __tstate = wxPyBeginAllowThreads();
39481 (arg1)->SetVGap(arg2);
39482
39483 wxPyEndAllowThreads(__tstate);
39484 if (PyErr_Occurred()) SWIG_fail;
39485 }
39486 Py_INCREF(Py_None); resultobj = Py_None;
39487 return resultobj;
39488 fail:
39489 return NULL;
39490 }
39491
39492
39493 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39494 PyObject *resultobj;
39495 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39496 int arg2 ;
39497 PyObject * obj0 = 0 ;
39498 PyObject * obj1 = 0 ;
39499 char *kwnames[] = {
39500 (char *) "self",(char *) "gap", NULL
39501 };
39502
39503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39505 if (SWIG_arg_fail(1)) SWIG_fail;
39506 {
39507 arg2 = (int)(SWIG_As_int(obj1));
39508 if (SWIG_arg_fail(2)) SWIG_fail;
39509 }
39510 {
39511 PyThreadState* __tstate = wxPyBeginAllowThreads();
39512 (arg1)->SetHGap(arg2);
39513
39514 wxPyEndAllowThreads(__tstate);
39515 if (PyErr_Occurred()) SWIG_fail;
39516 }
39517 Py_INCREF(Py_None); resultobj = Py_None;
39518 return resultobj;
39519 fail:
39520 return NULL;
39521 }
39522
39523
39524 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39525 PyObject *resultobj;
39526 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39527 int result;
39528 PyObject * obj0 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (int)(arg1)->GetCols();
39539
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 {
39544 resultobj = SWIG_From_int((int)(result));
39545 }
39546 return resultobj;
39547 fail:
39548 return NULL;
39549 }
39550
39551
39552 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39553 PyObject *resultobj;
39554 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39555 int result;
39556 PyObject * obj0 = 0 ;
39557 char *kwnames[] = {
39558 (char *) "self", NULL
39559 };
39560
39561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39563 if (SWIG_arg_fail(1)) SWIG_fail;
39564 {
39565 PyThreadState* __tstate = wxPyBeginAllowThreads();
39566 result = (int)(arg1)->GetRows();
39567
39568 wxPyEndAllowThreads(__tstate);
39569 if (PyErr_Occurred()) SWIG_fail;
39570 }
39571 {
39572 resultobj = SWIG_From_int((int)(result));
39573 }
39574 return resultobj;
39575 fail:
39576 return NULL;
39577 }
39578
39579
39580 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39581 PyObject *resultobj;
39582 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39583 int result;
39584 PyObject * obj0 = 0 ;
39585 char *kwnames[] = {
39586 (char *) "self", NULL
39587 };
39588
39589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39591 if (SWIG_arg_fail(1)) SWIG_fail;
39592 {
39593 PyThreadState* __tstate = wxPyBeginAllowThreads();
39594 result = (int)(arg1)->GetVGap();
39595
39596 wxPyEndAllowThreads(__tstate);
39597 if (PyErr_Occurred()) SWIG_fail;
39598 }
39599 {
39600 resultobj = SWIG_From_int((int)(result));
39601 }
39602 return resultobj;
39603 fail:
39604 return NULL;
39605 }
39606
39607
39608 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39609 PyObject *resultobj;
39610 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39611 int result;
39612 PyObject * obj0 = 0 ;
39613 char *kwnames[] = {
39614 (char *) "self", NULL
39615 };
39616
39617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39619 if (SWIG_arg_fail(1)) SWIG_fail;
39620 {
39621 PyThreadState* __tstate = wxPyBeginAllowThreads();
39622 result = (int)(arg1)->GetHGap();
39623
39624 wxPyEndAllowThreads(__tstate);
39625 if (PyErr_Occurred()) SWIG_fail;
39626 }
39627 {
39628 resultobj = SWIG_From_int((int)(result));
39629 }
39630 return resultobj;
39631 fail:
39632 return NULL;
39633 }
39634
39635
39636 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39637 PyObject *obj;
39638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39639 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39640 Py_INCREF(obj);
39641 return Py_BuildValue((char *)"");
39642 }
39643 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39644 PyObject *resultobj;
39645 int arg1 = (int) 1 ;
39646 int arg2 = (int) 0 ;
39647 int arg3 = (int) 0 ;
39648 int arg4 = (int) 0 ;
39649 wxFlexGridSizer *result;
39650 PyObject * obj0 = 0 ;
39651 PyObject * obj1 = 0 ;
39652 PyObject * obj2 = 0 ;
39653 PyObject * obj3 = 0 ;
39654 char *kwnames[] = {
39655 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39656 };
39657
39658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39659 if (obj0) {
39660 {
39661 arg1 = (int)(SWIG_As_int(obj0));
39662 if (SWIG_arg_fail(1)) SWIG_fail;
39663 }
39664 }
39665 if (obj1) {
39666 {
39667 arg2 = (int)(SWIG_As_int(obj1));
39668 if (SWIG_arg_fail(2)) SWIG_fail;
39669 }
39670 }
39671 if (obj2) {
39672 {
39673 arg3 = (int)(SWIG_As_int(obj2));
39674 if (SWIG_arg_fail(3)) SWIG_fail;
39675 }
39676 }
39677 if (obj3) {
39678 {
39679 arg4 = (int)(SWIG_As_int(obj3));
39680 if (SWIG_arg_fail(4)) SWIG_fail;
39681 }
39682 }
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39686
39687 wxPyEndAllowThreads(__tstate);
39688 if (PyErr_Occurred()) SWIG_fail;
39689 }
39690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj;
39699 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39700 size_t arg2 ;
39701 int arg3 = (int) 0 ;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 PyObject * obj2 = 0 ;
39705 char *kwnames[] = {
39706 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39707 };
39708
39709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39711 if (SWIG_arg_fail(1)) SWIG_fail;
39712 {
39713 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39714 if (SWIG_arg_fail(2)) SWIG_fail;
39715 }
39716 if (obj2) {
39717 {
39718 arg3 = (int)(SWIG_As_int(obj2));
39719 if (SWIG_arg_fail(3)) SWIG_fail;
39720 }
39721 }
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 (arg1)->AddGrowableRow(arg2,arg3);
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_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj;
39738 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39739 size_t arg2 ;
39740 PyObject * obj0 = 0 ;
39741 PyObject * obj1 = 0 ;
39742 char *kwnames[] = {
39743 (char *) "self",(char *) "idx", NULL
39744 };
39745
39746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
39747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39748 if (SWIG_arg_fail(1)) SWIG_fail;
39749 {
39750 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39751 if (SWIG_arg_fail(2)) SWIG_fail;
39752 }
39753 {
39754 PyThreadState* __tstate = wxPyBeginAllowThreads();
39755 (arg1)->RemoveGrowableRow(arg2);
39756
39757 wxPyEndAllowThreads(__tstate);
39758 if (PyErr_Occurred()) SWIG_fail;
39759 }
39760 Py_INCREF(Py_None); resultobj = Py_None;
39761 return resultobj;
39762 fail:
39763 return NULL;
39764 }
39765
39766
39767 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39768 PyObject *resultobj;
39769 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39770 size_t arg2 ;
39771 int arg3 = (int) 0 ;
39772 PyObject * obj0 = 0 ;
39773 PyObject * obj1 = 0 ;
39774 PyObject * obj2 = 0 ;
39775 char *kwnames[] = {
39776 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39777 };
39778
39779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
39780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39781 if (SWIG_arg_fail(1)) SWIG_fail;
39782 {
39783 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39784 if (SWIG_arg_fail(2)) SWIG_fail;
39785 }
39786 if (obj2) {
39787 {
39788 arg3 = (int)(SWIG_As_int(obj2));
39789 if (SWIG_arg_fail(3)) SWIG_fail;
39790 }
39791 }
39792 {
39793 PyThreadState* __tstate = wxPyBeginAllowThreads();
39794 (arg1)->AddGrowableCol(arg2,arg3);
39795
39796 wxPyEndAllowThreads(__tstate);
39797 if (PyErr_Occurred()) SWIG_fail;
39798 }
39799 Py_INCREF(Py_None); resultobj = Py_None;
39800 return resultobj;
39801 fail:
39802 return NULL;
39803 }
39804
39805
39806 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39807 PyObject *resultobj;
39808 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39809 size_t arg2 ;
39810 PyObject * obj0 = 0 ;
39811 PyObject * obj1 = 0 ;
39812 char *kwnames[] = {
39813 (char *) "self",(char *) "idx", NULL
39814 };
39815
39816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
39817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39818 if (SWIG_arg_fail(1)) SWIG_fail;
39819 {
39820 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39821 if (SWIG_arg_fail(2)) SWIG_fail;
39822 }
39823 {
39824 PyThreadState* __tstate = wxPyBeginAllowThreads();
39825 (arg1)->RemoveGrowableCol(arg2);
39826
39827 wxPyEndAllowThreads(__tstate);
39828 if (PyErr_Occurred()) SWIG_fail;
39829 }
39830 Py_INCREF(Py_None); resultobj = Py_None;
39831 return resultobj;
39832 fail:
39833 return NULL;
39834 }
39835
39836
39837 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39838 PyObject *resultobj;
39839 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39840 int arg2 ;
39841 PyObject * obj0 = 0 ;
39842 PyObject * obj1 = 0 ;
39843 char *kwnames[] = {
39844 (char *) "self",(char *) "direction", NULL
39845 };
39846
39847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
39848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39849 if (SWIG_arg_fail(1)) SWIG_fail;
39850 {
39851 arg2 = (int)(SWIG_As_int(obj1));
39852 if (SWIG_arg_fail(2)) SWIG_fail;
39853 }
39854 {
39855 PyThreadState* __tstate = wxPyBeginAllowThreads();
39856 (arg1)->SetFlexibleDirection(arg2);
39857
39858 wxPyEndAllowThreads(__tstate);
39859 if (PyErr_Occurred()) SWIG_fail;
39860 }
39861 Py_INCREF(Py_None); resultobj = Py_None;
39862 return resultobj;
39863 fail:
39864 return NULL;
39865 }
39866
39867
39868 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39869 PyObject *resultobj;
39870 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39871 int result;
39872 PyObject * obj0 = 0 ;
39873 char *kwnames[] = {
39874 (char *) "self", NULL
39875 };
39876
39877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
39878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39879 if (SWIG_arg_fail(1)) SWIG_fail;
39880 {
39881 PyThreadState* __tstate = wxPyBeginAllowThreads();
39882 result = (int)(arg1)->GetFlexibleDirection();
39883
39884 wxPyEndAllowThreads(__tstate);
39885 if (PyErr_Occurred()) SWIG_fail;
39886 }
39887 {
39888 resultobj = SWIG_From_int((int)(result));
39889 }
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39897 PyObject *resultobj;
39898 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39899 wxFlexSizerGrowMode arg2 ;
39900 PyObject * obj0 = 0 ;
39901 PyObject * obj1 = 0 ;
39902 char *kwnames[] = {
39903 (char *) "self",(char *) "mode", NULL
39904 };
39905
39906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
39907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(1)) SWIG_fail;
39909 {
39910 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
39911 if (SWIG_arg_fail(2)) SWIG_fail;
39912 }
39913 {
39914 PyThreadState* __tstate = wxPyBeginAllowThreads();
39915 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
39916
39917 wxPyEndAllowThreads(__tstate);
39918 if (PyErr_Occurred()) SWIG_fail;
39919 }
39920 Py_INCREF(Py_None); resultobj = Py_None;
39921 return resultobj;
39922 fail:
39923 return NULL;
39924 }
39925
39926
39927 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39928 PyObject *resultobj;
39929 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39930 wxFlexSizerGrowMode result;
39931 PyObject * obj0 = 0 ;
39932 char *kwnames[] = {
39933 (char *) "self", NULL
39934 };
39935
39936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
39937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39938 if (SWIG_arg_fail(1)) SWIG_fail;
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
39942
39943 wxPyEndAllowThreads(__tstate);
39944 if (PyErr_Occurred()) SWIG_fail;
39945 }
39946 resultobj = SWIG_From_int((result));
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj;
39955 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39956 wxArrayInt *result;
39957 PyObject * obj0 = 0 ;
39958 char *kwnames[] = {
39959 (char *) "self", NULL
39960 };
39961
39962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
39963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39964 if (SWIG_arg_fail(1)) SWIG_fail;
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 {
39968 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
39969 result = (wxArrayInt *) &_result_ref;
39970 }
39971
39972 wxPyEndAllowThreads(__tstate);
39973 if (PyErr_Occurred()) SWIG_fail;
39974 }
39975 {
39976 resultobj = PyList_New(0);
39977 size_t idx;
39978 for (idx = 0; idx < result->GetCount(); idx += 1) {
39979 PyObject* val = PyInt_FromLong( result->Item(idx) );
39980 PyList_Append(resultobj, val);
39981 Py_DECREF(val);
39982 }
39983 }
39984 return resultobj;
39985 fail:
39986 return NULL;
39987 }
39988
39989
39990 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
39991 PyObject *resultobj;
39992 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39993 wxArrayInt *result;
39994 PyObject * obj0 = 0 ;
39995 char *kwnames[] = {
39996 (char *) "self", NULL
39997 };
39998
39999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40001 if (SWIG_arg_fail(1)) SWIG_fail;
40002 {
40003 PyThreadState* __tstate = wxPyBeginAllowThreads();
40004 {
40005 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40006 result = (wxArrayInt *) &_result_ref;
40007 }
40008
40009 wxPyEndAllowThreads(__tstate);
40010 if (PyErr_Occurred()) SWIG_fail;
40011 }
40012 {
40013 resultobj = PyList_New(0);
40014 size_t idx;
40015 for (idx = 0; idx < result->GetCount(); idx += 1) {
40016 PyObject* val = PyInt_FromLong( result->Item(idx) );
40017 PyList_Append(resultobj, val);
40018 Py_DECREF(val);
40019 }
40020 }
40021 return resultobj;
40022 fail:
40023 return NULL;
40024 }
40025
40026
40027 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40028 PyObject *obj;
40029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40030 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40031 Py_INCREF(obj);
40032 return Py_BuildValue((char *)"");
40033 }
40034 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40035 PyObject *resultobj;
40036 int arg1 = (int) 0 ;
40037 int arg2 = (int) 0 ;
40038 wxGBPosition *result;
40039 PyObject * obj0 = 0 ;
40040 PyObject * obj1 = 0 ;
40041 char *kwnames[] = {
40042 (char *) "row",(char *) "col", NULL
40043 };
40044
40045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40046 if (obj0) {
40047 {
40048 arg1 = (int)(SWIG_As_int(obj0));
40049 if (SWIG_arg_fail(1)) SWIG_fail;
40050 }
40051 }
40052 if (obj1) {
40053 {
40054 arg2 = (int)(SWIG_As_int(obj1));
40055 if (SWIG_arg_fail(2)) SWIG_fail;
40056 }
40057 }
40058 {
40059 PyThreadState* __tstate = wxPyBeginAllowThreads();
40060 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40061
40062 wxPyEndAllowThreads(__tstate);
40063 if (PyErr_Occurred()) SWIG_fail;
40064 }
40065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40066 return resultobj;
40067 fail:
40068 return NULL;
40069 }
40070
40071
40072 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40073 PyObject *resultobj;
40074 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40075 int result;
40076 PyObject * obj0 = 0 ;
40077 char *kwnames[] = {
40078 (char *) "self", NULL
40079 };
40080
40081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40083 if (SWIG_arg_fail(1)) SWIG_fail;
40084 {
40085 PyThreadState* __tstate = wxPyBeginAllowThreads();
40086 result = (int)((wxGBPosition const *)arg1)->GetRow();
40087
40088 wxPyEndAllowThreads(__tstate);
40089 if (PyErr_Occurred()) SWIG_fail;
40090 }
40091 {
40092 resultobj = SWIG_From_int((int)(result));
40093 }
40094 return resultobj;
40095 fail:
40096 return NULL;
40097 }
40098
40099
40100 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40101 PyObject *resultobj;
40102 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40103 int result;
40104 PyObject * obj0 = 0 ;
40105 char *kwnames[] = {
40106 (char *) "self", NULL
40107 };
40108
40109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40111 if (SWIG_arg_fail(1)) SWIG_fail;
40112 {
40113 PyThreadState* __tstate = wxPyBeginAllowThreads();
40114 result = (int)((wxGBPosition const *)arg1)->GetCol();
40115
40116 wxPyEndAllowThreads(__tstate);
40117 if (PyErr_Occurred()) SWIG_fail;
40118 }
40119 {
40120 resultobj = SWIG_From_int((int)(result));
40121 }
40122 return resultobj;
40123 fail:
40124 return NULL;
40125 }
40126
40127
40128 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40129 PyObject *resultobj;
40130 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40131 int arg2 ;
40132 PyObject * obj0 = 0 ;
40133 PyObject * obj1 = 0 ;
40134 char *kwnames[] = {
40135 (char *) "self",(char *) "row", NULL
40136 };
40137
40138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40140 if (SWIG_arg_fail(1)) SWIG_fail;
40141 {
40142 arg2 = (int)(SWIG_As_int(obj1));
40143 if (SWIG_arg_fail(2)) SWIG_fail;
40144 }
40145 {
40146 PyThreadState* __tstate = wxPyBeginAllowThreads();
40147 (arg1)->SetRow(arg2);
40148
40149 wxPyEndAllowThreads(__tstate);
40150 if (PyErr_Occurred()) SWIG_fail;
40151 }
40152 Py_INCREF(Py_None); resultobj = Py_None;
40153 return resultobj;
40154 fail:
40155 return NULL;
40156 }
40157
40158
40159 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40160 PyObject *resultobj;
40161 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40162 int arg2 ;
40163 PyObject * obj0 = 0 ;
40164 PyObject * obj1 = 0 ;
40165 char *kwnames[] = {
40166 (char *) "self",(char *) "col", NULL
40167 };
40168
40169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40171 if (SWIG_arg_fail(1)) SWIG_fail;
40172 {
40173 arg2 = (int)(SWIG_As_int(obj1));
40174 if (SWIG_arg_fail(2)) SWIG_fail;
40175 }
40176 {
40177 PyThreadState* __tstate = wxPyBeginAllowThreads();
40178 (arg1)->SetCol(arg2);
40179
40180 wxPyEndAllowThreads(__tstate);
40181 if (PyErr_Occurred()) SWIG_fail;
40182 }
40183 Py_INCREF(Py_None); resultobj = Py_None;
40184 return resultobj;
40185 fail:
40186 return NULL;
40187 }
40188
40189
40190 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40191 PyObject *resultobj;
40192 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40193 wxGBPosition *arg2 = 0 ;
40194 bool result;
40195 wxGBPosition temp2 ;
40196 PyObject * obj0 = 0 ;
40197 PyObject * obj1 = 0 ;
40198 char *kwnames[] = {
40199 (char *) "self",(char *) "other", NULL
40200 };
40201
40202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40204 if (SWIG_arg_fail(1)) SWIG_fail;
40205 {
40206 arg2 = &temp2;
40207 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40208 }
40209 {
40210 PyThreadState* __tstate = wxPyBeginAllowThreads();
40211 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40212
40213 wxPyEndAllowThreads(__tstate);
40214 if (PyErr_Occurred()) SWIG_fail;
40215 }
40216 {
40217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40218 }
40219 return resultobj;
40220 fail:
40221 return NULL;
40222 }
40223
40224
40225 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40226 PyObject *resultobj;
40227 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40228 wxGBPosition *arg2 = 0 ;
40229 bool result;
40230 wxGBPosition temp2 ;
40231 PyObject * obj0 = 0 ;
40232 PyObject * obj1 = 0 ;
40233 char *kwnames[] = {
40234 (char *) "self",(char *) "other", NULL
40235 };
40236
40237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40239 if (SWIG_arg_fail(1)) SWIG_fail;
40240 {
40241 arg2 = &temp2;
40242 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40243 }
40244 {
40245 PyThreadState* __tstate = wxPyBeginAllowThreads();
40246 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40247
40248 wxPyEndAllowThreads(__tstate);
40249 if (PyErr_Occurred()) SWIG_fail;
40250 }
40251 {
40252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40253 }
40254 return resultobj;
40255 fail:
40256 return NULL;
40257 }
40258
40259
40260 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40261 PyObject *resultobj;
40262 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40263 int arg2 = (int) 0 ;
40264 int arg3 = (int) 0 ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 PyObject * obj2 = 0 ;
40268 char *kwnames[] = {
40269 (char *) "self",(char *) "row",(char *) "col", NULL
40270 };
40271
40272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40274 if (SWIG_arg_fail(1)) SWIG_fail;
40275 if (obj1) {
40276 {
40277 arg2 = (int)(SWIG_As_int(obj1));
40278 if (SWIG_arg_fail(2)) SWIG_fail;
40279 }
40280 }
40281 if (obj2) {
40282 {
40283 arg3 = (int)(SWIG_As_int(obj2));
40284 if (SWIG_arg_fail(3)) SWIG_fail;
40285 }
40286 }
40287 {
40288 PyThreadState* __tstate = wxPyBeginAllowThreads();
40289 wxGBPosition_Set(arg1,arg2,arg3);
40290
40291 wxPyEndAllowThreads(__tstate);
40292 if (PyErr_Occurred()) SWIG_fail;
40293 }
40294 Py_INCREF(Py_None); resultobj = Py_None;
40295 return resultobj;
40296 fail:
40297 return NULL;
40298 }
40299
40300
40301 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40302 PyObject *resultobj;
40303 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40304 PyObject *result;
40305 PyObject * obj0 = 0 ;
40306 char *kwnames[] = {
40307 (char *) "self", NULL
40308 };
40309
40310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40312 if (SWIG_arg_fail(1)) SWIG_fail;
40313 {
40314 PyThreadState* __tstate = wxPyBeginAllowThreads();
40315 result = (PyObject *)wxGBPosition_Get(arg1);
40316
40317 wxPyEndAllowThreads(__tstate);
40318 if (PyErr_Occurred()) SWIG_fail;
40319 }
40320 resultobj = result;
40321 return resultobj;
40322 fail:
40323 return NULL;
40324 }
40325
40326
40327 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40328 PyObject *obj;
40329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40330 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40331 Py_INCREF(obj);
40332 return Py_BuildValue((char *)"");
40333 }
40334 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40335 PyObject *resultobj;
40336 int arg1 = (int) 1 ;
40337 int arg2 = (int) 1 ;
40338 wxGBSpan *result;
40339 PyObject * obj0 = 0 ;
40340 PyObject * obj1 = 0 ;
40341 char *kwnames[] = {
40342 (char *) "rowspan",(char *) "colspan", NULL
40343 };
40344
40345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40346 if (obj0) {
40347 {
40348 arg1 = (int)(SWIG_As_int(obj0));
40349 if (SWIG_arg_fail(1)) SWIG_fail;
40350 }
40351 }
40352 if (obj1) {
40353 {
40354 arg2 = (int)(SWIG_As_int(obj1));
40355 if (SWIG_arg_fail(2)) SWIG_fail;
40356 }
40357 }
40358 {
40359 PyThreadState* __tstate = wxPyBeginAllowThreads();
40360 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40361
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40373 PyObject *resultobj;
40374 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40375 int result;
40376 PyObject * obj0 = 0 ;
40377 char *kwnames[] = {
40378 (char *) "self", NULL
40379 };
40380
40381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40383 if (SWIG_arg_fail(1)) SWIG_fail;
40384 {
40385 PyThreadState* __tstate = wxPyBeginAllowThreads();
40386 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40387
40388 wxPyEndAllowThreads(__tstate);
40389 if (PyErr_Occurred()) SWIG_fail;
40390 }
40391 {
40392 resultobj = SWIG_From_int((int)(result));
40393 }
40394 return resultobj;
40395 fail:
40396 return NULL;
40397 }
40398
40399
40400 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj;
40402 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40403 int result;
40404 PyObject * obj0 = 0 ;
40405 char *kwnames[] = {
40406 (char *) "self", NULL
40407 };
40408
40409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40411 if (SWIG_arg_fail(1)) SWIG_fail;
40412 {
40413 PyThreadState* __tstate = wxPyBeginAllowThreads();
40414 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40415
40416 wxPyEndAllowThreads(__tstate);
40417 if (PyErr_Occurred()) SWIG_fail;
40418 }
40419 {
40420 resultobj = SWIG_From_int((int)(result));
40421 }
40422 return resultobj;
40423 fail:
40424 return NULL;
40425 }
40426
40427
40428 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40429 PyObject *resultobj;
40430 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40431 int arg2 ;
40432 PyObject * obj0 = 0 ;
40433 PyObject * obj1 = 0 ;
40434 char *kwnames[] = {
40435 (char *) "self",(char *) "rowspan", NULL
40436 };
40437
40438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40440 if (SWIG_arg_fail(1)) SWIG_fail;
40441 {
40442 arg2 = (int)(SWIG_As_int(obj1));
40443 if (SWIG_arg_fail(2)) SWIG_fail;
40444 }
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 (arg1)->SetRowspan(arg2);
40448
40449 wxPyEndAllowThreads(__tstate);
40450 if (PyErr_Occurred()) SWIG_fail;
40451 }
40452 Py_INCREF(Py_None); resultobj = Py_None;
40453 return resultobj;
40454 fail:
40455 return NULL;
40456 }
40457
40458
40459 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40460 PyObject *resultobj;
40461 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40462 int arg2 ;
40463 PyObject * obj0 = 0 ;
40464 PyObject * obj1 = 0 ;
40465 char *kwnames[] = {
40466 (char *) "self",(char *) "colspan", NULL
40467 };
40468
40469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40471 if (SWIG_arg_fail(1)) SWIG_fail;
40472 {
40473 arg2 = (int)(SWIG_As_int(obj1));
40474 if (SWIG_arg_fail(2)) SWIG_fail;
40475 }
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 (arg1)->SetColspan(arg2);
40479
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 Py_INCREF(Py_None); resultobj = Py_None;
40484 return resultobj;
40485 fail:
40486 return NULL;
40487 }
40488
40489
40490 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40491 PyObject *resultobj;
40492 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40493 wxGBSpan *arg2 = 0 ;
40494 bool result;
40495 wxGBSpan temp2 ;
40496 PyObject * obj0 = 0 ;
40497 PyObject * obj1 = 0 ;
40498 char *kwnames[] = {
40499 (char *) "self",(char *) "other", NULL
40500 };
40501
40502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
40503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40504 if (SWIG_arg_fail(1)) SWIG_fail;
40505 {
40506 arg2 = &temp2;
40507 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40508 }
40509 {
40510 PyThreadState* __tstate = wxPyBeginAllowThreads();
40511 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
40512
40513 wxPyEndAllowThreads(__tstate);
40514 if (PyErr_Occurred()) SWIG_fail;
40515 }
40516 {
40517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40518 }
40519 return resultobj;
40520 fail:
40521 return NULL;
40522 }
40523
40524
40525 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40526 PyObject *resultobj;
40527 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40528 wxGBSpan *arg2 = 0 ;
40529 bool result;
40530 wxGBSpan temp2 ;
40531 PyObject * obj0 = 0 ;
40532 PyObject * obj1 = 0 ;
40533 char *kwnames[] = {
40534 (char *) "self",(char *) "other", NULL
40535 };
40536
40537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
40538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40539 if (SWIG_arg_fail(1)) SWIG_fail;
40540 {
40541 arg2 = &temp2;
40542 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40543 }
40544 {
40545 PyThreadState* __tstate = wxPyBeginAllowThreads();
40546 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
40547
40548 wxPyEndAllowThreads(__tstate);
40549 if (PyErr_Occurred()) SWIG_fail;
40550 }
40551 {
40552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40553 }
40554 return resultobj;
40555 fail:
40556 return NULL;
40557 }
40558
40559
40560 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40561 PyObject *resultobj;
40562 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40563 int arg2 = (int) 1 ;
40564 int arg3 = (int) 1 ;
40565 PyObject * obj0 = 0 ;
40566 PyObject * obj1 = 0 ;
40567 PyObject * obj2 = 0 ;
40568 char *kwnames[] = {
40569 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
40570 };
40571
40572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40574 if (SWIG_arg_fail(1)) SWIG_fail;
40575 if (obj1) {
40576 {
40577 arg2 = (int)(SWIG_As_int(obj1));
40578 if (SWIG_arg_fail(2)) SWIG_fail;
40579 }
40580 }
40581 if (obj2) {
40582 {
40583 arg3 = (int)(SWIG_As_int(obj2));
40584 if (SWIG_arg_fail(3)) SWIG_fail;
40585 }
40586 }
40587 {
40588 PyThreadState* __tstate = wxPyBeginAllowThreads();
40589 wxGBSpan_Set(arg1,arg2,arg3);
40590
40591 wxPyEndAllowThreads(__tstate);
40592 if (PyErr_Occurred()) SWIG_fail;
40593 }
40594 Py_INCREF(Py_None); resultobj = Py_None;
40595 return resultobj;
40596 fail:
40597 return NULL;
40598 }
40599
40600
40601 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40602 PyObject *resultobj;
40603 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40604 PyObject *result;
40605 PyObject * obj0 = 0 ;
40606 char *kwnames[] = {
40607 (char *) "self", NULL
40608 };
40609
40610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
40611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40612 if (SWIG_arg_fail(1)) SWIG_fail;
40613 {
40614 PyThreadState* __tstate = wxPyBeginAllowThreads();
40615 result = (PyObject *)wxGBSpan_Get(arg1);
40616
40617 wxPyEndAllowThreads(__tstate);
40618 if (PyErr_Occurred()) SWIG_fail;
40619 }
40620 resultobj = result;
40621 return resultobj;
40622 fail:
40623 return NULL;
40624 }
40625
40626
40627 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
40628 PyObject *obj;
40629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40630 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
40631 Py_INCREF(obj);
40632 return Py_BuildValue((char *)"");
40633 }
40634 static int _wrap_DefaultSpan_set(PyObject *) {
40635 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
40636 return 1;
40637 }
40638
40639
40640 static PyObject *_wrap_DefaultSpan_get(void) {
40641 PyObject *pyobj;
40642
40643 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
40644 return pyobj;
40645 }
40646
40647
40648 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
40649 PyObject *resultobj;
40650 wxGBSizerItem *result;
40651 char *kwnames[] = {
40652 NULL
40653 };
40654
40655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
40656 {
40657 PyThreadState* __tstate = wxPyBeginAllowThreads();
40658 result = (wxGBSizerItem *)new wxGBSizerItem();
40659
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj;
40672 wxWindow *arg1 = (wxWindow *) 0 ;
40673 wxGBPosition *arg2 = 0 ;
40674 wxGBSpan *arg3 = 0 ;
40675 int arg4 ;
40676 int arg5 ;
40677 PyObject *arg6 = (PyObject *) NULL ;
40678 wxGBSizerItem *result;
40679 wxGBPosition temp2 ;
40680 wxGBSpan temp3 ;
40681 PyObject * obj0 = 0 ;
40682 PyObject * obj1 = 0 ;
40683 PyObject * obj2 = 0 ;
40684 PyObject * obj3 = 0 ;
40685 PyObject * obj4 = 0 ;
40686 PyObject * obj5 = 0 ;
40687 char *kwnames[] = {
40688 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40689 };
40690
40691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40693 if (SWIG_arg_fail(1)) SWIG_fail;
40694 {
40695 arg2 = &temp2;
40696 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40697 }
40698 {
40699 arg3 = &temp3;
40700 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
40701 }
40702 {
40703 arg4 = (int)(SWIG_As_int(obj3));
40704 if (SWIG_arg_fail(4)) SWIG_fail;
40705 }
40706 {
40707 arg5 = (int)(SWIG_As_int(obj4));
40708 if (SWIG_arg_fail(5)) SWIG_fail;
40709 }
40710 if (obj5) {
40711 arg6 = obj5;
40712 }
40713 {
40714 PyThreadState* __tstate = wxPyBeginAllowThreads();
40715 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
40716
40717 wxPyEndAllowThreads(__tstate);
40718 if (PyErr_Occurred()) SWIG_fail;
40719 }
40720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40721 return resultobj;
40722 fail:
40723 return NULL;
40724 }
40725
40726
40727 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40728 PyObject *resultobj;
40729 wxSizer *arg1 = (wxSizer *) 0 ;
40730 wxGBPosition *arg2 = 0 ;
40731 wxGBSpan *arg3 = 0 ;
40732 int arg4 ;
40733 int arg5 ;
40734 PyObject *arg6 = (PyObject *) NULL ;
40735 wxGBSizerItem *result;
40736 wxGBPosition temp2 ;
40737 wxGBSpan temp3 ;
40738 PyObject * obj0 = 0 ;
40739 PyObject * obj1 = 0 ;
40740 PyObject * obj2 = 0 ;
40741 PyObject * obj3 = 0 ;
40742 PyObject * obj4 = 0 ;
40743 PyObject * obj5 = 0 ;
40744 char *kwnames[] = {
40745 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40746 };
40747
40748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40750 if (SWIG_arg_fail(1)) SWIG_fail;
40751 {
40752 arg2 = &temp2;
40753 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40754 }
40755 {
40756 arg3 = &temp3;
40757 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
40758 }
40759 {
40760 arg4 = (int)(SWIG_As_int(obj3));
40761 if (SWIG_arg_fail(4)) SWIG_fail;
40762 }
40763 {
40764 arg5 = (int)(SWIG_As_int(obj4));
40765 if (SWIG_arg_fail(5)) SWIG_fail;
40766 }
40767 if (obj5) {
40768 arg6 = obj5;
40769 }
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
40773
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40778 return resultobj;
40779 fail:
40780 return NULL;
40781 }
40782
40783
40784 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40785 PyObject *resultobj;
40786 int arg1 ;
40787 int arg2 ;
40788 wxGBPosition *arg3 = 0 ;
40789 wxGBSpan *arg4 = 0 ;
40790 int arg5 ;
40791 int arg6 ;
40792 PyObject *arg7 = (PyObject *) NULL ;
40793 wxGBSizerItem *result;
40794 wxGBPosition temp3 ;
40795 wxGBSpan temp4 ;
40796 PyObject * obj0 = 0 ;
40797 PyObject * obj1 = 0 ;
40798 PyObject * obj2 = 0 ;
40799 PyObject * obj3 = 0 ;
40800 PyObject * obj4 = 0 ;
40801 PyObject * obj5 = 0 ;
40802 PyObject * obj6 = 0 ;
40803 char *kwnames[] = {
40804 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40805 };
40806
40807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40808 {
40809 arg1 = (int)(SWIG_As_int(obj0));
40810 if (SWIG_arg_fail(1)) SWIG_fail;
40811 }
40812 {
40813 arg2 = (int)(SWIG_As_int(obj1));
40814 if (SWIG_arg_fail(2)) SWIG_fail;
40815 }
40816 {
40817 arg3 = &temp3;
40818 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
40819 }
40820 {
40821 arg4 = &temp4;
40822 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
40823 }
40824 {
40825 arg5 = (int)(SWIG_As_int(obj4));
40826 if (SWIG_arg_fail(5)) SWIG_fail;
40827 }
40828 {
40829 arg6 = (int)(SWIG_As_int(obj5));
40830 if (SWIG_arg_fail(6)) SWIG_fail;
40831 }
40832 if (obj6) {
40833 arg7 = obj6;
40834 }
40835 {
40836 PyThreadState* __tstate = wxPyBeginAllowThreads();
40837 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
40838
40839 wxPyEndAllowThreads(__tstate);
40840 if (PyErr_Occurred()) SWIG_fail;
40841 }
40842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
40850 PyObject *resultobj;
40851 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
40852 wxGBPosition result;
40853 PyObject * obj0 = 0 ;
40854 char *kwnames[] = {
40855 (char *) "self", NULL
40856 };
40857
40858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
40859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
40860 if (SWIG_arg_fail(1)) SWIG_fail;
40861 {
40862 PyThreadState* __tstate = wxPyBeginAllowThreads();
40863 result = ((wxGBSizerItem const *)arg1)->GetPos();
40864
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 {
40869 wxGBPosition * resultptr;
40870 resultptr = new wxGBPosition((wxGBPosition &)(result));
40871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
40872 }
40873 return resultobj;
40874 fail:
40875 return NULL;
40876 }
40877
40878
40879 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40880 PyObject *resultobj;
40881 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
40882 wxGBSpan result;
40883 PyObject * obj0 = 0 ;
40884 char *kwnames[] = {
40885 (char *) "self", NULL
40886 };
40887
40888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
40889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
40890 if (SWIG_arg_fail(1)) SWIG_fail;
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = ((wxGBSizerItem const *)arg1)->GetSpan();
40894
40895 wxPyEndAllowThreads(__tstate);
40896 if (PyErr_Occurred()) SWIG_fail;
40897 }
40898 {
40899 wxGBSpan * resultptr;
40900 resultptr = new wxGBSpan((wxGBSpan &)(result));
40901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
40902 }
40903 return resultobj;
40904 fail:
40905 return NULL;
40906 }
40907
40908
40909 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
40910 PyObject *resultobj;
40911 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
40912 wxGBPosition *arg2 = 0 ;
40913 bool result;
40914 wxGBPosition temp2 ;
40915 PyObject * obj0 = 0 ;
40916 PyObject * obj1 = 0 ;
40917 char *kwnames[] = {
40918 (char *) "self",(char *) "pos", NULL
40919 };
40920
40921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
40922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
40923 if (SWIG_arg_fail(1)) SWIG_fail;
40924 {
40925 arg2 = &temp2;
40926 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40927 }
40928 {
40929 PyThreadState* __tstate = wxPyBeginAllowThreads();
40930 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
40931
40932 wxPyEndAllowThreads(__tstate);
40933 if (PyErr_Occurred()) SWIG_fail;
40934 }
40935 {
40936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40937 }
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40945 PyObject *resultobj;
40946 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
40947 wxGBSpan *arg2 = 0 ;
40948 bool result;
40949 wxGBSpan temp2 ;
40950 PyObject * obj0 = 0 ;
40951 PyObject * obj1 = 0 ;
40952 char *kwnames[] = {
40953 (char *) "self",(char *) "span", NULL
40954 };
40955
40956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
40957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
40958 if (SWIG_arg_fail(1)) SWIG_fail;
40959 {
40960 arg2 = &temp2;
40961 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40962 }
40963 {
40964 PyThreadState* __tstate = wxPyBeginAllowThreads();
40965 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
40966
40967 wxPyEndAllowThreads(__tstate);
40968 if (PyErr_Occurred()) SWIG_fail;
40969 }
40970 {
40971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40972 }
40973 return resultobj;
40974 fail:
40975 return NULL;
40976 }
40977
40978
40979 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
40980 PyObject *resultobj;
40981 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
40982 wxGBSizerItem *arg2 = 0 ;
40983 bool result;
40984 PyObject * obj0 = 0 ;
40985 PyObject * obj1 = 0 ;
40986 char *kwnames[] = {
40987 (char *) "self",(char *) "other", NULL
40988 };
40989
40990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
40991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
40992 if (SWIG_arg_fail(1)) SWIG_fail;
40993 {
40994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
40995 if (SWIG_arg_fail(2)) SWIG_fail;
40996 if (arg2 == NULL) {
40997 SWIG_null_ref("wxGBSizerItem");
40998 }
40999 if (SWIG_arg_fail(2)) SWIG_fail;
41000 }
41001 {
41002 PyThreadState* __tstate = wxPyBeginAllowThreads();
41003 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41004
41005 wxPyEndAllowThreads(__tstate);
41006 if (PyErr_Occurred()) SWIG_fail;
41007 }
41008 {
41009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41010 }
41011 return resultobj;
41012 fail:
41013 return NULL;
41014 }
41015
41016
41017 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41018 PyObject *resultobj;
41019 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41020 wxGBPosition *arg2 = 0 ;
41021 wxGBSpan *arg3 = 0 ;
41022 bool result;
41023 wxGBPosition temp2 ;
41024 wxGBSpan temp3 ;
41025 PyObject * obj0 = 0 ;
41026 PyObject * obj1 = 0 ;
41027 PyObject * obj2 = 0 ;
41028 char *kwnames[] = {
41029 (char *) "self",(char *) "pos",(char *) "span", NULL
41030 };
41031
41032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41034 if (SWIG_arg_fail(1)) SWIG_fail;
41035 {
41036 arg2 = &temp2;
41037 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41038 }
41039 {
41040 arg3 = &temp3;
41041 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41042 }
41043 {
41044 PyThreadState* __tstate = wxPyBeginAllowThreads();
41045 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41046
41047 wxPyEndAllowThreads(__tstate);
41048 if (PyErr_Occurred()) SWIG_fail;
41049 }
41050 {
41051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41052 }
41053 return resultobj;
41054 fail:
41055 return NULL;
41056 }
41057
41058
41059 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41060 PyObject *resultobj;
41061 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41062 wxGBPosition result;
41063 PyObject * obj0 = 0 ;
41064 char *kwnames[] = {
41065 (char *) "self", NULL
41066 };
41067
41068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41070 if (SWIG_arg_fail(1)) SWIG_fail;
41071 {
41072 PyThreadState* __tstate = wxPyBeginAllowThreads();
41073 result = wxGBSizerItem_GetEndPos(arg1);
41074
41075 wxPyEndAllowThreads(__tstate);
41076 if (PyErr_Occurred()) SWIG_fail;
41077 }
41078 {
41079 wxGBPosition * resultptr;
41080 resultptr = new wxGBPosition((wxGBPosition &)(result));
41081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41082 }
41083 return resultobj;
41084 fail:
41085 return NULL;
41086 }
41087
41088
41089 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj;
41091 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41092 wxGridBagSizer *result;
41093 PyObject * obj0 = 0 ;
41094 char *kwnames[] = {
41095 (char *) "self", NULL
41096 };
41097
41098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41100 if (SWIG_arg_fail(1)) SWIG_fail;
41101 {
41102 PyThreadState* __tstate = wxPyBeginAllowThreads();
41103 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41104
41105 wxPyEndAllowThreads(__tstate);
41106 if (PyErr_Occurred()) SWIG_fail;
41107 }
41108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41109 return resultobj;
41110 fail:
41111 return NULL;
41112 }
41113
41114
41115 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41116 PyObject *resultobj;
41117 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41118 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41119 PyObject * obj0 = 0 ;
41120 PyObject * obj1 = 0 ;
41121 char *kwnames[] = {
41122 (char *) "self",(char *) "sizer", NULL
41123 };
41124
41125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41127 if (SWIG_arg_fail(1)) SWIG_fail;
41128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41129 if (SWIG_arg_fail(2)) SWIG_fail;
41130 {
41131 PyThreadState* __tstate = wxPyBeginAllowThreads();
41132 (arg1)->SetGBSizer(arg2);
41133
41134 wxPyEndAllowThreads(__tstate);
41135 if (PyErr_Occurred()) SWIG_fail;
41136 }
41137 Py_INCREF(Py_None); resultobj = Py_None;
41138 return resultobj;
41139 fail:
41140 return NULL;
41141 }
41142
41143
41144 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41145 PyObject *obj;
41146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41147 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41148 Py_INCREF(obj);
41149 return Py_BuildValue((char *)"");
41150 }
41151 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41152 PyObject *resultobj;
41153 int arg1 = (int) 0 ;
41154 int arg2 = (int) 0 ;
41155 wxGridBagSizer *result;
41156 PyObject * obj0 = 0 ;
41157 PyObject * obj1 = 0 ;
41158 char *kwnames[] = {
41159 (char *) "vgap",(char *) "hgap", NULL
41160 };
41161
41162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41163 if (obj0) {
41164 {
41165 arg1 = (int)(SWIG_As_int(obj0));
41166 if (SWIG_arg_fail(1)) SWIG_fail;
41167 }
41168 }
41169 if (obj1) {
41170 {
41171 arg2 = (int)(SWIG_As_int(obj1));
41172 if (SWIG_arg_fail(2)) SWIG_fail;
41173 }
41174 }
41175 {
41176 PyThreadState* __tstate = wxPyBeginAllowThreads();
41177 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41178
41179 wxPyEndAllowThreads(__tstate);
41180 if (PyErr_Occurred()) SWIG_fail;
41181 }
41182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41190 PyObject *resultobj;
41191 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41192 PyObject *arg2 = (PyObject *) 0 ;
41193 wxGBPosition *arg3 = 0 ;
41194 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41195 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41196 int arg5 = (int) 0 ;
41197 int arg6 = (int) 0 ;
41198 PyObject *arg7 = (PyObject *) NULL ;
41199 wxGBSizerItem *result;
41200 wxGBPosition temp3 ;
41201 wxGBSpan temp4 ;
41202 PyObject * obj0 = 0 ;
41203 PyObject * obj1 = 0 ;
41204 PyObject * obj2 = 0 ;
41205 PyObject * obj3 = 0 ;
41206 PyObject * obj4 = 0 ;
41207 PyObject * obj5 = 0 ;
41208 PyObject * obj6 = 0 ;
41209 char *kwnames[] = {
41210 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41211 };
41212
41213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41215 if (SWIG_arg_fail(1)) SWIG_fail;
41216 arg2 = obj1;
41217 {
41218 arg3 = &temp3;
41219 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41220 }
41221 if (obj3) {
41222 {
41223 arg4 = &temp4;
41224 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41225 }
41226 }
41227 if (obj4) {
41228 {
41229 arg5 = (int)(SWIG_As_int(obj4));
41230 if (SWIG_arg_fail(5)) SWIG_fail;
41231 }
41232 }
41233 if (obj5) {
41234 {
41235 arg6 = (int)(SWIG_As_int(obj5));
41236 if (SWIG_arg_fail(6)) SWIG_fail;
41237 }
41238 }
41239 if (obj6) {
41240 arg7 = obj6;
41241 }
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41245
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41250 return resultobj;
41251 fail:
41252 return NULL;
41253 }
41254
41255
41256 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41257 PyObject *resultobj;
41258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41259 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41260 wxGBSizerItem *result;
41261 PyObject * obj0 = 0 ;
41262 PyObject * obj1 = 0 ;
41263 char *kwnames[] = {
41264 (char *) "self",(char *) "item", NULL
41265 };
41266
41267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41269 if (SWIG_arg_fail(1)) SWIG_fail;
41270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41271 if (SWIG_arg_fail(2)) SWIG_fail;
41272 {
41273 PyThreadState* __tstate = wxPyBeginAllowThreads();
41274 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41275
41276 wxPyEndAllowThreads(__tstate);
41277 if (PyErr_Occurred()) SWIG_fail;
41278 }
41279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41280 return resultobj;
41281 fail:
41282 return NULL;
41283 }
41284
41285
41286 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj;
41288 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41289 int arg2 ;
41290 int arg3 ;
41291 wxSize result;
41292 PyObject * obj0 = 0 ;
41293 PyObject * obj1 = 0 ;
41294 PyObject * obj2 = 0 ;
41295 char *kwnames[] = {
41296 (char *) "self",(char *) "row",(char *) "col", NULL
41297 };
41298
41299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41301 if (SWIG_arg_fail(1)) SWIG_fail;
41302 {
41303 arg2 = (int)(SWIG_As_int(obj1));
41304 if (SWIG_arg_fail(2)) SWIG_fail;
41305 }
41306 {
41307 arg3 = (int)(SWIG_As_int(obj2));
41308 if (SWIG_arg_fail(3)) SWIG_fail;
41309 }
41310 {
41311 PyThreadState* __tstate = wxPyBeginAllowThreads();
41312 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41313
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 {
41318 wxSize * resultptr;
41319 resultptr = new wxSize((wxSize &)(result));
41320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41321 }
41322 return resultobj;
41323 fail:
41324 return NULL;
41325 }
41326
41327
41328 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41329 PyObject *resultobj;
41330 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41331 wxSize result;
41332 PyObject * obj0 = 0 ;
41333 char *kwnames[] = {
41334 (char *) "self", NULL
41335 };
41336
41337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41339 if (SWIG_arg_fail(1)) SWIG_fail;
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41343
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 {
41348 wxSize * resultptr;
41349 resultptr = new wxSize((wxSize &)(result));
41350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41351 }
41352 return resultobj;
41353 fail:
41354 return NULL;
41355 }
41356
41357
41358 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41359 PyObject *resultobj;
41360 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41361 wxSize *arg2 = 0 ;
41362 wxSize temp2 ;
41363 PyObject * obj0 = 0 ;
41364 PyObject * obj1 = 0 ;
41365 char *kwnames[] = {
41366 (char *) "self",(char *) "sz", NULL
41367 };
41368
41369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41371 if (SWIG_arg_fail(1)) SWIG_fail;
41372 {
41373 arg2 = &temp2;
41374 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41375 }
41376 {
41377 PyThreadState* __tstate = wxPyBeginAllowThreads();
41378 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41379
41380 wxPyEndAllowThreads(__tstate);
41381 if (PyErr_Occurred()) SWIG_fail;
41382 }
41383 Py_INCREF(Py_None); resultobj = Py_None;
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41391 PyObject *resultobj;
41392 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41393 wxWindow *arg2 = (wxWindow *) 0 ;
41394 wxGBPosition result;
41395 PyObject * obj0 = 0 ;
41396 PyObject * obj1 = 0 ;
41397
41398 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41400 if (SWIG_arg_fail(1)) SWIG_fail;
41401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41402 if (SWIG_arg_fail(2)) SWIG_fail;
41403 {
41404 PyThreadState* __tstate = wxPyBeginAllowThreads();
41405 result = (arg1)->GetItemPosition(arg2);
41406
41407 wxPyEndAllowThreads(__tstate);
41408 if (PyErr_Occurred()) SWIG_fail;
41409 }
41410 {
41411 wxGBPosition * resultptr;
41412 resultptr = new wxGBPosition((wxGBPosition &)(result));
41413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41414 }
41415 return resultobj;
41416 fail:
41417 return NULL;
41418 }
41419
41420
41421 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41422 PyObject *resultobj;
41423 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41424 wxSizer *arg2 = (wxSizer *) 0 ;
41425 wxGBPosition result;
41426 PyObject * obj0 = 0 ;
41427 PyObject * obj1 = 0 ;
41428
41429 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41431 if (SWIG_arg_fail(1)) SWIG_fail;
41432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41433 if (SWIG_arg_fail(2)) SWIG_fail;
41434 {
41435 PyThreadState* __tstate = wxPyBeginAllowThreads();
41436 result = (arg1)->GetItemPosition(arg2);
41437
41438 wxPyEndAllowThreads(__tstate);
41439 if (PyErr_Occurred()) SWIG_fail;
41440 }
41441 {
41442 wxGBPosition * resultptr;
41443 resultptr = new wxGBPosition((wxGBPosition &)(result));
41444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41445 }
41446 return resultobj;
41447 fail:
41448 return NULL;
41449 }
41450
41451
41452 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41453 PyObject *resultobj;
41454 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41455 size_t arg2 ;
41456 wxGBPosition result;
41457 PyObject * obj0 = 0 ;
41458 PyObject * obj1 = 0 ;
41459
41460 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41462 if (SWIG_arg_fail(1)) SWIG_fail;
41463 {
41464 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41465 if (SWIG_arg_fail(2)) SWIG_fail;
41466 }
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (arg1)->GetItemPosition(arg2);
41470
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 {
41475 wxGBPosition * resultptr;
41476 resultptr = new wxGBPosition((wxGBPosition &)(result));
41477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41478 }
41479 return resultobj;
41480 fail:
41481 return NULL;
41482 }
41483
41484
41485 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41486 int argc;
41487 PyObject *argv[3];
41488 int ii;
41489
41490 argc = PyObject_Length(args);
41491 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41492 argv[ii] = PyTuple_GetItem(args,ii);
41493 }
41494 if (argc == 2) {
41495 int _v;
41496 {
41497 void *ptr;
41498 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41499 _v = 0;
41500 PyErr_Clear();
41501 } else {
41502 _v = 1;
41503 }
41504 }
41505 if (_v) {
41506 {
41507 void *ptr;
41508 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41509 _v = 0;
41510 PyErr_Clear();
41511 } else {
41512 _v = 1;
41513 }
41514 }
41515 if (_v) {
41516 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
41517 }
41518 }
41519 }
41520 if (argc == 2) {
41521 int _v;
41522 {
41523 void *ptr;
41524 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41525 _v = 0;
41526 PyErr_Clear();
41527 } else {
41528 _v = 1;
41529 }
41530 }
41531 if (_v) {
41532 {
41533 void *ptr;
41534 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41535 _v = 0;
41536 PyErr_Clear();
41537 } else {
41538 _v = 1;
41539 }
41540 }
41541 if (_v) {
41542 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
41543 }
41544 }
41545 }
41546 if (argc == 2) {
41547 int _v;
41548 {
41549 void *ptr;
41550 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41551 _v = 0;
41552 PyErr_Clear();
41553 } else {
41554 _v = 1;
41555 }
41556 }
41557 if (_v) {
41558 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41559 if (_v) {
41560 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
41561 }
41562 }
41563 }
41564
41565 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
41566 return NULL;
41567 }
41568
41569
41570 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41571 PyObject *resultobj;
41572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41573 wxWindow *arg2 = (wxWindow *) 0 ;
41574 wxGBPosition *arg3 = 0 ;
41575 bool result;
41576 wxGBPosition temp3 ;
41577 PyObject * obj0 = 0 ;
41578 PyObject * obj1 = 0 ;
41579 PyObject * obj2 = 0 ;
41580
41581 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41583 if (SWIG_arg_fail(1)) SWIG_fail;
41584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41585 if (SWIG_arg_fail(2)) SWIG_fail;
41586 {
41587 arg3 = &temp3;
41588 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41589 }
41590 {
41591 PyThreadState* __tstate = wxPyBeginAllowThreads();
41592 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41593
41594 wxPyEndAllowThreads(__tstate);
41595 if (PyErr_Occurred()) SWIG_fail;
41596 }
41597 {
41598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41599 }
41600 return resultobj;
41601 fail:
41602 return NULL;
41603 }
41604
41605
41606 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41607 PyObject *resultobj;
41608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41609 wxSizer *arg2 = (wxSizer *) 0 ;
41610 wxGBPosition *arg3 = 0 ;
41611 bool result;
41612 wxGBPosition temp3 ;
41613 PyObject * obj0 = 0 ;
41614 PyObject * obj1 = 0 ;
41615 PyObject * obj2 = 0 ;
41616
41617 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41619 if (SWIG_arg_fail(1)) SWIG_fail;
41620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41621 if (SWIG_arg_fail(2)) SWIG_fail;
41622 {
41623 arg3 = &temp3;
41624 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41625 }
41626 {
41627 PyThreadState* __tstate = wxPyBeginAllowThreads();
41628 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41629
41630 wxPyEndAllowThreads(__tstate);
41631 if (PyErr_Occurred()) SWIG_fail;
41632 }
41633 {
41634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41635 }
41636 return resultobj;
41637 fail:
41638 return NULL;
41639 }
41640
41641
41642 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41643 PyObject *resultobj;
41644 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41645 size_t arg2 ;
41646 wxGBPosition *arg3 = 0 ;
41647 bool result;
41648 wxGBPosition temp3 ;
41649 PyObject * obj0 = 0 ;
41650 PyObject * obj1 = 0 ;
41651 PyObject * obj2 = 0 ;
41652
41653 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41655 if (SWIG_arg_fail(1)) SWIG_fail;
41656 {
41657 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41658 if (SWIG_arg_fail(2)) SWIG_fail;
41659 }
41660 {
41661 arg3 = &temp3;
41662 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41663 }
41664 {
41665 PyThreadState* __tstate = wxPyBeginAllowThreads();
41666 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41667
41668 wxPyEndAllowThreads(__tstate);
41669 if (PyErr_Occurred()) SWIG_fail;
41670 }
41671 {
41672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41673 }
41674 return resultobj;
41675 fail:
41676 return NULL;
41677 }
41678
41679
41680 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
41681 int argc;
41682 PyObject *argv[4];
41683 int ii;
41684
41685 argc = PyObject_Length(args);
41686 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
41687 argv[ii] = PyTuple_GetItem(args,ii);
41688 }
41689 if (argc == 3) {
41690 int _v;
41691 {
41692 void *ptr;
41693 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41694 _v = 0;
41695 PyErr_Clear();
41696 } else {
41697 _v = 1;
41698 }
41699 }
41700 if (_v) {
41701 {
41702 void *ptr;
41703 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41704 _v = 0;
41705 PyErr_Clear();
41706 } else {
41707 _v = 1;
41708 }
41709 }
41710 if (_v) {
41711 {
41712 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41713 }
41714 if (_v) {
41715 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
41716 }
41717 }
41718 }
41719 }
41720 if (argc == 3) {
41721 int _v;
41722 {
41723 void *ptr;
41724 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41725 _v = 0;
41726 PyErr_Clear();
41727 } else {
41728 _v = 1;
41729 }
41730 }
41731 if (_v) {
41732 {
41733 void *ptr;
41734 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41735 _v = 0;
41736 PyErr_Clear();
41737 } else {
41738 _v = 1;
41739 }
41740 }
41741 if (_v) {
41742 {
41743 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41744 }
41745 if (_v) {
41746 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
41747 }
41748 }
41749 }
41750 }
41751 if (argc == 3) {
41752 int _v;
41753 {
41754 void *ptr;
41755 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41756 _v = 0;
41757 PyErr_Clear();
41758 } else {
41759 _v = 1;
41760 }
41761 }
41762 if (_v) {
41763 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41764 if (_v) {
41765 {
41766 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41767 }
41768 if (_v) {
41769 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
41770 }
41771 }
41772 }
41773 }
41774
41775 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
41776 return NULL;
41777 }
41778
41779
41780 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
41781 PyObject *resultobj;
41782 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41783 wxWindow *arg2 = (wxWindow *) 0 ;
41784 wxGBSpan result;
41785 PyObject * obj0 = 0 ;
41786 PyObject * obj1 = 0 ;
41787
41788 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
41789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41790 if (SWIG_arg_fail(1)) SWIG_fail;
41791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41792 if (SWIG_arg_fail(2)) SWIG_fail;
41793 {
41794 PyThreadState* __tstate = wxPyBeginAllowThreads();
41795 result = (arg1)->GetItemSpan(arg2);
41796
41797 wxPyEndAllowThreads(__tstate);
41798 if (PyErr_Occurred()) SWIG_fail;
41799 }
41800 {
41801 wxGBSpan * resultptr;
41802 resultptr = new wxGBSpan((wxGBSpan &)(result));
41803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41804 }
41805 return resultobj;
41806 fail:
41807 return NULL;
41808 }
41809
41810
41811 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
41812 PyObject *resultobj;
41813 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41814 wxSizer *arg2 = (wxSizer *) 0 ;
41815 wxGBSpan result;
41816 PyObject * obj0 = 0 ;
41817 PyObject * obj1 = 0 ;
41818
41819 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
41820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41821 if (SWIG_arg_fail(1)) SWIG_fail;
41822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41823 if (SWIG_arg_fail(2)) SWIG_fail;
41824 {
41825 PyThreadState* __tstate = wxPyBeginAllowThreads();
41826 result = (arg1)->GetItemSpan(arg2);
41827
41828 wxPyEndAllowThreads(__tstate);
41829 if (PyErr_Occurred()) SWIG_fail;
41830 }
41831 {
41832 wxGBSpan * resultptr;
41833 resultptr = new wxGBSpan((wxGBSpan &)(result));
41834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41835 }
41836 return resultobj;
41837 fail:
41838 return NULL;
41839 }
41840
41841
41842 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
41843 PyObject *resultobj;
41844 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41845 size_t arg2 ;
41846 wxGBSpan result;
41847 PyObject * obj0 = 0 ;
41848 PyObject * obj1 = 0 ;
41849
41850 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
41851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41852 if (SWIG_arg_fail(1)) SWIG_fail;
41853 {
41854 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41855 if (SWIG_arg_fail(2)) SWIG_fail;
41856 }
41857 {
41858 PyThreadState* __tstate = wxPyBeginAllowThreads();
41859 result = (arg1)->GetItemSpan(arg2);
41860
41861 wxPyEndAllowThreads(__tstate);
41862 if (PyErr_Occurred()) SWIG_fail;
41863 }
41864 {
41865 wxGBSpan * resultptr;
41866 resultptr = new wxGBSpan((wxGBSpan &)(result));
41867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41868 }
41869 return resultobj;
41870 fail:
41871 return NULL;
41872 }
41873
41874
41875 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
41876 int argc;
41877 PyObject *argv[3];
41878 int ii;
41879
41880 argc = PyObject_Length(args);
41881 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41882 argv[ii] = PyTuple_GetItem(args,ii);
41883 }
41884 if (argc == 2) {
41885 int _v;
41886 {
41887 void *ptr;
41888 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41889 _v = 0;
41890 PyErr_Clear();
41891 } else {
41892 _v = 1;
41893 }
41894 }
41895 if (_v) {
41896 {
41897 void *ptr;
41898 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41899 _v = 0;
41900 PyErr_Clear();
41901 } else {
41902 _v = 1;
41903 }
41904 }
41905 if (_v) {
41906 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
41907 }
41908 }
41909 }
41910 if (argc == 2) {
41911 int _v;
41912 {
41913 void *ptr;
41914 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41915 _v = 0;
41916 PyErr_Clear();
41917 } else {
41918 _v = 1;
41919 }
41920 }
41921 if (_v) {
41922 {
41923 void *ptr;
41924 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41925 _v = 0;
41926 PyErr_Clear();
41927 } else {
41928 _v = 1;
41929 }
41930 }
41931 if (_v) {
41932 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
41933 }
41934 }
41935 }
41936 if (argc == 2) {
41937 int _v;
41938 {
41939 void *ptr;
41940 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41941 _v = 0;
41942 PyErr_Clear();
41943 } else {
41944 _v = 1;
41945 }
41946 }
41947 if (_v) {
41948 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41949 if (_v) {
41950 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
41951 }
41952 }
41953 }
41954
41955 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
41956 return NULL;
41957 }
41958
41959
41960 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
41961 PyObject *resultobj;
41962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41963 wxWindow *arg2 = (wxWindow *) 0 ;
41964 wxGBSpan *arg3 = 0 ;
41965 bool result;
41966 wxGBSpan temp3 ;
41967 PyObject * obj0 = 0 ;
41968 PyObject * obj1 = 0 ;
41969 PyObject * obj2 = 0 ;
41970
41971 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
41972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41973 if (SWIG_arg_fail(1)) SWIG_fail;
41974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41975 if (SWIG_arg_fail(2)) SWIG_fail;
41976 {
41977 arg3 = &temp3;
41978 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
41983
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 {
41988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41989 }
41990 return resultobj;
41991 fail:
41992 return NULL;
41993 }
41994
41995
41996 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
41997 PyObject *resultobj;
41998 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41999 wxSizer *arg2 = (wxSizer *) 0 ;
42000 wxGBSpan *arg3 = 0 ;
42001 bool result;
42002 wxGBSpan temp3 ;
42003 PyObject * obj0 = 0 ;
42004 PyObject * obj1 = 0 ;
42005 PyObject * obj2 = 0 ;
42006
42007 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42009 if (SWIG_arg_fail(1)) SWIG_fail;
42010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42011 if (SWIG_arg_fail(2)) SWIG_fail;
42012 {
42013 arg3 = &temp3;
42014 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42015 }
42016 {
42017 PyThreadState* __tstate = wxPyBeginAllowThreads();
42018 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42019
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 {
42024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42025 }
42026 return resultobj;
42027 fail:
42028 return NULL;
42029 }
42030
42031
42032 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42033 PyObject *resultobj;
42034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42035 size_t arg2 ;
42036 wxGBSpan *arg3 = 0 ;
42037 bool result;
42038 wxGBSpan temp3 ;
42039 PyObject * obj0 = 0 ;
42040 PyObject * obj1 = 0 ;
42041 PyObject * obj2 = 0 ;
42042
42043 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42045 if (SWIG_arg_fail(1)) SWIG_fail;
42046 {
42047 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42048 if (SWIG_arg_fail(2)) SWIG_fail;
42049 }
42050 {
42051 arg3 = &temp3;
42052 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42053 }
42054 {
42055 PyThreadState* __tstate = wxPyBeginAllowThreads();
42056 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42057
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 {
42062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42063 }
42064 return resultobj;
42065 fail:
42066 return NULL;
42067 }
42068
42069
42070 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42071 int argc;
42072 PyObject *argv[4];
42073 int ii;
42074
42075 argc = PyObject_Length(args);
42076 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42077 argv[ii] = PyTuple_GetItem(args,ii);
42078 }
42079 if (argc == 3) {
42080 int _v;
42081 {
42082 void *ptr;
42083 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42084 _v = 0;
42085 PyErr_Clear();
42086 } else {
42087 _v = 1;
42088 }
42089 }
42090 if (_v) {
42091 {
42092 void *ptr;
42093 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42094 _v = 0;
42095 PyErr_Clear();
42096 } else {
42097 _v = 1;
42098 }
42099 }
42100 if (_v) {
42101 {
42102 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42103 }
42104 if (_v) {
42105 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42106 }
42107 }
42108 }
42109 }
42110 if (argc == 3) {
42111 int _v;
42112 {
42113 void *ptr;
42114 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42115 _v = 0;
42116 PyErr_Clear();
42117 } else {
42118 _v = 1;
42119 }
42120 }
42121 if (_v) {
42122 {
42123 void *ptr;
42124 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42125 _v = 0;
42126 PyErr_Clear();
42127 } else {
42128 _v = 1;
42129 }
42130 }
42131 if (_v) {
42132 {
42133 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42134 }
42135 if (_v) {
42136 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42137 }
42138 }
42139 }
42140 }
42141 if (argc == 3) {
42142 int _v;
42143 {
42144 void *ptr;
42145 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42146 _v = 0;
42147 PyErr_Clear();
42148 } else {
42149 _v = 1;
42150 }
42151 }
42152 if (_v) {
42153 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42154 if (_v) {
42155 {
42156 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42157 }
42158 if (_v) {
42159 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42160 }
42161 }
42162 }
42163 }
42164
42165 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42166 return NULL;
42167 }
42168
42169
42170 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42171 PyObject *resultobj;
42172 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42173 wxWindow *arg2 = (wxWindow *) 0 ;
42174 wxGBSizerItem *result;
42175 PyObject * obj0 = 0 ;
42176 PyObject * obj1 = 0 ;
42177
42178 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42180 if (SWIG_arg_fail(1)) SWIG_fail;
42181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42182 if (SWIG_arg_fail(2)) SWIG_fail;
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42186
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42191 return resultobj;
42192 fail:
42193 return NULL;
42194 }
42195
42196
42197 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42198 PyObject *resultobj;
42199 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42200 wxSizer *arg2 = (wxSizer *) 0 ;
42201 wxGBSizerItem *result;
42202 PyObject * obj0 = 0 ;
42203 PyObject * obj1 = 0 ;
42204
42205 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42207 if (SWIG_arg_fail(1)) SWIG_fail;
42208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42209 if (SWIG_arg_fail(2)) SWIG_fail;
42210 {
42211 PyThreadState* __tstate = wxPyBeginAllowThreads();
42212 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42213
42214 wxPyEndAllowThreads(__tstate);
42215 if (PyErr_Occurred()) SWIG_fail;
42216 }
42217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42218 return resultobj;
42219 fail:
42220 return NULL;
42221 }
42222
42223
42224 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42225 int argc;
42226 PyObject *argv[3];
42227 int ii;
42228
42229 argc = PyObject_Length(args);
42230 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42231 argv[ii] = PyTuple_GetItem(args,ii);
42232 }
42233 if (argc == 2) {
42234 int _v;
42235 {
42236 void *ptr;
42237 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42238 _v = 0;
42239 PyErr_Clear();
42240 } else {
42241 _v = 1;
42242 }
42243 }
42244 if (_v) {
42245 {
42246 void *ptr;
42247 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42248 _v = 0;
42249 PyErr_Clear();
42250 } else {
42251 _v = 1;
42252 }
42253 }
42254 if (_v) {
42255 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42256 }
42257 }
42258 }
42259 if (argc == 2) {
42260 int _v;
42261 {
42262 void *ptr;
42263 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42264 _v = 0;
42265 PyErr_Clear();
42266 } else {
42267 _v = 1;
42268 }
42269 }
42270 if (_v) {
42271 {
42272 void *ptr;
42273 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42274 _v = 0;
42275 PyErr_Clear();
42276 } else {
42277 _v = 1;
42278 }
42279 }
42280 if (_v) {
42281 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42282 }
42283 }
42284 }
42285
42286 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42287 return NULL;
42288 }
42289
42290
42291 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42292 PyObject *resultobj;
42293 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42294 wxGBPosition *arg2 = 0 ;
42295 wxGBSizerItem *result;
42296 wxGBPosition temp2 ;
42297 PyObject * obj0 = 0 ;
42298 PyObject * obj1 = 0 ;
42299 char *kwnames[] = {
42300 (char *) "self",(char *) "pos", NULL
42301 };
42302
42303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42305 if (SWIG_arg_fail(1)) SWIG_fail;
42306 {
42307 arg2 = &temp2;
42308 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42309 }
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42313
42314 wxPyEndAllowThreads(__tstate);
42315 if (PyErr_Occurred()) SWIG_fail;
42316 }
42317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42318 return resultobj;
42319 fail:
42320 return NULL;
42321 }
42322
42323
42324 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42325 PyObject *resultobj;
42326 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42327 wxPoint *arg2 = 0 ;
42328 wxGBSizerItem *result;
42329 wxPoint temp2 ;
42330 PyObject * obj0 = 0 ;
42331 PyObject * obj1 = 0 ;
42332 char *kwnames[] = {
42333 (char *) "self",(char *) "pt", NULL
42334 };
42335
42336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42338 if (SWIG_arg_fail(1)) SWIG_fail;
42339 {
42340 arg2 = &temp2;
42341 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42342 }
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42346
42347 wxPyEndAllowThreads(__tstate);
42348 if (PyErr_Occurred()) SWIG_fail;
42349 }
42350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42351 return resultobj;
42352 fail:
42353 return NULL;
42354 }
42355
42356
42357 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42358 PyObject *resultobj;
42359 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42360 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42361 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42362 bool result;
42363 PyObject * obj0 = 0 ;
42364 PyObject * obj1 = 0 ;
42365 PyObject * obj2 = 0 ;
42366 char *kwnames[] = {
42367 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42368 };
42369
42370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42372 if (SWIG_arg_fail(1)) SWIG_fail;
42373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42374 if (SWIG_arg_fail(2)) SWIG_fail;
42375 if (obj2) {
42376 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42377 if (SWIG_arg_fail(3)) SWIG_fail;
42378 }
42379 {
42380 PyThreadState* __tstate = wxPyBeginAllowThreads();
42381 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42382
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 {
42387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42388 }
42389 return resultobj;
42390 fail:
42391 return NULL;
42392 }
42393
42394
42395 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42396 PyObject *resultobj;
42397 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42398 wxGBPosition *arg2 = 0 ;
42399 wxGBSpan *arg3 = 0 ;
42400 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42401 bool result;
42402 wxGBPosition temp2 ;
42403 wxGBSpan temp3 ;
42404 PyObject * obj0 = 0 ;
42405 PyObject * obj1 = 0 ;
42406 PyObject * obj2 = 0 ;
42407 PyObject * obj3 = 0 ;
42408 char *kwnames[] = {
42409 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42410 };
42411
42412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42414 if (SWIG_arg_fail(1)) SWIG_fail;
42415 {
42416 arg2 = &temp2;
42417 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42418 }
42419 {
42420 arg3 = &temp3;
42421 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42422 }
42423 if (obj3) {
42424 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42425 if (SWIG_arg_fail(4)) SWIG_fail;
42426 }
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42430
42431 wxPyEndAllowThreads(__tstate);
42432 if (PyErr_Occurred()) SWIG_fail;
42433 }
42434 {
42435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42436 }
42437 return resultobj;
42438 fail:
42439 return NULL;
42440 }
42441
42442
42443 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42444 PyObject *obj;
42445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42446 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42447 Py_INCREF(obj);
42448 return Py_BuildValue((char *)"");
42449 }
42450 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42451 PyObject *resultobj;
42452 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42453 wxRelationship arg2 ;
42454 wxWindow *arg3 = (wxWindow *) 0 ;
42455 wxEdge arg4 ;
42456 int arg5 = (int) 0 ;
42457 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42458 PyObject * obj0 = 0 ;
42459 PyObject * obj1 = 0 ;
42460 PyObject * obj2 = 0 ;
42461 PyObject * obj3 = 0 ;
42462 PyObject * obj4 = 0 ;
42463 PyObject * obj5 = 0 ;
42464 char *kwnames[] = {
42465 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42466 };
42467
42468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42470 if (SWIG_arg_fail(1)) SWIG_fail;
42471 {
42472 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42473 if (SWIG_arg_fail(2)) SWIG_fail;
42474 }
42475 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42476 if (SWIG_arg_fail(3)) SWIG_fail;
42477 {
42478 arg4 = (wxEdge)(SWIG_As_int(obj3));
42479 if (SWIG_arg_fail(4)) SWIG_fail;
42480 }
42481 if (obj4) {
42482 {
42483 arg5 = (int)(SWIG_As_int(obj4));
42484 if (SWIG_arg_fail(5)) SWIG_fail;
42485 }
42486 }
42487 if (obj5) {
42488 {
42489 arg6 = (int)(SWIG_As_int(obj5));
42490 if (SWIG_arg_fail(6)) SWIG_fail;
42491 }
42492 }
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
42496
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 Py_INCREF(Py_None); resultobj = Py_None;
42501 return resultobj;
42502 fail:
42503 return NULL;
42504 }
42505
42506
42507 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
42508 PyObject *resultobj;
42509 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42510 wxWindow *arg2 = (wxWindow *) 0 ;
42511 int arg3 = (int) 0 ;
42512 PyObject * obj0 = 0 ;
42513 PyObject * obj1 = 0 ;
42514 PyObject * obj2 = 0 ;
42515 char *kwnames[] = {
42516 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42517 };
42518
42519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42521 if (SWIG_arg_fail(1)) SWIG_fail;
42522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42523 if (SWIG_arg_fail(2)) SWIG_fail;
42524 if (obj2) {
42525 {
42526 arg3 = (int)(SWIG_As_int(obj2));
42527 if (SWIG_arg_fail(3)) SWIG_fail;
42528 }
42529 }
42530 {
42531 PyThreadState* __tstate = wxPyBeginAllowThreads();
42532 (arg1)->LeftOf(arg2,arg3);
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_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
42545 PyObject *resultobj;
42546 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42547 wxWindow *arg2 = (wxWindow *) 0 ;
42548 int arg3 = (int) 0 ;
42549 PyObject * obj0 = 0 ;
42550 PyObject * obj1 = 0 ;
42551 PyObject * obj2 = 0 ;
42552 char *kwnames[] = {
42553 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42554 };
42555
42556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42558 if (SWIG_arg_fail(1)) SWIG_fail;
42559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42560 if (SWIG_arg_fail(2)) SWIG_fail;
42561 if (obj2) {
42562 {
42563 arg3 = (int)(SWIG_As_int(obj2));
42564 if (SWIG_arg_fail(3)) SWIG_fail;
42565 }
42566 }
42567 {
42568 PyThreadState* __tstate = wxPyBeginAllowThreads();
42569 (arg1)->RightOf(arg2,arg3);
42570
42571 wxPyEndAllowThreads(__tstate);
42572 if (PyErr_Occurred()) SWIG_fail;
42573 }
42574 Py_INCREF(Py_None); resultobj = Py_None;
42575 return resultobj;
42576 fail:
42577 return NULL;
42578 }
42579
42580
42581 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
42582 PyObject *resultobj;
42583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42584 wxWindow *arg2 = (wxWindow *) 0 ;
42585 int arg3 = (int) 0 ;
42586 PyObject * obj0 = 0 ;
42587 PyObject * obj1 = 0 ;
42588 PyObject * obj2 = 0 ;
42589 char *kwnames[] = {
42590 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42591 };
42592
42593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
42594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42595 if (SWIG_arg_fail(1)) SWIG_fail;
42596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42597 if (SWIG_arg_fail(2)) SWIG_fail;
42598 if (obj2) {
42599 {
42600 arg3 = (int)(SWIG_As_int(obj2));
42601 if (SWIG_arg_fail(3)) SWIG_fail;
42602 }
42603 }
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 (arg1)->Above(arg2,arg3);
42607
42608 wxPyEndAllowThreads(__tstate);
42609 if (PyErr_Occurred()) SWIG_fail;
42610 }
42611 Py_INCREF(Py_None); resultobj = Py_None;
42612 return resultobj;
42613 fail:
42614 return NULL;
42615 }
42616
42617
42618 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
42619 PyObject *resultobj;
42620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42621 wxWindow *arg2 = (wxWindow *) 0 ;
42622 int arg3 = (int) 0 ;
42623 PyObject * obj0 = 0 ;
42624 PyObject * obj1 = 0 ;
42625 PyObject * obj2 = 0 ;
42626 char *kwnames[] = {
42627 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42628 };
42629
42630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
42631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42632 if (SWIG_arg_fail(1)) SWIG_fail;
42633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42634 if (SWIG_arg_fail(2)) SWIG_fail;
42635 if (obj2) {
42636 {
42637 arg3 = (int)(SWIG_As_int(obj2));
42638 if (SWIG_arg_fail(3)) SWIG_fail;
42639 }
42640 }
42641 {
42642 PyThreadState* __tstate = wxPyBeginAllowThreads();
42643 (arg1)->Below(arg2,arg3);
42644
42645 wxPyEndAllowThreads(__tstate);
42646 if (PyErr_Occurred()) SWIG_fail;
42647 }
42648 Py_INCREF(Py_None); resultobj = Py_None;
42649 return resultobj;
42650 fail:
42651 return NULL;
42652 }
42653
42654
42655 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
42656 PyObject *resultobj;
42657 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42658 wxWindow *arg2 = (wxWindow *) 0 ;
42659 wxEdge arg3 ;
42660 int arg4 = (int) 0 ;
42661 PyObject * obj0 = 0 ;
42662 PyObject * obj1 = 0 ;
42663 PyObject * obj2 = 0 ;
42664 PyObject * obj3 = 0 ;
42665 char *kwnames[] = {
42666 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
42667 };
42668
42669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42671 if (SWIG_arg_fail(1)) SWIG_fail;
42672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42673 if (SWIG_arg_fail(2)) SWIG_fail;
42674 {
42675 arg3 = (wxEdge)(SWIG_As_int(obj2));
42676 if (SWIG_arg_fail(3)) SWIG_fail;
42677 }
42678 if (obj3) {
42679 {
42680 arg4 = (int)(SWIG_As_int(obj3));
42681 if (SWIG_arg_fail(4)) SWIG_fail;
42682 }
42683 }
42684 {
42685 PyThreadState* __tstate = wxPyBeginAllowThreads();
42686 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
42687
42688 wxPyEndAllowThreads(__tstate);
42689 if (PyErr_Occurred()) SWIG_fail;
42690 }
42691 Py_INCREF(Py_None); resultobj = Py_None;
42692 return resultobj;
42693 fail:
42694 return NULL;
42695 }
42696
42697
42698 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
42699 PyObject *resultobj;
42700 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42701 wxWindow *arg2 = (wxWindow *) 0 ;
42702 wxEdge arg3 ;
42703 int arg4 ;
42704 PyObject * obj0 = 0 ;
42705 PyObject * obj1 = 0 ;
42706 PyObject * obj2 = 0 ;
42707 PyObject * obj3 = 0 ;
42708 char *kwnames[] = {
42709 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
42710 };
42711
42712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42714 if (SWIG_arg_fail(1)) SWIG_fail;
42715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42716 if (SWIG_arg_fail(2)) SWIG_fail;
42717 {
42718 arg3 = (wxEdge)(SWIG_As_int(obj2));
42719 if (SWIG_arg_fail(3)) SWIG_fail;
42720 }
42721 {
42722 arg4 = (int)(SWIG_As_int(obj3));
42723 if (SWIG_arg_fail(4)) SWIG_fail;
42724 }
42725 {
42726 PyThreadState* __tstate = wxPyBeginAllowThreads();
42727 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
42728
42729 wxPyEndAllowThreads(__tstate);
42730 if (PyErr_Occurred()) SWIG_fail;
42731 }
42732 Py_INCREF(Py_None); resultobj = Py_None;
42733 return resultobj;
42734 fail:
42735 return NULL;
42736 }
42737
42738
42739 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
42740 PyObject *resultobj;
42741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42742 int arg2 ;
42743 PyObject * obj0 = 0 ;
42744 PyObject * obj1 = 0 ;
42745 char *kwnames[] = {
42746 (char *) "self",(char *) "val", NULL
42747 };
42748
42749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
42750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42751 if (SWIG_arg_fail(1)) SWIG_fail;
42752 {
42753 arg2 = (int)(SWIG_As_int(obj1));
42754 if (SWIG_arg_fail(2)) SWIG_fail;
42755 }
42756 {
42757 PyThreadState* __tstate = wxPyBeginAllowThreads();
42758 (arg1)->Absolute(arg2);
42759
42760 wxPyEndAllowThreads(__tstate);
42761 if (PyErr_Occurred()) SWIG_fail;
42762 }
42763 Py_INCREF(Py_None); resultobj = Py_None;
42764 return resultobj;
42765 fail:
42766 return NULL;
42767 }
42768
42769
42770 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
42771 PyObject *resultobj;
42772 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42773 PyObject * obj0 = 0 ;
42774 char *kwnames[] = {
42775 (char *) "self", NULL
42776 };
42777
42778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
42779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42780 if (SWIG_arg_fail(1)) SWIG_fail;
42781 {
42782 PyThreadState* __tstate = wxPyBeginAllowThreads();
42783 (arg1)->Unconstrained();
42784
42785 wxPyEndAllowThreads(__tstate);
42786 if (PyErr_Occurred()) SWIG_fail;
42787 }
42788 Py_INCREF(Py_None); resultobj = Py_None;
42789 return resultobj;
42790 fail:
42791 return NULL;
42792 }
42793
42794
42795 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
42796 PyObject *resultobj;
42797 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42798 PyObject * obj0 = 0 ;
42799 char *kwnames[] = {
42800 (char *) "self", NULL
42801 };
42802
42803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
42804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42805 if (SWIG_arg_fail(1)) SWIG_fail;
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 (arg1)->AsIs();
42809
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 Py_INCREF(Py_None); resultobj = Py_None;
42814 return resultobj;
42815 fail:
42816 return NULL;
42817 }
42818
42819
42820 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42821 PyObject *resultobj;
42822 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42823 wxWindow *result;
42824 PyObject * obj0 = 0 ;
42825 char *kwnames[] = {
42826 (char *) "self", NULL
42827 };
42828
42829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
42830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42831 if (SWIG_arg_fail(1)) SWIG_fail;
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 result = (wxWindow *)(arg1)->GetOtherWindow();
42835
42836 wxPyEndAllowThreads(__tstate);
42837 if (PyErr_Occurred()) SWIG_fail;
42838 }
42839 {
42840 resultobj = wxPyMake_wxObject(result, 0);
42841 }
42842 return resultobj;
42843 fail:
42844 return NULL;
42845 }
42846
42847
42848 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
42849 PyObject *resultobj;
42850 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42851 wxEdge result;
42852 PyObject * obj0 = 0 ;
42853 char *kwnames[] = {
42854 (char *) "self", NULL
42855 };
42856
42857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
42858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(1)) SWIG_fail;
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
42863
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 resultobj = SWIG_From_int((result));
42868 return resultobj;
42869 fail:
42870 return NULL;
42871 }
42872
42873
42874 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
42875 PyObject *resultobj;
42876 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42877 wxEdge arg2 ;
42878 PyObject * obj0 = 0 ;
42879 PyObject * obj1 = 0 ;
42880 char *kwnames[] = {
42881 (char *) "self",(char *) "which", NULL
42882 };
42883
42884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
42885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42886 if (SWIG_arg_fail(1)) SWIG_fail;
42887 {
42888 arg2 = (wxEdge)(SWIG_As_int(obj1));
42889 if (SWIG_arg_fail(2)) SWIG_fail;
42890 }
42891 {
42892 PyThreadState* __tstate = wxPyBeginAllowThreads();
42893 (arg1)->SetEdge((wxEdge )arg2);
42894
42895 wxPyEndAllowThreads(__tstate);
42896 if (PyErr_Occurred()) SWIG_fail;
42897 }
42898 Py_INCREF(Py_None); resultobj = Py_None;
42899 return resultobj;
42900 fail:
42901 return NULL;
42902 }
42903
42904
42905 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
42906 PyObject *resultobj;
42907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42908 int arg2 ;
42909 PyObject * obj0 = 0 ;
42910 PyObject * obj1 = 0 ;
42911 char *kwnames[] = {
42912 (char *) "self",(char *) "v", NULL
42913 };
42914
42915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
42916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42917 if (SWIG_arg_fail(1)) SWIG_fail;
42918 {
42919 arg2 = (int)(SWIG_As_int(obj1));
42920 if (SWIG_arg_fail(2)) SWIG_fail;
42921 }
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 (arg1)->SetValue(arg2);
42925
42926 wxPyEndAllowThreads(__tstate);
42927 if (PyErr_Occurred()) SWIG_fail;
42928 }
42929 Py_INCREF(Py_None); resultobj = Py_None;
42930 return resultobj;
42931 fail:
42932 return NULL;
42933 }
42934
42935
42936 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
42937 PyObject *resultobj;
42938 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42939 int result;
42940 PyObject * obj0 = 0 ;
42941 char *kwnames[] = {
42942 (char *) "self", NULL
42943 };
42944
42945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
42946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42947 if (SWIG_arg_fail(1)) SWIG_fail;
42948 {
42949 PyThreadState* __tstate = wxPyBeginAllowThreads();
42950 result = (int)(arg1)->GetMargin();
42951
42952 wxPyEndAllowThreads(__tstate);
42953 if (PyErr_Occurred()) SWIG_fail;
42954 }
42955 {
42956 resultobj = SWIG_From_int((int)(result));
42957 }
42958 return resultobj;
42959 fail:
42960 return NULL;
42961 }
42962
42963
42964 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
42965 PyObject *resultobj;
42966 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42967 int arg2 ;
42968 PyObject * obj0 = 0 ;
42969 PyObject * obj1 = 0 ;
42970 char *kwnames[] = {
42971 (char *) "self",(char *) "m", NULL
42972 };
42973
42974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
42975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42976 if (SWIG_arg_fail(1)) SWIG_fail;
42977 {
42978 arg2 = (int)(SWIG_As_int(obj1));
42979 if (SWIG_arg_fail(2)) SWIG_fail;
42980 }
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 (arg1)->SetMargin(arg2);
42984
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 Py_INCREF(Py_None); resultobj = Py_None;
42989 return resultobj;
42990 fail:
42991 return NULL;
42992 }
42993
42994
42995 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
42996 PyObject *resultobj;
42997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42998 int result;
42999 PyObject * obj0 = 0 ;
43000 char *kwnames[] = {
43001 (char *) "self", NULL
43002 };
43003
43004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43006 if (SWIG_arg_fail(1)) SWIG_fail;
43007 {
43008 PyThreadState* __tstate = wxPyBeginAllowThreads();
43009 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43010
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 {
43015 resultobj = SWIG_From_int((int)(result));
43016 }
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj;
43025 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43026 int result;
43027 PyObject * obj0 = 0 ;
43028 char *kwnames[] = {
43029 (char *) "self", NULL
43030 };
43031
43032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43034 if (SWIG_arg_fail(1)) SWIG_fail;
43035 {
43036 PyThreadState* __tstate = wxPyBeginAllowThreads();
43037 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43038
43039 wxPyEndAllowThreads(__tstate);
43040 if (PyErr_Occurred()) SWIG_fail;
43041 }
43042 {
43043 resultobj = SWIG_From_int((int)(result));
43044 }
43045 return resultobj;
43046 fail:
43047 return NULL;
43048 }
43049
43050
43051 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43052 PyObject *resultobj;
43053 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43054 int result;
43055 PyObject * obj0 = 0 ;
43056 char *kwnames[] = {
43057 (char *) "self", NULL
43058 };
43059
43060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43062 if (SWIG_arg_fail(1)) SWIG_fail;
43063 {
43064 PyThreadState* __tstate = wxPyBeginAllowThreads();
43065 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43066
43067 wxPyEndAllowThreads(__tstate);
43068 if (PyErr_Occurred()) SWIG_fail;
43069 }
43070 {
43071 resultobj = SWIG_From_int((int)(result));
43072 }
43073 return resultobj;
43074 fail:
43075 return NULL;
43076 }
43077
43078
43079 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43080 PyObject *resultobj;
43081 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43082 bool result;
43083 PyObject * obj0 = 0 ;
43084 char *kwnames[] = {
43085 (char *) "self", NULL
43086 };
43087
43088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43090 if (SWIG_arg_fail(1)) SWIG_fail;
43091 {
43092 PyThreadState* __tstate = wxPyBeginAllowThreads();
43093 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43094
43095 wxPyEndAllowThreads(__tstate);
43096 if (PyErr_Occurred()) SWIG_fail;
43097 }
43098 {
43099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43100 }
43101 return resultobj;
43102 fail:
43103 return NULL;
43104 }
43105
43106
43107 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43108 PyObject *resultobj;
43109 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43110 bool arg2 ;
43111 PyObject * obj0 = 0 ;
43112 PyObject * obj1 = 0 ;
43113 char *kwnames[] = {
43114 (char *) "self",(char *) "d", NULL
43115 };
43116
43117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43119 if (SWIG_arg_fail(1)) SWIG_fail;
43120 {
43121 arg2 = (bool)(SWIG_As_bool(obj1));
43122 if (SWIG_arg_fail(2)) SWIG_fail;
43123 }
43124 {
43125 PyThreadState* __tstate = wxPyBeginAllowThreads();
43126 (arg1)->SetDone(arg2);
43127
43128 wxPyEndAllowThreads(__tstate);
43129 if (PyErr_Occurred()) SWIG_fail;
43130 }
43131 Py_INCREF(Py_None); resultobj = Py_None;
43132 return resultobj;
43133 fail:
43134 return NULL;
43135 }
43136
43137
43138 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43139 PyObject *resultobj;
43140 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43141 wxRelationship result;
43142 PyObject * obj0 = 0 ;
43143 char *kwnames[] = {
43144 (char *) "self", NULL
43145 };
43146
43147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43149 if (SWIG_arg_fail(1)) SWIG_fail;
43150 {
43151 PyThreadState* __tstate = wxPyBeginAllowThreads();
43152 result = (wxRelationship)(arg1)->GetRelationship();
43153
43154 wxPyEndAllowThreads(__tstate);
43155 if (PyErr_Occurred()) SWIG_fail;
43156 }
43157 resultobj = SWIG_From_int((result));
43158 return resultobj;
43159 fail:
43160 return NULL;
43161 }
43162
43163
43164 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43165 PyObject *resultobj;
43166 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43167 wxRelationship arg2 ;
43168 PyObject * obj0 = 0 ;
43169 PyObject * obj1 = 0 ;
43170 char *kwnames[] = {
43171 (char *) "self",(char *) "r", NULL
43172 };
43173
43174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43176 if (SWIG_arg_fail(1)) SWIG_fail;
43177 {
43178 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43179 if (SWIG_arg_fail(2)) SWIG_fail;
43180 }
43181 {
43182 PyThreadState* __tstate = wxPyBeginAllowThreads();
43183 (arg1)->SetRelationship((wxRelationship )arg2);
43184
43185 wxPyEndAllowThreads(__tstate);
43186 if (PyErr_Occurred()) SWIG_fail;
43187 }
43188 Py_INCREF(Py_None); resultobj = Py_None;
43189 return resultobj;
43190 fail:
43191 return NULL;
43192 }
43193
43194
43195 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43196 PyObject *resultobj;
43197 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43198 wxWindow *arg2 = (wxWindow *) 0 ;
43199 bool result;
43200 PyObject * obj0 = 0 ;
43201 PyObject * obj1 = 0 ;
43202 char *kwnames[] = {
43203 (char *) "self",(char *) "otherW", NULL
43204 };
43205
43206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43208 if (SWIG_arg_fail(1)) SWIG_fail;
43209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43210 if (SWIG_arg_fail(2)) SWIG_fail;
43211 {
43212 PyThreadState* __tstate = wxPyBeginAllowThreads();
43213 result = (bool)(arg1)->ResetIfWin(arg2);
43214
43215 wxPyEndAllowThreads(__tstate);
43216 if (PyErr_Occurred()) SWIG_fail;
43217 }
43218 {
43219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43220 }
43221 return resultobj;
43222 fail:
43223 return NULL;
43224 }
43225
43226
43227 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43228 PyObject *resultobj;
43229 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43230 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43231 wxWindow *arg3 = (wxWindow *) 0 ;
43232 bool result;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235 PyObject * obj2 = 0 ;
43236 char *kwnames[] = {
43237 (char *) "self",(char *) "constraints",(char *) "win", NULL
43238 };
43239
43240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43242 if (SWIG_arg_fail(1)) SWIG_fail;
43243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43244 if (SWIG_arg_fail(2)) SWIG_fail;
43245 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43246 if (SWIG_arg_fail(3)) SWIG_fail;
43247 {
43248 PyThreadState* __tstate = wxPyBeginAllowThreads();
43249 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43250
43251 wxPyEndAllowThreads(__tstate);
43252 if (PyErr_Occurred()) SWIG_fail;
43253 }
43254 {
43255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43256 }
43257 return resultobj;
43258 fail:
43259 return NULL;
43260 }
43261
43262
43263 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43264 PyObject *resultobj;
43265 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43266 wxEdge arg2 ;
43267 wxWindow *arg3 = (wxWindow *) 0 ;
43268 wxWindow *arg4 = (wxWindow *) 0 ;
43269 int result;
43270 PyObject * obj0 = 0 ;
43271 PyObject * obj1 = 0 ;
43272 PyObject * obj2 = 0 ;
43273 PyObject * obj3 = 0 ;
43274 char *kwnames[] = {
43275 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43276 };
43277
43278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43280 if (SWIG_arg_fail(1)) SWIG_fail;
43281 {
43282 arg2 = (wxEdge)(SWIG_As_int(obj1));
43283 if (SWIG_arg_fail(2)) SWIG_fail;
43284 }
43285 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43286 if (SWIG_arg_fail(3)) SWIG_fail;
43287 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43288 if (SWIG_arg_fail(4)) SWIG_fail;
43289 {
43290 PyThreadState* __tstate = wxPyBeginAllowThreads();
43291 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43292
43293 wxPyEndAllowThreads(__tstate);
43294 if (PyErr_Occurred()) SWIG_fail;
43295 }
43296 {
43297 resultobj = SWIG_From_int((int)(result));
43298 }
43299 return resultobj;
43300 fail:
43301 return NULL;
43302 }
43303
43304
43305 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43306 PyObject *obj;
43307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43308 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43309 Py_INCREF(obj);
43310 return Py_BuildValue((char *)"");
43311 }
43312 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43313 PyObject *resultobj;
43314 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43315 wxIndividualLayoutConstraint *result;
43316 PyObject * obj0 = 0 ;
43317 char *kwnames[] = {
43318 (char *) "self", NULL
43319 };
43320
43321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43323 if (SWIG_arg_fail(1)) SWIG_fail;
43324 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43325
43326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43327 return resultobj;
43328 fail:
43329 return NULL;
43330 }
43331
43332
43333 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43334 PyObject *resultobj;
43335 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43336 wxIndividualLayoutConstraint *result;
43337 PyObject * obj0 = 0 ;
43338 char *kwnames[] = {
43339 (char *) "self", NULL
43340 };
43341
43342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43344 if (SWIG_arg_fail(1)) SWIG_fail;
43345 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43346
43347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43348 return resultobj;
43349 fail:
43350 return NULL;
43351 }
43352
43353
43354 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43355 PyObject *resultobj;
43356 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43357 wxIndividualLayoutConstraint *result;
43358 PyObject * obj0 = 0 ;
43359 char *kwnames[] = {
43360 (char *) "self", NULL
43361 };
43362
43363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43365 if (SWIG_arg_fail(1)) SWIG_fail;
43366 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43367
43368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43369 return resultobj;
43370 fail:
43371 return NULL;
43372 }
43373
43374
43375 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43376 PyObject *resultobj;
43377 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43378 wxIndividualLayoutConstraint *result;
43379 PyObject * obj0 = 0 ;
43380 char *kwnames[] = {
43381 (char *) "self", NULL
43382 };
43383
43384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43386 if (SWIG_arg_fail(1)) SWIG_fail;
43387 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43388
43389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43390 return resultobj;
43391 fail:
43392 return NULL;
43393 }
43394
43395
43396 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43397 PyObject *resultobj;
43398 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43399 wxIndividualLayoutConstraint *result;
43400 PyObject * obj0 = 0 ;
43401 char *kwnames[] = {
43402 (char *) "self", NULL
43403 };
43404
43405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43407 if (SWIG_arg_fail(1)) SWIG_fail;
43408 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43409
43410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43411 return resultobj;
43412 fail:
43413 return NULL;
43414 }
43415
43416
43417 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43418 PyObject *resultobj;
43419 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43420 wxIndividualLayoutConstraint *result;
43421 PyObject * obj0 = 0 ;
43422 char *kwnames[] = {
43423 (char *) "self", NULL
43424 };
43425
43426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43428 if (SWIG_arg_fail(1)) SWIG_fail;
43429 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43430
43431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43432 return resultobj;
43433 fail:
43434 return NULL;
43435 }
43436
43437
43438 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43439 PyObject *resultobj;
43440 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43441 wxIndividualLayoutConstraint *result;
43442 PyObject * obj0 = 0 ;
43443 char *kwnames[] = {
43444 (char *) "self", NULL
43445 };
43446
43447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43449 if (SWIG_arg_fail(1)) SWIG_fail;
43450 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43451
43452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43453 return resultobj;
43454 fail:
43455 return NULL;
43456 }
43457
43458
43459 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43460 PyObject *resultobj;
43461 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43462 wxIndividualLayoutConstraint *result;
43463 PyObject * obj0 = 0 ;
43464 char *kwnames[] = {
43465 (char *) "self", NULL
43466 };
43467
43468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43470 if (SWIG_arg_fail(1)) SWIG_fail;
43471 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43472
43473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43474 return resultobj;
43475 fail:
43476 return NULL;
43477 }
43478
43479
43480 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43481 PyObject *resultobj;
43482 wxLayoutConstraints *result;
43483 char *kwnames[] = {
43484 NULL
43485 };
43486
43487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
43488 {
43489 PyThreadState* __tstate = wxPyBeginAllowThreads();
43490 result = (wxLayoutConstraints *)new wxLayoutConstraints();
43491
43492 wxPyEndAllowThreads(__tstate);
43493 if (PyErr_Occurred()) SWIG_fail;
43494 }
43495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
43496 return resultobj;
43497 fail:
43498 return NULL;
43499 }
43500
43501
43502 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43503 PyObject *resultobj;
43504 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43505 wxWindow *arg2 = (wxWindow *) 0 ;
43506 int *arg3 = (int *) 0 ;
43507 bool result;
43508 int temp3 ;
43509 int res3 = 0 ;
43510 PyObject * obj0 = 0 ;
43511 PyObject * obj1 = 0 ;
43512 char *kwnames[] = {
43513 (char *) "self",(char *) "win", NULL
43514 };
43515
43516 arg3 = &temp3; res3 = SWIG_NEWOBJ;
43517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
43518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43519 if (SWIG_arg_fail(1)) SWIG_fail;
43520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43521 if (SWIG_arg_fail(2)) SWIG_fail;
43522 {
43523 PyThreadState* __tstate = wxPyBeginAllowThreads();
43524 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
43525
43526 wxPyEndAllowThreads(__tstate);
43527 if (PyErr_Occurred()) SWIG_fail;
43528 }
43529 {
43530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43531 }
43532 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
43533 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
43541 PyObject *resultobj;
43542 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43543 bool result;
43544 PyObject * obj0 = 0 ;
43545 char *kwnames[] = {
43546 (char *) "self", NULL
43547 };
43548
43549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
43550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43551 if (SWIG_arg_fail(1)) SWIG_fail;
43552 {
43553 PyThreadState* __tstate = wxPyBeginAllowThreads();
43554 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
43555
43556 wxPyEndAllowThreads(__tstate);
43557 if (PyErr_Occurred()) SWIG_fail;
43558 }
43559 {
43560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43561 }
43562 return resultobj;
43563 fail:
43564 return NULL;
43565 }
43566
43567
43568 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
43569 PyObject *obj;
43570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43571 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
43572 Py_INCREF(obj);
43573 return Py_BuildValue((char *)"");
43574 }
43575 static PyMethodDef SwigMethods[] = {
43576 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
43577 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
43578 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
43579 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
43580 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
43581 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43582 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43583 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43584 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43585 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43586 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43587 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43588 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43589 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43590 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43591 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
43592 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
43593 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43594 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43595 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43596 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43597 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43598 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
43599 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
43600 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43601 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
43602 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43603 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43604 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43605 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43606 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43607 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43608 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43609 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43610 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43611 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43612 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43613 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43614 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
43615 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43616 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43617 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43618 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43619 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43620 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43621 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43622 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43623 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43624 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43625 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43626 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43627 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43628 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43629 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
43630 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43631 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
43632 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
43633 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
43634 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43635 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
43636 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
43637 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
43638 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
43639 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43640 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43641 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43642 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43643 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43644 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43645 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43646 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43647 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43648 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43649 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43650 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43651 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43652 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43653 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43654 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43655 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43656 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43657 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43658 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43659 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
43660 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
43661 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
43662 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
43663 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
43664 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
43665 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43666 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43667 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43668 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43669 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
43670 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
43671 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
43672 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43673 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43674 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43675 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43676 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43677 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43678 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43679 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43680 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43681 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43682 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
43683 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
43684 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
43685 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
43686 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43687 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
43688 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
43689 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43690 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43691 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43692 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43693 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
43694 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
43695 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43696 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43697 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
43698 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43699 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43700 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
43701 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
43702 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43703 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43704 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43705 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43706 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43707 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43708 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43709 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43710 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
43711 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43712 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43713 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
43714 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
43715 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
43716 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
43717 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
43718 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
43719 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
43720 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
43721 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
43722 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
43723 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
43724 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
43725 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
43726 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
43727 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
43728 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
43729 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
43730 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
43731 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
43732 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43733 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43734 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
43735 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
43736 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43737 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43738 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
43739 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
43740 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
43741 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43742 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
43743 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43744 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43745 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43746 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43747 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
43748 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43749 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43750 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43751 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
43752 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
43753 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
43754 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
43755 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
43756 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
43757 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43758 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43759 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43760 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43761 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
43762 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
43763 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
43764 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
43765 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43766 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43767 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43768 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
43769 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43770 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43771 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43772 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43773 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43774 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
43775 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
43776 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
43777 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
43778 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43779 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
43780 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43781 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43782 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43783 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43784 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
43785 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
43786 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
43787 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
43788 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
43789 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
43790 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
43791 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
43792 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
43793 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
43794 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
43795 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
43796 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
43797 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
43798 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
43799 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
43800 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
43801 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
43802 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
43803 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
43804 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
43805 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
43806 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
43807 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
43808 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
43809 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
43810 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
43811 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
43812 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
43813 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
43814 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
43815 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
43816 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
43817 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
43818 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
43819 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
43820 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
43821 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
43822 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
43823 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
43824 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
43825 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
43826 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
43827 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
43828 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
43829 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
43830 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
43831 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
43832 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
43833 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
43834 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43835 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43836 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43837 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
43838 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
43839 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
43840 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
43841 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
43842 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
43843 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
43844 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
43845 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
43846 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
43847 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
43848 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
43849 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
43850 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
43851 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
43852 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
43853 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
43854 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
43855 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
43856 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
43857 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
43858 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
43859 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
43860 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
43861 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
43862 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
43863 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
43864 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
43865 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
43866 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43867 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43868 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43869 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
43870 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
43871 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
43872 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
43873 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43874 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
43875 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43876 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
43877 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43878 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
43879 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43880 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
43881 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43882 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
43883 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43884 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
43885 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43886 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
43887 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43888 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
43889 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43890 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
43891 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43892 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
43893 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43894 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
43895 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
43896 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
43897 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43898 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43899 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43900 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43901 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43902 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
43903 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
43904 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43905 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43906 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
43907 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
43908 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
43909 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
43910 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
43911 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
43912 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
43913 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
43914 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
43915 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
43916 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
43917 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
43918 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
43919 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
43920 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
43921 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43922 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
43923 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
43924 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
43925 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
43926 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
43927 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
43928 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
43929 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
43930 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
43931 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
43932 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
43933 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
43934 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
43935 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43936 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
43937 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
43938 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
43939 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
43940 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
43941 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
43942 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
43943 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
43944 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
43945 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
43946 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
43947 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43948 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
43949 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
43950 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
43951 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
43952 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43953 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
43954 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43955 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
43956 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43957 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
43958 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43959 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
43960 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43961 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
43962 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43963 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
43964 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
43965 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
43966 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
43967 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
43968 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
43969 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
43970 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
43971 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
43972 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
43973 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
43974 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
43975 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
43976 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
43977 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
43978 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
43979 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
43980 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
43981 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
43982 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
43983 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
43984 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
43985 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
43986 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
43987 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
43988 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
43989 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
43990 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
43991 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
43992 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
43993 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43994 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
43995 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43996 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
43997 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
43998 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
43999 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44000 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44001 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44002 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44003 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44004 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44005 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44006 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44007 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44008 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44009 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44010 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44011 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44012 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44013 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44014 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44015 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44016 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44017 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44018 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44019 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44020 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44021 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44022 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44023 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44024 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44025 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44026 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44027 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44028 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44029 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44030 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44031 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44032 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44033 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44034 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44035 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44036 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44037 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44038 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44039 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44040 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44041 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44042 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44043 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44044 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44045 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44046 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44047 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44048 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44049 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44050 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44051 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44052 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44053 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44054 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44055 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44056 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44057 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44058 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44059 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44060 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44061 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44062 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44063 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44064 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44065 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44066 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44067 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44068 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44069 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44070 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44071 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44072 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44073 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44074 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44075 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44076 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44077 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44078 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44079 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44080 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44081 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44082 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44083 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44084 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44085 { (char *)"MoveEvent_m_pos_set", (PyCFunction) _wrap_MoveEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
44086 { (char *)"MoveEvent_m_pos_get", (PyCFunction) _wrap_MoveEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
44087 { (char *)"MoveEvent_m_rect_set", (PyCFunction) _wrap_MoveEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44088 { (char *)"MoveEvent_m_rect_get", (PyCFunction) _wrap_MoveEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44089 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44090 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44091 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44092 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44093 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44094 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44097 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44098 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44100 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44101 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44102 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44104 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44105 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44106 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44107 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44108 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44109 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44110 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44112 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44114 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44115 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44116 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44117 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44118 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44119 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44120 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44121 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44122 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44123 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44125 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44126 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44127 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44128 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44129 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44131 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44133 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44135 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44136 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44137 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44139 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44141 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44143 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44145 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44147 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44150 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44152 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44153 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44154 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44157 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44159 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44160 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44161 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44163 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44167 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44171 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44176 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44177 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44179 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44182 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44186 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44189 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44193 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44198 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44203 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44208 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44214 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44224 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44248 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44268 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44269 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44275 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44279 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44289 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44312 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44458 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
44498 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
44512 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
44515 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
44570 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
44597 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
44627 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
44635 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
44652 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
44653 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
44690 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
44720 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
44723 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
44727 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
44730 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
44740 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
44752 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
44762 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
44772 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
44786 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
44793 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
44794 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
44795 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
44796 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
44797 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
44802 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
44829 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
44841 { NULL, NULL, 0, NULL }
44842 };
44843
44844
44845 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
44846
44847 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
44848 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
44849 }
44850 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
44851 return (void *)((wxSizer *) ((wxBoxSizer *) x));
44852 }
44853 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
44854 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
44855 }
44856 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
44857 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
44858 }
44859 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
44860 return (void *)((wxSizer *) ((wxGridSizer *) x));
44861 }
44862 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
44863 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
44864 }
44865 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
44866 return (void *)((wxSizer *) ((wxPySizer *) x));
44867 }
44868 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
44869 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
44870 }
44871 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
44872 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
44873 }
44874 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
44875 return (void *)((wxEvent *) ((wxMenuEvent *) x));
44876 }
44877 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
44878 return (void *)((wxEvent *) ((wxCloseEvent *) x));
44879 }
44880 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
44881 return (void *)((wxEvent *) ((wxMouseEvent *) x));
44882 }
44883 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
44884 return (void *)((wxEvent *) ((wxEraseEvent *) x));
44885 }
44886 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
44887 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
44888 }
44889 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
44890 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
44891 }
44892 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
44893 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
44894 }
44895 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
44896 return (void *)((wxEvent *) ((wxPyEvent *) x));
44897 }
44898 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
44899 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
44900 }
44901 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
44902 return (void *)((wxEvent *) ((wxIdleEvent *) x));
44903 }
44904 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
44905 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
44906 }
44907 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
44908 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
44909 }
44910 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
44911 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
44912 }
44913 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
44914 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
44915 }
44916 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
44917 return (void *)((wxEvent *) ((wxActivateEvent *) x));
44918 }
44919 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
44920 return (void *)((wxEvent *) ((wxSizeEvent *) x));
44921 }
44922 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
44923 return (void *)((wxEvent *) ((wxMoveEvent *) x));
44924 }
44925 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
44926 return (void *)((wxEvent *) ((wxPaintEvent *) x));
44927 }
44928 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
44929 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
44930 }
44931 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
44932 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
44933 }
44934 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
44935 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
44936 }
44937 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
44938 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
44939 }
44940 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
44941 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
44942 }
44943 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
44944 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
44945 }
44946 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
44947 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
44948 }
44949 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
44950 return (void *)((wxEvent *) ((wxFocusEvent *) x));
44951 }
44952 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
44953 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
44954 }
44955 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
44956 return (void *)((wxEvent *) ((wxShowEvent *) x));
44957 }
44958 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
44959 return (void *)((wxEvent *) ((wxCommandEvent *) x));
44960 }
44961 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
44962 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
44963 }
44964 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
44965 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
44966 }
44967 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
44968 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
44969 }
44970 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
44971 return (void *)((wxEvent *) ((wxKeyEvent *) x));
44972 }
44973 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
44974 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
44975 }
44976 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
44977 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
44978 }
44979 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
44980 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
44981 }
44982 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
44983 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
44984 }
44985 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
44986 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
44987 }
44988 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
44989 return (void *)((wxControl *) ((wxControlWithItems *) x));
44990 }
44991 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
44992 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
44993 }
44994 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
44995 return (void *)((wxEvtHandler *) ((wxWindow *) x));
44996 }
44997 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
44998 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
44999 }
45000 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45001 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45002 }
45003 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45004 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45005 }
45006 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45007 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45008 }
45009 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45010 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45011 }
45012 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45013 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45014 }
45015 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45016 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45017 }
45018 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45019 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45020 }
45021 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45022 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45023 }
45024 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45025 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45026 }
45027 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45028 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45029 }
45030 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45031 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45032 }
45033 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45034 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45035 }
45036 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45037 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45038 }
45039 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45040 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45041 }
45042 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45043 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45044 }
45045 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45046 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45047 }
45048 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45049 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45050 }
45051 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45052 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45053 }
45054 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45055 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45056 }
45057 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45058 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45059 }
45060 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45061 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45062 }
45063 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45064 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45065 }
45066 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45067 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45068 }
45069 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45070 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45071 }
45072 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45073 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45074 }
45075 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45076 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45077 }
45078 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45079 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45080 }
45081 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45082 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45083 }
45084 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45085 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45086 }
45087 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45088 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45089 }
45090 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45091 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45092 }
45093 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45094 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45095 }
45096 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45097 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45098 }
45099 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45100 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45101 }
45102 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45103 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45104 }
45105 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45106 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45107 }
45108 static void *_p_wxSizerTo_p_wxObject(void *x) {
45109 return (void *)((wxObject *) ((wxSizer *) x));
45110 }
45111 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45112 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45113 }
45114 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45115 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45116 }
45117 static void *_p_wxMenuTo_p_wxObject(void *x) {
45118 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45119 }
45120 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45121 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45122 }
45123 static void *_p_wxImageTo_p_wxObject(void *x) {
45124 return (void *)((wxObject *) ((wxImage *) x));
45125 }
45126 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45127 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45128 }
45129 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45130 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45131 }
45132 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45133 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45134 }
45135 static void *_p_wxWindowTo_p_wxObject(void *x) {
45136 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45137 }
45138 static void *_p_wxControlTo_p_wxObject(void *x) {
45139 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45140 }
45141 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45142 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45143 }
45144 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45145 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45146 }
45147 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45148 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45149 }
45150 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45151 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45152 }
45153 static void *_p_wxEventTo_p_wxObject(void *x) {
45154 return (void *)((wxObject *) ((wxEvent *) x));
45155 }
45156 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45157 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45158 }
45159 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45160 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45161 }
45162 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45163 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45164 }
45165 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45166 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45167 }
45168 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45169 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45170 }
45171 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45172 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45173 }
45174 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45175 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45176 }
45177 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45178 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45179 }
45180 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45181 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45182 }
45183 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45184 return (void *)((wxObject *) ((wxEvtHandler *) x));
45185 }
45186 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45187 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45188 }
45189 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45190 return (void *)((wxObject *) ((wxImageHandler *) x));
45191 }
45192 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45193 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45194 }
45195 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45196 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45197 }
45198 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45199 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45200 }
45201 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45202 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45203 }
45204 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45205 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45206 }
45207 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45208 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45209 }
45210 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45211 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45212 }
45213 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45214 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45215 }
45216 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45217 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45218 }
45219 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45220 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45221 }
45222 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45223 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45224 }
45225 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45226 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45227 }
45228 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45229 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45230 }
45231 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45232 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45233 }
45234 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45235 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45236 }
45237 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45238 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45239 }
45240 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45241 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45242 }
45243 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45244 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45245 }
45246 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45247 return (void *)((wxObject *) ((wxFileSystem *) x));
45248 }
45249 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45250 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45251 }
45252 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45253 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45254 }
45255 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45256 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45257 }
45258 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45259 return (void *)((wxObject *) ((wxSizerItem *) x));
45260 }
45261 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45262 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45263 }
45264 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45265 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45266 }
45267 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45268 return (void *)((wxObject *) ((wxFSFile *) x));
45269 }
45270 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45271 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45272 }
45273 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45274 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45275 }
45276 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45277 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45278 }
45279 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45280 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45281 }
45282 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45284 }
45285 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45286 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45287 }
45288 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45289 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45290 }
45291 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45292 return (void *)((wxObject *) ((wxMenuItem *) x));
45293 }
45294 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45295 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45296 }
45297 static void *_p_wxControlTo_p_wxWindow(void *x) {
45298 return (void *)((wxWindow *) ((wxControl *) x));
45299 }
45300 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45301 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45302 }
45303 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45304 return (void *)((wxWindow *) ((wxMenuBar *) x));
45305 }
45306 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45307 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45308 }
45309 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45310 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45311 }
45312 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45313 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45314 }
45315 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45316 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45317 }
45318 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45319 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45320 }
45321 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45322 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45323 }
45324 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45325 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45326 }
45327 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45328 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45329 }
45330 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45331 return (void *)((wxValidator *) ((wxPyValidator *) x));
45332 }
45333 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}};
45334 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}};
45335 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}};
45336 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}};
45337 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}};
45338 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}};
45339 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}};
45340 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_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}};
45341 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},{0, 0, 0, 0, 0, 0, 0}};
45342 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}};
45343 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}};
45344 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}};
45345 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}};
45346 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_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_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_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_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}};
45347 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}};
45348 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}};
45349 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}};
45350 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}};
45351 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}};
45352 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}};
45353 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}};
45354 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}};
45355 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}};
45356 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}};
45357 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}};
45358 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}};
45359 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}};
45360 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}};
45361 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}};
45362 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}};
45363 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}};
45364 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}};
45365 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}};
45366 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}};
45367 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}};
45368 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}};
45369 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}};
45370 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}};
45371 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}};
45372 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}};
45373 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}};
45374 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}};
45375 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}};
45376 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}};
45377 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}};
45378 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}};
45379 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}};
45380 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}};
45381 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}};
45382 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}};
45383 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}};
45384 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}};
45385 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}};
45386 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}};
45387 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}};
45388 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}};
45389 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}};
45390 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}};
45391 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}};
45392 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}};
45393 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}};
45394 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}};
45395 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}};
45396 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}};
45397 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}};
45398 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}};
45399 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}};
45400 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}};
45401 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}};
45402 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}};
45403 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}};
45404 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}};
45405 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}};
45406 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}};
45407 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}};
45408 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}};
45409 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}};
45410 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}};
45411 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}};
45412 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}};
45413 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}};
45414 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}};
45415 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}};
45416 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}};
45417 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}};
45418 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}};
45419 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}};
45420 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}};
45421 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}};
45422 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}};
45423 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}};
45424 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_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_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_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_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_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_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_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}};
45425 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}};
45426 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}};
45427 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}};
45428 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}};
45429 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}};
45430 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}};
45431 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}};
45432 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}};
45433 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}};
45434 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}};
45435 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}};
45436 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}};
45437 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}};
45438 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}};
45439 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}};
45440 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}};
45441 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}};
45442 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}};
45443 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}};
45444 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}};
45445 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}};
45446 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_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}};
45447 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}};
45448 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}};
45449 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}};
45450 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}};
45451 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}};
45452 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}};
45453 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}};
45454 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}};
45455 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}};
45456 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}};
45457
45458 static swig_type_info *swig_types_initial[] = {
45459 _swigt__p_wxLayoutConstraints,
45460 _swigt__p_wxRealPoint,
45461 _swigt__p_wxSizerItem,
45462 _swigt__p_wxGBSizerItem,
45463 _swigt__p_wxScrollEvent,
45464 _swigt__p_wxEventLoop,
45465 _swigt__p_wxIndividualLayoutConstraint,
45466 _swigt__p_wxSizer,
45467 _swigt__p_wxBoxSizer,
45468 _swigt__p_wxStaticBoxSizer,
45469 _swigt__p_wxGridBagSizer,
45470 _swigt__p_wxAcceleratorEntry,
45471 _swigt__p_wxUpdateUIEvent,
45472 _swigt__p_wxEvent,
45473 _swigt__p_wxMenu,
45474 _swigt__p_wxGridSizer,
45475 _swigt__p_wxFlexGridSizer,
45476 _swigt__p_wxInitDialogEvent,
45477 _swigt__p_wxItemContainer,
45478 _swigt__p_wxNcPaintEvent,
45479 _swigt__p_wxPaintEvent,
45480 _swigt__p_wxSysColourChangedEvent,
45481 _swigt__p_wxMouseCaptureChangedEvent,
45482 _swigt__p_wxDisplayChangedEvent,
45483 _swigt__p_wxPaletteChangedEvent,
45484 _swigt__p_wxControl,
45485 _swigt__p_wxFont,
45486 _swigt__p_wxMenuBarBase,
45487 _swigt__p_wxSetCursorEvent,
45488 _swigt__p_wxFSFile,
45489 _swigt__p_wxCaret,
45490 _swigt__ptrdiff_t,
45491 _swigt__std__ptrdiff_t,
45492 _swigt__p_wxRegion,
45493 _swigt__p_wxPoint2D,
45494 _swigt__p_int,
45495 _swigt__p_wxSize,
45496 _swigt__p_wxDC,
45497 _swigt__p_wxPySizer,
45498 _swigt__p_wxVisualAttributes,
45499 _swigt__p_wxNotifyEvent,
45500 _swigt__p_wxPyEvent,
45501 _swigt__p_wxPropagationDisabler,
45502 _swigt__p_form_ops_t,
45503 _swigt__p_wxAppTraits,
45504 _swigt__p_wxArrayString,
45505 _swigt__p_wxShowEvent,
45506 _swigt__p_wxToolTip,
45507 _swigt__p_wxMoveEvent,
45508 _swigt__p_wxSizeEvent,
45509 _swigt__p_wxActivateEvent,
45510 _swigt__p_wxIconizeEvent,
45511 _swigt__p_wxMaximizeEvent,
45512 _swigt__p_wxQueryNewPaletteEvent,
45513 _swigt__p_wxWindowCreateEvent,
45514 _swigt__p_wxIdleEvent,
45515 _swigt__p_wxMenuItem,
45516 _swigt__p_wxStaticBox,
45517 _swigt__p_long,
45518 _swigt__p_wxDuplexMode,
45519 _swigt__p_wxTIFFHandler,
45520 _swigt__p_wxXPMHandler,
45521 _swigt__p_wxPNMHandler,
45522 _swigt__p_wxJPEGHandler,
45523 _swigt__p_wxPCXHandler,
45524 _swigt__p_wxGIFHandler,
45525 _swigt__p_wxPNGHandler,
45526 _swigt__p_wxANIHandler,
45527 _swigt__p_wxMemoryFSHandler,
45528 _swigt__p_wxZipFSHandler,
45529 _swigt__p_wxInternetFSHandler,
45530 _swigt__p_wxPyFileSystemHandler,
45531 _swigt__p_wxEvtHandler,
45532 _swigt__p_wxCURHandler,
45533 _swigt__p_wxICOHandler,
45534 _swigt__p_wxBMPHandler,
45535 _swigt__p_wxImageHandler,
45536 _swigt__p_wxFileSystemHandler,
45537 _swigt__p_wxRect,
45538 _swigt__p_wxGBSpan,
45539 _swigt__p_wxPropagateOnce,
45540 _swigt__p_wxAcceleratorTable,
45541 _swigt__p_char,
45542 _swigt__p_wxGBPosition,
45543 _swigt__p_wxImage,
45544 _swigt__p_wxFrame,
45545 _swigt__p_wxScrollWinEvent,
45546 _swigt__p_wxPaperSize,
45547 _swigt__p_wxImageHistogram,
45548 _swigt__p_wxPoint,
45549 _swigt__p_wxCursor,
45550 _swigt__p_wxObject,
45551 _swigt__p_wxInputStream,
45552 _swigt__p_wxOutputStream,
45553 _swigt__p_wxPyInputStream,
45554 _swigt__p_wxDateTime,
45555 _swigt__p_wxKeyEvent,
45556 _swigt__p_wxNavigationKeyEvent,
45557 _swigt__p_wxWindowDestroyEvent,
45558 _swigt__p_unsigned_long,
45559 _swigt__p_wxWindow,
45560 _swigt__p_wxMenuBar,
45561 _swigt__p_wxFileSystem,
45562 _swigt__p_wxBitmap,
45563 _swigt__unsigned_int,
45564 _swigt__p_unsigned_int,
45565 _swigt__p_wxMenuEvent,
45566 _swigt__p_wxContextMenuEvent,
45567 _swigt__p_unsigned_char,
45568 _swigt__p_wxEraseEvent,
45569 _swigt__p_wxMouseEvent,
45570 _swigt__p_wxCloseEvent,
45571 _swigt__p_wxPyApp,
45572 _swigt__p_wxCommandEvent,
45573 _swigt__p_wxPyCommandEvent,
45574 _swigt__p_wxPyDropTarget,
45575 _swigt__p_wxQuantize,
45576 _swigt__p_wxChildFocusEvent,
45577 _swigt__p_wxFocusEvent,
45578 _swigt__p_wxDropFilesEvent,
45579 _swigt__p_wxControlWithItems,
45580 _swigt__p_wxColour,
45581 _swigt__p_wxValidator,
45582 _swigt__p_wxPyValidator,
45583 0
45584 };
45585
45586
45587 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
45588
45589 static swig_const_info swig_const_table[] = {
45590 {0, 0, 0, 0.0, 0, 0}};
45591
45592 #ifdef __cplusplus
45593 }
45594 #endif
45595
45596
45597 #ifdef __cplusplus
45598 extern "C" {
45599 #endif
45600
45601 /* Python-specific SWIG API */
45602 #define SWIG_newvarlink() SWIG_Python_newvarlink()
45603 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
45604 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
45605
45606 /* -----------------------------------------------------------------------------
45607 * global variable support code.
45608 * ----------------------------------------------------------------------------- */
45609
45610 typedef struct swig_globalvar {
45611 char *name; /* Name of global variable */
45612 PyObject *(*get_attr)(); /* Return the current value */
45613 int (*set_attr)(PyObject *); /* Set the value */
45614 struct swig_globalvar *next;
45615 } swig_globalvar;
45616
45617 typedef struct swig_varlinkobject {
45618 PyObject_HEAD
45619 swig_globalvar *vars;
45620 } swig_varlinkobject;
45621
45622 static PyObject *
45623 swig_varlink_repr(swig_varlinkobject *v) {
45624 v = v;
45625 return PyString_FromString("<Swig global variables>");
45626 }
45627
45628 static int
45629 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
45630 swig_globalvar *var;
45631 flags = flags;
45632 fprintf(fp,"Swig global variables { ");
45633 for (var = v->vars; var; var=var->next) {
45634 fprintf(fp,"%s", var->name);
45635 if (var->next) fprintf(fp,", ");
45636 }
45637 fprintf(fp," }\n");
45638 return 0;
45639 }
45640
45641 static PyObject *
45642 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
45643 swig_globalvar *var = v->vars;
45644 while (var) {
45645 if (strcmp(var->name,n) == 0) {
45646 return (*var->get_attr)();
45647 }
45648 var = var->next;
45649 }
45650 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45651 return NULL;
45652 }
45653
45654 static int
45655 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
45656 swig_globalvar *var = v->vars;
45657 while (var) {
45658 if (strcmp(var->name,n) == 0) {
45659 return (*var->set_attr)(p);
45660 }
45661 var = var->next;
45662 }
45663 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45664 return 1;
45665 }
45666
45667 static PyTypeObject varlinktype = {
45668 PyObject_HEAD_INIT(0)
45669 0, /* Number of items in variable part (ob_size) */
45670 (char *)"swigvarlink", /* Type name (tp_name) */
45671 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
45672 0, /* Itemsize (tp_itemsize) */
45673 0, /* Deallocator (tp_dealloc) */
45674 (printfunc) swig_varlink_print, /* Print (tp_print) */
45675 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
45676 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
45677 0, /* tp_compare */
45678 (reprfunc) swig_varlink_repr, /* tp_repr */
45679 0, /* tp_as_number */
45680 0, /* tp_as_sequence */
45681 0, /* tp_as_mapping */
45682 0, /* tp_hash */
45683 0, /* tp_call */
45684 0, /* tp_str */
45685 0, /* tp_getattro */
45686 0, /* tp_setattro */
45687 0, /* tp_as_buffer */
45688 0, /* tp_flags */
45689 0, /* tp_doc */
45690 #if PY_VERSION_HEX >= 0x02000000
45691 0, /* tp_traverse */
45692 0, /* tp_clear */
45693 #endif
45694 #if PY_VERSION_HEX >= 0x02010000
45695 0, /* tp_richcompare */
45696 0, /* tp_weaklistoffset */
45697 #endif
45698 #if PY_VERSION_HEX >= 0x02020000
45699 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
45700 #endif
45701 #if PY_VERSION_HEX >= 0x02030000
45702 0, /* tp_del */
45703 #endif
45704 #ifdef COUNT_ALLOCS
45705 0,0,0,0 /* tp_alloc -> tp_next */
45706 #endif
45707 };
45708
45709 /* Create a variable linking object for use later */
45710 static PyObject *
45711 SWIG_Python_newvarlink(void) {
45712 swig_varlinkobject *result = 0;
45713 result = PyMem_NEW(swig_varlinkobject,1);
45714 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
45715 result->ob_type = &varlinktype;
45716 result->vars = 0;
45717 result->ob_refcnt = 0;
45718 Py_XINCREF((PyObject *) result);
45719 return ((PyObject*) result);
45720 }
45721
45722 static void
45723 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
45724 swig_varlinkobject *v;
45725 swig_globalvar *gv;
45726 v= (swig_varlinkobject *) p;
45727 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
45728 gv->name = (char *) malloc(strlen(name)+1);
45729 strcpy(gv->name,name);
45730 gv->get_attr = get_attr;
45731 gv->set_attr = set_attr;
45732 gv->next = v->vars;
45733 v->vars = gv;
45734 }
45735
45736 /* -----------------------------------------------------------------------------
45737 * constants/methods manipulation
45738 * ----------------------------------------------------------------------------- */
45739
45740 /* Install Constants */
45741 static void
45742 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
45743 PyObject *obj = 0;
45744 size_t i;
45745 for (i = 0; constants[i].type; i++) {
45746 switch(constants[i].type) {
45747 case SWIG_PY_INT:
45748 obj = PyInt_FromLong(constants[i].lvalue);
45749 break;
45750 case SWIG_PY_FLOAT:
45751 obj = PyFloat_FromDouble(constants[i].dvalue);
45752 break;
45753 case SWIG_PY_STRING:
45754 if (constants[i].pvalue) {
45755 obj = PyString_FromString((char *) constants[i].pvalue);
45756 } else {
45757 Py_INCREF(Py_None);
45758 obj = Py_None;
45759 }
45760 break;
45761 case SWIG_PY_POINTER:
45762 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
45763 break;
45764 case SWIG_PY_BINARY:
45765 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
45766 break;
45767 default:
45768 obj = 0;
45769 break;
45770 }
45771 if (obj) {
45772 PyDict_SetItemString(d,constants[i].name,obj);
45773 Py_DECREF(obj);
45774 }
45775 }
45776 }
45777
45778 /* -----------------------------------------------------------------------------*/
45779 /* Fix SwigMethods to carry the callback ptrs when needed */
45780 /* -----------------------------------------------------------------------------*/
45781
45782 static void
45783 SWIG_Python_FixMethods(PyMethodDef *methods,
45784 swig_const_info *const_table,
45785 swig_type_info **types,
45786 swig_type_info **types_initial) {
45787 size_t i;
45788 for (i = 0; methods[i].ml_name; ++i) {
45789 char *c = methods[i].ml_doc;
45790 if (c && (c = strstr(c, "swig_ptr: "))) {
45791 int j;
45792 swig_const_info *ci = 0;
45793 char *name = c + 10;
45794 for (j = 0; const_table[j].type; j++) {
45795 if (strncmp(const_table[j].name, name,
45796 strlen(const_table[j].name)) == 0) {
45797 ci = &(const_table[j]);
45798 break;
45799 }
45800 }
45801 if (ci) {
45802 size_t shift = (ci->ptype) - types;
45803 swig_type_info *ty = types_initial[shift];
45804 size_t ldoc = (c - methods[i].ml_doc);
45805 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
45806 char *ndoc = (char*)malloc(ldoc + lptr + 10);
45807 char *buff = ndoc;
45808 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
45809 strncpy(buff, methods[i].ml_doc, ldoc);
45810 buff += ldoc;
45811 strncpy(buff, "swig_ptr: ", 10);
45812 buff += 10;
45813 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
45814 methods[i].ml_doc = ndoc;
45815 }
45816 }
45817 }
45818 }
45819
45820 /* -----------------------------------------------------------------------------*
45821 * Initialize type list
45822 * -----------------------------------------------------------------------------*/
45823
45824 #if PY_MAJOR_VERSION < 2
45825 /* PyModule_AddObject function was introduced in Python 2.0. The following function
45826 is copied out of Python/modsupport.c in python version 2.3.4 */
45827 static int
45828 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
45829 {
45830 PyObject *dict;
45831 if (!PyModule_Check(m)) {
45832 PyErr_SetString(PyExc_TypeError,
45833 "PyModule_AddObject() needs module as first arg");
45834 return -1;
45835 }
45836 if (!o) {
45837 PyErr_SetString(PyExc_TypeError,
45838 "PyModule_AddObject() needs non-NULL value");
45839 return -1;
45840 }
45841
45842 dict = PyModule_GetDict(m);
45843 if (dict == NULL) {
45844 /* Internal error -- modules must have a dict! */
45845 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
45846 PyModule_GetName(m));
45847 return -1;
45848 }
45849 if (PyDict_SetItemString(dict, name, o))
45850 return -1;
45851 Py_DECREF(o);
45852 return 0;
45853 }
45854 #endif
45855
45856 static swig_type_info **
45857 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
45858 static PyMethodDef swig_empty_runtime_method_table[] = {
45859 {
45860 NULL, NULL, 0, NULL
45861 }
45862 };/* Sentinel */
45863
45864 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
45865 swig_empty_runtime_method_table);
45866 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
45867 if (pointer && module) {
45868 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
45869 }
45870 return type_list_handle;
45871 }
45872
45873 static swig_type_info **
45874 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
45875 swig_type_info **type_pointer;
45876
45877 /* first check if module already created */
45878 type_pointer = SWIG_Python_GetTypeListHandle();
45879 if (type_pointer) {
45880 return type_pointer;
45881 } else {
45882 /* create a new module and variable */
45883 return SWIG_Python_SetTypeListHandle(type_list_handle);
45884 }
45885 }
45886
45887 #ifdef __cplusplus
45888 }
45889 #endif
45890
45891 /* -----------------------------------------------------------------------------*
45892 * Partial Init method
45893 * -----------------------------------------------------------------------------*/
45894
45895 #ifdef SWIG_LINK_RUNTIME
45896 #ifdef __cplusplus
45897 extern "C"
45898 #endif
45899 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
45900 #endif
45901
45902 #ifdef __cplusplus
45903 extern "C"
45904 #endif
45905 SWIGEXPORT(void) SWIG_init(void) {
45906 static PyObject *SWIG_globals = 0;
45907 static int typeinit = 0;
45908 PyObject *m, *d;
45909 int i;
45910 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
45911
45912 /* Fix SwigMethods to carry the callback ptrs when needed */
45913 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
45914
45915 m = Py_InitModule((char *) SWIG_name, SwigMethods);
45916 d = PyModule_GetDict(m);
45917
45918 if (!typeinit) {
45919 #ifdef SWIG_LINK_RUNTIME
45920 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
45921 #else
45922 # ifndef SWIG_STATIC_RUNTIME
45923 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
45924 # endif
45925 #endif
45926 for (i = 0; swig_types_initial[i]; i++) {
45927 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
45928 }
45929 typeinit = 1;
45930 }
45931 SWIG_InstallConstants(d,swig_const_table);
45932
45933
45934 #ifndef wxPyUSE_EXPORT
45935 // Make our API structure a CObject so other modules can import it
45936 // from this module.
45937 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
45938 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
45939 Py_XDECREF(cobj);
45940 #endif
45941
45942 {
45943 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
45944 }
45945 {
45946 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
45947 }
45948 {
45949 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
45950 }
45951 {
45952 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
45953 }
45954 {
45955 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
45956 }
45957 {
45958 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
45959 }
45960 {
45961 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
45962 }
45963 {
45964 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
45965 }
45966 {
45967 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
45968 }
45969 {
45970 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
45971 }
45972 {
45973 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
45974 }
45975 {
45976 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
45977 }
45978 {
45979 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
45980 }
45981 {
45982 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
45983 }
45984 {
45985 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
45986 }
45987 {
45988 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
45989 }
45990 {
45991 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
45992 }
45993 {
45994 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
45995 }
45996 {
45997 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
45998 }
45999 {
46000 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46001 }
46002 {
46003 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46004 }
46005 {
46006 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46007 }
46008 {
46009 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46010 }
46011 {
46012 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46013 }
46014 {
46015 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46016 }
46017 {
46018 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46019 }
46020 {
46021 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46022 }
46023 {
46024 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46025 }
46026 {
46027 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46028 }
46029 {
46030 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46031 }
46032 {
46033 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46034 }
46035 {
46036 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46037 }
46038 {
46039 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46040 }
46041 {
46042 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46043 }
46044 {
46045 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46046 }
46047 {
46048 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46049 }
46050 {
46051 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46052 }
46053 {
46054 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46055 }
46056 {
46057 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46058 }
46059 {
46060 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46061 }
46062 {
46063 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46064 }
46065 {
46066 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46067 }
46068 {
46069 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46070 }
46071 {
46072 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46073 }
46074 {
46075 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46076 }
46077 {
46078 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46079 }
46080 {
46081 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46082 }
46083 {
46084 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46085 }
46086 {
46087 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46088 }
46089 {
46090 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46091 }
46092 {
46093 PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
46094 }
46095 {
46096 PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
46097 }
46098 {
46099 PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
46100 }
46101 {
46102 PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
46103 }
46104 {
46105 PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
46106 }
46107 {
46108 PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
46109 }
46110 {
46111 PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
46112 }
46113 {
46114 PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
46115 }
46116 {
46117 PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
46118 }
46119 {
46120 PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
46121 }
46122 {
46123 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46124 }
46125 {
46126 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46127 }
46128 {
46129 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46130 }
46131 {
46132 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46133 }
46134 {
46135 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46136 }
46137 {
46138 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46139 }
46140 {
46141 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46142 }
46143 {
46144 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46145 }
46146 {
46147 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46148 }
46149 {
46150 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46151 }
46152 {
46153 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46154 }
46155 {
46156 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46157 }
46158 {
46159 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46160 }
46161 {
46162 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46163 }
46164 {
46165 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46166 }
46167 {
46168 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46169 }
46170 {
46171 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46172 }
46173 {
46174 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46175 }
46176 {
46177 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46178 }
46179 {
46180 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46181 }
46182 {
46183 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46184 }
46185 {
46186 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46187 }
46188 {
46189 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46190 }
46191 {
46192 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46193 }
46194 {
46195 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46196 }
46197 {
46198 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46199 }
46200 {
46201 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46202 }
46203 {
46204 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46205 }
46206 {
46207 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46208 }
46209 {
46210 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46211 }
46212 {
46213 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46214 }
46215 {
46216 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46217 }
46218 {
46219 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46220 }
46221 {
46222 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46223 }
46224 {
46225 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46226 }
46227 {
46228 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46229 }
46230 {
46231 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46232 }
46233 {
46234 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46235 }
46236 {
46237 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46238 }
46239 {
46240 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46241 }
46242 {
46243 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46244 }
46245 {
46246 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46247 }
46248 {
46249 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46250 }
46251 {
46252 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46253 }
46254 {
46255 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46256 }
46257 {
46258 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46259 }
46260 {
46261 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46262 }
46263 {
46264 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46265 }
46266 {
46267 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46268 }
46269 {
46270 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46271 }
46272 {
46273 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46274 }
46275 {
46276 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46277 }
46278 {
46279 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46280 }
46281 {
46282 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46283 }
46284 {
46285 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46286 }
46287 {
46288 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46289 }
46290 {
46291 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46292 }
46293 {
46294 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46295 }
46296 {
46297 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46298 }
46299 {
46300 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46301 }
46302 {
46303 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46304 }
46305 {
46306 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46307 }
46308 {
46309 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46310 }
46311 {
46312 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46313 }
46314 {
46315 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46316 }
46317 {
46318 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46319 }
46320 {
46321 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46322 }
46323 {
46324 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46325 }
46326 {
46327 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46328 }
46329 {
46330 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46331 }
46332 {
46333 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46334 }
46335 {
46336 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46337 }
46338 {
46339 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46340 }
46341 {
46342 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46343 }
46344 {
46345 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46346 }
46347 {
46348 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46349 }
46350 {
46351 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46352 }
46353 {
46354 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46355 }
46356 {
46357 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46358 }
46359 {
46360 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46361 }
46362 {
46363 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46364 }
46365 {
46366 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46367 }
46368 {
46369 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46370 }
46371 {
46372 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46373 }
46374 {
46375 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46376 }
46377 {
46378 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46379 }
46380 {
46381 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46382 }
46383 {
46384 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46385 }
46386 {
46387 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46388 }
46389 {
46390 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46391 }
46392 {
46393 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46394 }
46395 {
46396 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46397 }
46398 {
46399 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46400 }
46401 {
46402 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46403 }
46404 {
46405 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46406 }
46407 {
46408 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46409 }
46410 {
46411 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46412 }
46413 {
46414 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46415 }
46416 {
46417 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46418 }
46419 {
46420 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46421 }
46422 {
46423 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46424 }
46425 {
46426 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46427 }
46428 {
46429 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46430 }
46431 {
46432 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46433 }
46434 {
46435 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46436 }
46437 {
46438 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46439 }
46440 {
46441 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46442 }
46443 {
46444 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46445 }
46446 {
46447 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46448 }
46449 {
46450 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46451 }
46452 {
46453 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46454 }
46455 {
46456 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46457 }
46458 {
46459 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46460 }
46461 {
46462 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46463 }
46464 {
46465 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46466 }
46467 {
46468 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46469 }
46470 {
46471 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
46472 }
46473 {
46474 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
46475 }
46476 {
46477 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
46478 }
46479 {
46480 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
46481 }
46482 {
46483 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
46484 }
46485 {
46486 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
46487 }
46488 {
46489 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
46490 }
46491 {
46492 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
46493 }
46494 {
46495 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
46496 }
46497 {
46498 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
46499 }
46500 {
46501 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
46502 }
46503 {
46504 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
46505 }
46506 {
46507 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
46508 }
46509 {
46510 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
46511 }
46512 {
46513 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
46514 }
46515 {
46516 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
46517 }
46518 {
46519 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
46520 }
46521 {
46522 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
46523 }
46524 {
46525 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
46526 }
46527 {
46528 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
46529 }
46530 {
46531 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
46532 }
46533 {
46534 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
46535 }
46536 {
46537 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
46538 }
46539 {
46540 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
46541 }
46542 {
46543 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
46544 }
46545 {
46546 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
46547 }
46548 {
46549 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
46550 }
46551 {
46552 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
46553 }
46554 {
46555 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
46556 }
46557 {
46558 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
46559 }
46560 {
46561 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
46562 }
46563 {
46564 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
46565 }
46566 {
46567 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
46568 }
46569 {
46570 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
46571 }
46572 {
46573 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
46574 }
46575 {
46576 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
46577 }
46578 {
46579 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
46580 }
46581 {
46582 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
46583 }
46584 {
46585 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
46586 }
46587 {
46588 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
46589 }
46590 {
46591 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
46592 }
46593 {
46594 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
46595 }
46596 {
46597 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
46598 }
46599 {
46600 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
46601 }
46602 {
46603 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
46604 }
46605 {
46606 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
46607 }
46608 {
46609 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
46610 }
46611 {
46612 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
46613 }
46614 {
46615 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
46616 }
46617 {
46618 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
46619 }
46620 {
46621 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
46622 }
46623 {
46624 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
46625 }
46626 {
46627 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
46628 }
46629 {
46630 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
46631 }
46632 {
46633 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
46634 }
46635 {
46636 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
46637 }
46638 {
46639 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
46640 }
46641 {
46642 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
46643 }
46644 {
46645 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
46646 }
46647 {
46648 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
46649 }
46650 {
46651 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
46652 }
46653 {
46654 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
46655 }
46656 {
46657 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
46658 }
46659 {
46660 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
46661 }
46662 {
46663 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
46664 }
46665 {
46666 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
46667 }
46668 {
46669 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
46670 }
46671 {
46672 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
46673 }
46674 {
46675 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
46676 }
46677 {
46678 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
46679 }
46680 {
46681 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
46682 }
46683 {
46684 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
46685 }
46686 {
46687 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
46688 }
46689 {
46690 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
46691 }
46692 {
46693 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
46694 }
46695 {
46696 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
46697 }
46698 {
46699 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
46700 }
46701 {
46702 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
46703 }
46704 {
46705 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
46706 }
46707 {
46708 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
46709 }
46710 {
46711 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
46712 }
46713 {
46714 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
46715 }
46716 {
46717 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
46718 }
46719 {
46720 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
46721 }
46722 {
46723 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
46724 }
46725 {
46726 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
46727 }
46728 {
46729 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
46730 }
46731 {
46732 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
46733 }
46734 {
46735 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
46736 }
46737 {
46738 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
46739 }
46740 {
46741 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
46742 }
46743 {
46744 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
46745 }
46746 {
46747 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
46748 }
46749 {
46750 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
46751 }
46752 {
46753 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
46754 }
46755 {
46756 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
46757 }
46758 {
46759 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
46760 }
46761 {
46762 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
46763 }
46764 {
46765 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
46766 }
46767 {
46768 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
46769 }
46770 {
46771 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
46772 }
46773 {
46774 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
46775 }
46776 {
46777 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
46778 }
46779 {
46780 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
46781 }
46782 {
46783 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
46784 }
46785 {
46786 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
46787 }
46788 {
46789 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
46790 }
46791 {
46792 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
46793 }
46794 {
46795 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
46796 }
46797 {
46798 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
46799 }
46800 {
46801 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
46802 }
46803 {
46804 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
46805 }
46806 {
46807 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
46808 }
46809 {
46810 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
46811 }
46812 {
46813 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
46814 }
46815 {
46816 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
46817 }
46818 {
46819 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
46820 }
46821 {
46822 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
46823 }
46824 {
46825 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
46826 }
46827 {
46828 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
46829 }
46830 {
46831 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
46832 }
46833 {
46834 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
46835 }
46836 {
46837 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
46838 }
46839 {
46840 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
46841 }
46842 {
46843 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
46844 }
46845 {
46846 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
46847 }
46848 {
46849 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
46850 }
46851 {
46852 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
46853 }
46854 {
46855 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
46856 }
46857 {
46858 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
46859 }
46860 {
46861 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
46862 }
46863 {
46864 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
46865 }
46866 {
46867 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
46868 }
46869 {
46870 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
46871 }
46872 {
46873 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
46874 }
46875 {
46876 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
46877 }
46878 {
46879 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
46880 }
46881 {
46882 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
46883 }
46884 {
46885 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
46886 }
46887 {
46888 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
46889 }
46890 {
46891 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
46892 }
46893 {
46894 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
46895 }
46896 {
46897 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
46898 }
46899 {
46900 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
46901 }
46902 {
46903 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
46904 }
46905 {
46906 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
46907 }
46908 {
46909 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
46910 }
46911 {
46912 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
46913 }
46914 {
46915 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
46916 }
46917 {
46918 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
46919 }
46920 {
46921 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
46922 }
46923 {
46924 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
46925 }
46926 {
46927 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
46928 }
46929 {
46930 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
46931 }
46932 {
46933 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
46934 }
46935 {
46936 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
46937 }
46938 {
46939 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
46940 }
46941 {
46942 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
46943 }
46944 {
46945 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
46946 }
46947 {
46948 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
46949 }
46950 {
46951 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
46952 }
46953 {
46954 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
46955 }
46956 {
46957 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
46958 }
46959 {
46960 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
46961 }
46962 {
46963 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
46964 }
46965 {
46966 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
46967 }
46968 {
46969 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
46970 }
46971 {
46972 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
46973 }
46974 {
46975 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
46976 }
46977 {
46978 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
46979 }
46980 {
46981 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
46982 }
46983 {
46984 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
46985 }
46986 {
46987 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
46988 }
46989 {
46990 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
46991 }
46992 {
46993 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
46994 }
46995 {
46996 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
46997 }
46998 {
46999 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47000 }
47001 {
47002 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47003 }
47004 {
47005 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47006 }
47007 {
47008 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47009 }
47010 {
47011 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47012 }
47013 {
47014 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47015 }
47016 {
47017 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47018 }
47019 {
47020 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47021 }
47022 {
47023 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47024 }
47025 {
47026 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47027 }
47028 {
47029 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47030 }
47031 {
47032 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47033 }
47034 {
47035 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47036 }
47037 {
47038 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47039 }
47040 {
47041 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47042 }
47043 {
47044 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47045 }
47046 {
47047 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47048 }
47049 {
47050 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47051 }
47052 {
47053 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47054 }
47055 {
47056 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47057 }
47058 {
47059 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47060 }
47061 {
47062 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47063 }
47064 {
47065 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47066 }
47067 {
47068 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47069 }
47070 {
47071 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47072 }
47073 {
47074 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47075 }
47076 {
47077 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47078 }
47079 {
47080 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47081 }
47082 {
47083 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47084 }
47085 {
47086 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47087 }
47088 {
47089 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47090 }
47091 {
47092 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47093 }
47094 {
47095 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47096 }
47097 {
47098 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47099 }
47100 {
47101 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47102 }
47103 {
47104 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47105 }
47106 {
47107 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47108 }
47109 {
47110 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47111 }
47112 {
47113 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47114 }
47115 {
47116 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47117 }
47118 {
47119 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47120 }
47121 {
47122 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47123 }
47124 {
47125 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47126 }
47127 {
47128 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47129 }
47130 {
47131 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47132 }
47133 {
47134 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47135 }
47136 {
47137 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47138 }
47139 {
47140 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47141 }
47142 {
47143 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47144 }
47145 {
47146 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47147 }
47148 {
47149 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47150 }
47151 {
47152 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47153 }
47154 {
47155 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47156 }
47157 {
47158 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47159 }
47160 {
47161 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47162 }
47163 {
47164 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47165 }
47166 {
47167 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47168 }
47169 {
47170 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47171 }
47172 {
47173 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47174 }
47175 {
47176 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47177 }
47178 {
47179 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47180 }
47181 {
47182 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47183 }
47184 {
47185 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47186 }
47187 {
47188 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47189 }
47190 {
47191 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47192 }
47193 {
47194 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47195 }
47196 {
47197 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47198 }
47199 {
47200 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47201 }
47202 {
47203 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47204 }
47205 {
47206 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47207 }
47208 {
47209 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47210 }
47211 {
47212 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47213 }
47214 {
47215 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47216 }
47217 {
47218 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47219 }
47220 {
47221 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47222 }
47223 {
47224 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47225 }
47226 {
47227 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47228 }
47229 {
47230 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47231 }
47232 {
47233 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47234 }
47235 {
47236 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47237 }
47238 {
47239 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47240 }
47241 {
47242 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47243 }
47244 {
47245 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47246 }
47247 {
47248 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47249 }
47250 {
47251 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47252 }
47253 {
47254 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47255 }
47256 {
47257 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47258 }
47259 {
47260 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47261 }
47262 {
47263 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47264 }
47265 {
47266 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47267 }
47268 {
47269 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47270 }
47271 {
47272 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47273 }
47274 {
47275 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47276 }
47277 {
47278 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47279 }
47280 {
47281 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47282 }
47283 {
47284 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47285 }
47286 {
47287 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47288 }
47289 {
47290 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47291 }
47292 {
47293 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47294 }
47295 {
47296 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47297 }
47298 {
47299 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47300 }
47301 {
47302 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47303 }
47304 {
47305 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47306 }
47307 {
47308 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47309 }
47310 {
47311 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47312 }
47313 {
47314 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47315 }
47316 {
47317 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47318 }
47319 {
47320 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47321 }
47322 {
47323 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47324 }
47325 {
47326 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47327 }
47328 {
47329 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47330 }
47331 {
47332 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47333 }
47334 {
47335 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47336 }
47337 {
47338 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47339 }
47340 {
47341 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47342 }
47343 {
47344 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47345 }
47346 {
47347 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47348 }
47349 {
47350 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47351 }
47352 {
47353 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47354 }
47355 {
47356 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47357 }
47358 {
47359 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47360 }
47361 {
47362 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47363 }
47364 {
47365 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47366 }
47367 {
47368 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47369 }
47370 {
47371 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47372 }
47373 {
47374 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47375 }
47376 {
47377 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47378 }
47379 {
47380 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47381 }
47382 {
47383 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47384 }
47385 {
47386 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47387 }
47388 {
47389 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47390 }
47391 {
47392 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47393 }
47394 {
47395 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47396 }
47397 {
47398 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47399 }
47400 {
47401 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47402 }
47403 {
47404 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47405 }
47406 {
47407 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47408 }
47409 {
47410 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47411 }
47412 {
47413 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47414 }
47415 {
47416 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47417 }
47418 {
47419 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47420 }
47421 {
47422 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47423 }
47424 {
47425 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47426 }
47427 {
47428 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47429 }
47430 {
47431 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47432 }
47433 {
47434 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47435 }
47436 {
47437 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47438 }
47439 {
47440 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47441 }
47442 {
47443 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47444 }
47445 {
47446 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47447 }
47448 {
47449 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47450 }
47451 {
47452 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47453 }
47454 {
47455 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47456 }
47457 {
47458 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47459 }
47460 {
47461 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47462 }
47463 {
47464 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47465 }
47466 {
47467 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47468 }
47469 {
47470 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
47471 }
47472 {
47473 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
47474 }
47475 {
47476 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
47477 }
47478 {
47479 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
47480 }
47481 {
47482 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
47483 }
47484 {
47485 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
47486 }
47487 {
47488 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
47489 }
47490 {
47491 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
47492 }
47493 {
47494 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
47495 }
47496 {
47497 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
47498 }
47499 {
47500 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
47501 }
47502 {
47503 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
47504 }
47505 {
47506 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
47507 }
47508 {
47509 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
47510 }
47511 {
47512 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
47513 }
47514 {
47515 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
47516 }
47517 {
47518 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
47519 }
47520 {
47521 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
47522 }
47523 {
47524 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
47525 }
47526 {
47527 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
47528 }
47529 {
47530 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
47531 }
47532 {
47533 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
47534 }
47535 {
47536 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
47537 }
47538 {
47539 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
47540 }
47541 {
47542 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
47543 }
47544 {
47545 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
47546 }
47547 {
47548 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
47549 }
47550 {
47551 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
47552 }
47553 {
47554 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
47555 }
47556 {
47557 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
47558 }
47559 {
47560 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
47561 }
47562 {
47563 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
47564 }
47565 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
47566 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
47567 {
47568 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
47719 }
47720 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
47721 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
47722 {
47723 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
47730 }
47731
47732 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
47733
47734
47735 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
47736
47737 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
47738 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
47739 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
47740 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
47741 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
47742 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
47743 {
47744 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
47787 }
47788 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
47789 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
47790 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
47791 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
47792 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
47793 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
47794 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
47795 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
47796 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
47797 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
47798 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
47799 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
47800 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
47801 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
47802 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
47803 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
47804 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
47805 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
47806 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
47807 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
47808 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
47809 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
47810 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
47811 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
47812 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
47813 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
47814 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
47815 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
47816 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
47817 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
47818 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
47819 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
47820 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
47821 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
47822 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
47823 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
47824 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
47825 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
47826 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
47827 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
47828 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
47829 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
47830 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
47831 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
47832 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
47833 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
47834 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
47835 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
47836 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
47837 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
47838 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
47839 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
47840 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
47841 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
47842 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
47843 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
47844 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
47845 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
47846 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
47847 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
47848 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
47849 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
47850 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
47851 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
47852 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
47853 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
47854 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
47855 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
47856 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
47857 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
47858 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
47859 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
47860 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
47861 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
47862 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
47863 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
47864 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
47865 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
47866 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
47867 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
47868 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
47869 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
47870 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
47871 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
47872 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
47873 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
47874 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
47875 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
47876 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
47877 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
47878 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
47879 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
47880 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
47881 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
47882 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
47883 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
47884 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
47885 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
47886 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
47887 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
47888 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
47889 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
47890 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
47891 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
47892 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
47893 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
47894 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
47895 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
47896 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
47897 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
47898 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
47899 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
47900 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
47901 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
47902 {
47903 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
47955 }
47956 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
47957 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
47958 {
47959 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
47972 }
47973 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
47974 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
47975 {
47976 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
47983 }
47984 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
47985 {
47986 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48041 }
48042
48043 // Initialize threading, some globals and such
48044 __wxPyPreStart(d);
48045
48046
48047 // Although these are defined in __version__ they need to be here too so
48048 // that an assert can be done to ensure that the wxPython and the wxWindows
48049 // versions match.
48050 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48051 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48052 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48053
48054 }
48055
wxWidgets (Impactor)